sst/core/activity.h

// Copyright 2009-2015 Sandia Corporation. Under the terms
// of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2015, Sandia Corporation
// 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_ACTIVITY_H
#define SST_CORE_ACTIVITY_H

#include <sst/core/sst_types.h>
#include <sst/core/serialization.h>

#include <sst/core/output.h>
#include <sst/core/mempool.h>

#include <cstring>
#include <errno.h>

// Default Priority Settings
#define STOPACTIONPRIORITY     01
#define SYNCPRIORITY           25
#define INTROSPECTPRIORITY     30
#define CLOCKPRIORITY          40
#define EVENTPRIORITY          50
#define MEMEVENTPRIORITY       50
#define BARRIERPRIORITY        75
#define ONESHOTPRIORITY        80
#define STATISTICCLOCKPRIORITY 85
#define FINALEVENTPRIORITY     98
#define EXITPRIORITY           99

namespace SST {

/** Base class for all Activities in the SST Event Queue */
class Activity {
public:
    Activity() {}
    virtual ~Activity() {}

    /** Function which will be called when the time for this Activity comes to pass. */
    virtual void execute(void) = 0;

    /** Comparator class to use with STL container classes. */
    class less_time_priority {
    public:
        /** Compare based off pointers */
        inline bool operator()(const Activity* lhs, const Activity* rhs) {
            if (lhs->delivery_time == rhs->delivery_time ) return lhs->priority < rhs->priority;
            else return lhs->delivery_time < rhs->delivery_time;
        }

        /** Compare based off references */
        inline bool operator()(const Activity& lhs, const Activity& rhs) {
            if (lhs.delivery_time == rhs.delivery_time ) return lhs.priority < rhs.priority;
            else return lhs.delivery_time < rhs.delivery_time;
        }
    };

    /** To use with STL priority queues, that order in reverse. */
    class pq_less_time_priority {
    public:
        /** Compare based off pointers */
        inline bool operator()(const Activity* lhs, const Activity* rhs) const {
            if ( lhs->delivery_time == rhs->delivery_time ) {
                if ( lhs->priority == rhs->priority ) {
                    /* TODO:  Handle 64-bit wrap-around */
                    return lhs->queue_order > rhs->queue_order;
                }
                return lhs->priority > rhs->priority;
            }
            return lhs->delivery_time > rhs->delivery_time;
        }

        /** Compare based off references */
        inline bool operator()(const Activity& lhs, const Activity& rhs) {
            if ( lhs.delivery_time == rhs.delivery_time ) {
                if ( lhs.priority == rhs.priority ) {
                    /* TODO:  Handle 64-bit wrap-around */
                    return lhs.queue_order > rhs.queue_order;
                }
                return lhs.priority > rhs.priority;
            }
            return lhs.delivery_time > rhs.delivery_time;
        }
    };

    /** Comparator class to use with STL container classes. */
    class less_time {
    public:
        /** Compare pointers */
        inline bool operator()(const Activity* lhs, const Activity* rhs) {
            return lhs->delivery_time < rhs->delivery_time;
        }

        /** Compare references */
        inline bool operator()(const Activity& lhs, const Activity& rhs) {
            return lhs.delivery_time < rhs.delivery_time;
        }
    };

    /** Set the time for which this Activity should be delivered */
    void setDeliveryTime(SimTime_t time) {
        delivery_time = time;
    }

    /** Return the time at which this Activity will be delivered */
    inline SimTime_t getDeliveryTime() const {
        return delivery_time;
    }

    /** Return the Priority of this Activity */
    inline int getPriority() const {
        return priority;
    }

    /** Generic print-print function for this Activity.
     * Subclasses should override this function.
     */
    virtual void print(const std::string& header, Output &out) const {
        out.output("%s Generic Activity to be delivered at %" PRIu64 " with priority %d\n",
                header.c_str(), delivery_time, priority);
    }

#ifdef __SST_DEBUG_EVENT_TRACKING__
    virtual void printTrackingInfo(const std::string& header, Output &out) const {
    }
#endif

    /** Set a new Queue order */
    void setQueueOrder(uint64_t order) {
        queue_order = order;
    }

#ifdef USE_MEMPOOL
    /** Allocates memory from a memory pool for a new Activity */
        void* operator new(std::size_t size) throw()
    {
        /* 1) Find memory pool
         * 1.5) If not found, create new
         * 2) Alloc item from pool
         * 3) Append PoolID to item, increment pointer
         */
        size_t poolSize = memPools.size();
        Core::MemPool *pool = NULL;
        uint32_t poolID = 0;
        for ( uint32_t i = 0 ; i < poolSize ; i++ ) {
            if ( memPools[i].first == size ) {
                pool = memPools[i].second;
                poolID = i;
                break;
            }
        }
        if ( NULL == pool ) {
            // MemPool size is element size + our poolID
            pool = new Core::MemPool(size+sizeof(uint32_t));
            memPools.push_back(std::make_pair(size, pool));
            poolID = memPools.size() - 1;
        }
        uint32_t *ptr = (uint32_t*)pool->malloc();
        if ( !ptr ) {
            fprintf(stderr, "Memory Pool failed to allocate a new object.  Error: %s\n", strerror(errno));
            return NULL;
        }
        *ptr = poolID;
        return (void*)(ptr+1);
    }


    /** Returns memory for this Activity to the appropriate memory pool */
        void operator delete(void* ptr)
    {
        /* 1) Decrement pointer
         * 2) Determine Pool ID
         * 2b) Set ID field to FFFFFFF to allow tracking
         * 3) Return to pool
         */
        uint32_t *ptr8 = ((uint32_t*)ptr) - 1;
        uint32_t poolID = *ptr8;
        *ptr8 = 0xffffffff;
        Core::MemPool* pool = memPools[poolID].second;

        pool->free(ptr8);
    }
    void operator delete(void* ptr, std::size_t sz){
        /* 1) Decrement pointer
         * 2) Determine Pool ID
         * 3) Return to pool
         */
        uint32_t *ptr8 = ((uint32_t*)ptr) - 1;
        uint32_t poolID = *ptr8;
        *ptr8 = 0xffffffff;
        Core::MemPool* pool = memPools[poolID].second;

        pool->free(ptr8);
    };
    
    static void getMemPoolUsage(uint64_t& bytes, uint64_t& active_activities) {
        bytes = 0;
        active_activities = 0;
        for ( uint32_t i = 0; i < Activity::memPools.size(); i++ ) {
            std::pair<size_t, Core::MemPool*> entry = Activity::memPools[i];
            bytes += entry.second->getBytesMemUsed();
            active_activities += entry.second->getUndeletedEntries();
        }
    }
    
    static void printUndeletedActivites(const std::string& header, Output &out, SimTime_t before = MAX_SIMTIME_T) {
        for ( uint32_t i = 0; i < Activity::memPools.size(); i++ ) {
            std::pair<size_t, Core::MemPool*> entry = Activity::memPools[i];
            const std::list<uint8_t*>& arenas = entry.second->getArenas();
            size_t arenaSize = entry.second->getArenaSize();
            size_t elemSize = entry.second->getElementSize();
            size_t nelem = arenaSize / elemSize;
            for ( auto iter = arenas.begin(); iter != arenas.end(); ++iter ) {
                for ( size_t j = 0; j < nelem; j++ ) {
                    uint32_t* ptr = (uint32_t*)((*iter) + (elemSize*j));
                    if ( *ptr != 0xFFFFFFFF ) {
                        Activity* act = (Activity*)(ptr + 1);
                        if ( act->delivery_time <= before ) {
                            act->print(header, out);
#ifdef __SST_DEBUG_EVENT_TRACKING__
                            act->printTrackingInfo(header + "    ", out);
#endif
                        }
                    }
                }
            }
        }
    }
    
#endif

    
protected:
    /** Set the priority of the Activity */
    void setPriority(int priority) {
        this->priority = priority;
    }


private:
    uint64_t  queue_order;
    SimTime_t delivery_time;
    int       priority;
#ifdef USE_MEMPOOL
        static std::vector<std::pair<size_t, Core::MemPool*> > memPools;
#endif

    friend class boost::serialization::access;
    template<class Archive>
    void
    serialize(Archive & ar, const unsigned int version )
    {
        ar & BOOST_SERIALIZATION_NVP(delivery_time);
        ar & BOOST_SERIALIZATION_NVP(priority);
    }
};

} //namespace SST

BOOST_CLASS_EXPORT_KEY(SST::Activity)

#endif // SST_CORE_ACTIVITY_H

---