coreTest_MemPoolTest.h

// Copyright 2009-2025 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2025, NTESS
// All rights reserved.
//
// This file is part of the SST software package. For license
// information, see the LICENSE file in the top level directory of the
// distribution.

#ifndef SST_CORE_CORETEST_MEMPOOLTEST_H
#define SST_CORE_CORETEST_MEMPOOLTEST_H

#include "sst/core/component.h"
#include "sst/core/link.h"

#include <cstdint>
#include <string>
#include <vector>

namespace SST::CoreTestMemPoolTest {

// We'll have 4 different sized events

class MemPoolTestEvent1 : public SST::Event
{
public:
    MemPoolTestEvent1() :
        SST::Event()
    {}

    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        Event::serialize_order(ser);
        SST_SER(array);
    }

    ImplementSerializable(SST::CoreTestMemPoolTest::MemPoolTestEvent1);

    std::string toString() const override
    {
        return std::string("MemPoolTestEvent1 to be delivered at ") + std::to_string(getDeliveryTime());
    }

private:
    uint64_t array[1];
};

class MemPoolTestEvent2 : public SST::Event
{
public:
    MemPoolTestEvent2() :
        SST::Event()
    {}

    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        Event::serialize_order(ser);
        SST_SER(array);
    }

    ImplementSerializable(SST::CoreTestMemPoolTest::MemPoolTestEvent2);

    std::string toString() const override
    {
        return std::string("MemPoolTestEvent2 to be delivered at ") + std::to_string(getDeliveryTime());
    }

private:
    uint64_t array[2];
};

class MemPoolTestEvent3 : public SST::Event
{
public:
    MemPoolTestEvent3() :
        SST::Event()
    {}

    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        Event::serialize_order(ser);
        SST_SER(array);
    }

    ImplementSerializable(SST::CoreTestMemPoolTest::MemPoolTestEvent3);

    std::string toString() const override
    {
        return std::string("MemPoolTestEvent3 to be delivered at ") + std::to_string(getDeliveryTime());
    }

private:
    uint64_t array[3];
};

class MemPoolTestEvent4 : public SST::Event
{
public:
    MemPoolTestEvent4() :
        SST::Event()
    {}

    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        Event::serialize_order(ser);
        SST_SER(array);
    }

    ImplementSerializable(SST::CoreTestMemPoolTest::MemPoolTestEvent4);

    std::string toString() const override
    {
        return std::string("MemPoolTestEvent4 to be delivered at ") + std::to_string(getDeliveryTime());
    }

private:
    uint64_t array[4];
};

class MemPoolTestPerformanceEvent : public SST::Event
{
public:
    MemPoolTestPerformanceEvent() :
        SST::Event()
    {}

    double rate;

    void serialize_order(SST::Core::Serialization::serializer& ser) override
    {
        Event::serialize_order(ser);
        SST_SER(rate);
    }

    ImplementSerializable(SST::CoreTestMemPoolTest::MemPoolTestPerformanceEvent);
};


// Class will just send messages to other side of link.  They can be
// configured to send different size events to test the mempool
// overflow feature
class MemPoolTestComponent : public SST::Component
{
public:
    SST_ELI_REGISTER_COMPONENT(
        MemPoolTestComponent,
        "coreTestElement",
        "memPoolTestComponent",
        SST_ELI_ELEMENT_VERSION(1,0,0),
        "Test MemPool overflow",
        COMPONENT_CATEGORY_UNCATEGORIZED
    )

    SST_ELI_DOCUMENT_PARAMS(
        { "event_size", "Size of event to sent (valid sizes: 1-4).", "1" },
        { "initial_events", "Number of events to send to each other component", "256" },
        { "undeleted_events", "Number of events to leave undeleted", "0" },
        { "check_overflow", "Check to see whether MemPool overflow is working correctly", "true"}
    )

    SST_ELI_DOCUMENT_PORTS(
        {"port%d", "Links to other test components", { "CoreTestMemPoolTest.MemPoolTestEvent", "" } }
    )

    SST_ELI_DOCUMENT_ATTRIBUTES(
        { "test_element", "true" }
    )

    MemPoolTestComponent(ComponentId_t id, Params& params);
    ~MemPoolTestComponent() {}

    void eventHandler(Event* ev, int port);
    void setup() override;
    void finish() override;
    void complete(unsigned int phase) override;

private:
    int                event_size;
    std::vector<Link*> links;
    int                events_sent;
    int                events_recv;
    int                initial_events;
    double             event_rate;
    int                undeleted_events;
    bool               check_overflow;

    Event* createEvent();
};

} // namespace SST::CoreTestMemPoolTest

#endif // SST_CORE_CORETEST_COMPONENT_H