coreTest_SharedObjectComponent.h

// Copyright 2009-2021 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2021, NTESS
// All rights reserved.
//
// Portions are copyright of other developers:
// See the file CONTRIBUTORS.TXT in the top level directory
// the distribution for more information.
//
// 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 _CORETESTSHAREDOBJECT_H
#define _CORETESTSHAREDOBJECT_H

#include <sst/core/component.h>
#include <sst/core/output.h>
#include <sst/core/shared/sharedArray.h>
#include <sst/core/shared/sharedMap.h>
#include <sst/core/shared/sharedSet.h>

namespace SST {
namespace CoreTestSharedObjectsComponent {

// Class so that we can check to see if the equivalence check works
// for sets
struct setItem : public SST::Core::Serialization::serializable {
    int key;
    int value;

    setItem() :
        key(0),
        value(0)
    {}

    setItem(int key, int value) :
        key(key),
        value(value)
    {}

    bool operator<(const setItem& lhs) const {
        return key < lhs.key;
    }

    bool operator==(const setItem& lhs) const {
        if ( key != lhs.key ) return false;
        if ( value != lhs.value ) return false;
        return true;
    }

    void serialize_order(SST::Core::Serialization::serializer& ser) override {
        ser & key;
        ser & value;
    }

    ImplementSerializable(SST::CoreTestSharedObjectsComponent::setItem);

};

class coreTestSharedObjectsComponent : public SST::Component
{
public:

    // REGISTER THIS COMPONENT INTO THE ELEMENT LIBRARY
    SST_ELI_REGISTER_COMPONENT(
        coreTestSharedObjectsComponent,
        "coreTestElement",
        "coreTestSharedObjectsComponent",
        SST_ELI_ELEMENT_VERSION(1,0,0),
        "Test for SharedObjects",
        COMPONENT_CATEGORY_UNCATEGORIZED
    )

    SST_ELI_DOCUMENT_PARAMS(
        { "object_type", "Type of object to test ( array | map | set )", "array"},
        { "num_entities", "Number of entities in the sim", "12"},
        { "myid", "ID Number (0 <= myid < num_entities)", nullptr},
        { "full_initialization", "If true, id 0 will initialize whole array, otherwise each id will contribute", "true"},
        { "multiple_initializers", "If doing full_initialization, this will cause ID N-1 to also initialize array", "false"},
        { "conflicting_write", "Controls whether a conflicting write is done when full_initialization and multiple_initializers are turned on (otherwise it has no effect)", "false"},
        { "verify_mode", "Sets verify mode for SharedArray ( FE | INIT | NONE )", "INIT" },
        { "late_write", "Controls whether a late write is done", "false" },
        { "publish", "Controls whether publish() is called or not", "true"},
        { "double_initialize", "If true, initialize() will be called twice", "false" },
        { "late_initialize", "If true, initialize() will be called during setup instead of in constructor", "false" }
    )

    // Optional since there is nothing to document
    SST_ELI_DOCUMENT_STATISTICS(
    )

    // Optional since there is nothing to document
    SST_ELI_DOCUMENT_PORTS(
    )

    // Optional since there is nothing to document
    SST_ELI_DOCUMENT_SUBCOMPONENT_SLOTS(
    )

    coreTestSharedObjectsComponent(SST::ComponentId_t id, SST::Params& params);
    ~coreTestSharedObjectsComponent() {}

    void init(unsigned int phase) override;
    void setup() override;
    void finish() override;
    void complete(unsigned int phase) override;

    bool tick(SST::Cycle_t);
private:
    Output out;

    bool test_array;
    bool test_map;
    bool test_set;

    int myid;
    int num_entities;

    int count;
    bool check;
    bool late_write;
    bool pub;
    bool late_initialize;

    Shared::SharedArray<int> array;
    Shared::SharedMap<int,int> map;
    Shared::SharedSet<setItem> set;
};

}
}

#endif