scProcessor.h

Go to the documentation of this file.

 
 /*  @author János Végh (jvegh)
 *  @bug No known bugs.
 */
 
#ifndef SCPROCESSOR_H
#define SCPROCESSOR_H
#include "Utils.h"
#include <map>
#include <QString>
#include "AbstractTopology.h"
 
#include "scClusterBus.h" //#include "scGridPoint.h"
//#include "scBenchmarkingHead.h" // Contains conditional compiles
 
//#include "scClusterBusArbiter.h"
 class scClusterBusMemoryFast;
 class scClusterBusMemorySlow;
 class scClusterBusArbiter;
  extern scClusterBusMemorySlow *MainMemory;
 
typedef struct{
        sc_in< sc_dt::sc_uint<MAX_GRIDPOINTS> >
     Denied
    ,Allocated
    ,PreAllocated
    ,Available
    ;
} TopologySignalPort_t, *TopologySignalPort_Ptr;
 
typedef struct{
        sc_signal<sc_dt::sc_uint<MAX_GRIDPOINTS>>
     Denied
    ,Allocated
    ,PreAllocated
    ,Available
        ;
} TopologySignal_t, *TopologySignal_Ptr;
 
// The relation of the gridpoints to the topology
typedef struct{
        SC_GRIDPOINT_MASK_TYPE
     Denied             
    ,Allocated          
    ,PreAllocated       
    ,Available          
        // This one is not a signal, just stored with the signal masks
    ,PreAllocatedForTopology 
    ;
} TopologyMask_t, *TopologyMask_Ptr;
 
typedef enum { cpt_Head, cpt_Member, cpt_Neighbor, cpt_AnyCore} CorePreference_t;
// These preference modes can be selected when asking for a new core
typedef enum {
                tpt_Allocated,    
                tpt_Preallocated, 
                tpt_Core,    
                tpt_Neighbor, 
                tpt_Another, 
                tpt_AnyThread} ThreadPreference_t;
 
typedef pair<string,scGridPoint*> GridModuleItem;
 
using namespace std;
// The modules can be the head of the cluster, a member of a cluster, or neither (stand-alone)
// These are the standard offsets of the neighbors in the order of
// the hexagonal Cluster Grid:  Head, N, NE, SE, S, SW, NW
 
// Here a two-dimensional topology is assumed
class scProcessor : public AbstractTopology, public sc_core::sc_module
{
    //Port declarations
        TopologySignalPort_t
    msSignalPort[MAX_HTHREADS];
        TopologySignal_t
    msSignal[MAX_HTHREADS];
  public:
//        sc_in_clk
//    clock; ///< This clock drives the bus
        scClusterBus*
    mClusterBus;    
        scClusterBusMemoryFast* 
    mClusterMemoryFast; 
        scClusterBusArbiter*
    mClusterBusArbiter; 
        scClusterBus*
    ClusterBus_Get(void){   return mClusterBus;}
    scProcessor(sc_core::sc_module_name nm, vector<scGridPoint*> Specials, bool StandAlone);
    SC_HAS_PROCESS(scProcessor); // Will be defined in separate file
    ~scProcessor(void);
    void RefreshGUI(scGridPoint & G);
        void
    Reset(void);
//        void
  //  CheckIGPCBs();
        scGridPoint*
    ClusterHead_Get(int i)
        { return dynamic_cast<scGridPoint*>(AbstractTopology::ClusterHead_Get(i)); }
     scGridPoint *ByPointer_Get(scGridPoint *GP) 
        {return dynamic_cast<scGridPoint *>(GP);}
 
    scGridPoint* ByIndex_Get(const int X, const int Y) 
        { return dynamic_cast<scGridPoint*>(AbstractTopology::ByIndex_Get(X, Y));}
    scGridPoint* ByPosition_Get(const int X, const int Y)
        { return dynamic_cast<scGridPoint*>(AbstractTopology::ByPosition_Get(X, Y));}
    scGridPoint* ByClusterAddress_Get(ClusterAddress_t CA)
    { return dynamic_cast<scGridPoint*>(AbstractTopology::ByClusterAddress_Get(CA));}
    scGridPoint* ClusterHeadOfMember_Get(scGridPoint* GP)
    { return dynamic_cast<scGridPoint*>(AbstractTopology::ClusterHeadOfMember_Get(GP));}
    scGridPoint* ByClusterMember_Get(unsigned short int CN, ClusterNeighbor CM= cm_Head)
    { return dynamic_cast<scGridPoint*>(AbstractTopology::ByClusterMember_Get(CN,CM));}
    scGridPoint* ByID_Get(int N) // Get a gridpoint by its ID
    { return dynamic_cast<scGridPoint*>(AbstractTopology::ByID_Get(N));}
     scGridPoint* ByIDMask_Get(SC_GRIDPOINT_MASK_TYPE Mask)
     { return ByID_Get(MaskToID(Mask));}
    scGridPoint* ByClusterPointer_Get(scGridPoint* GP, ClusterNeighbor N)
        { return dynamic_cast<scGridPoint*>(AbstractTopology::ByClusterPointer_Get(GP,N));}
    // Simple accessor functions, PC related stuff
        scHThread*
    ByName_Get(string N);
 /*       SC_GRIDPOINT_MASK_TYPE
    ChildrenMask_Get(SC_HTHREAD_ID_TYPE H=0)
    { return msChildrenMask[H];}///< Return which cores are allocated for us
        void
    ChildrenMask_Set(SC_GRIDPOINT_MASK_TYPE M, SC_HTHREAD_ID_TYPE H=0)
    {   msChildrenMask[H] = M;}///< Set mask of our children
        void
    ChildrenMaskBit_Set(scGridPoint* C);  ///< Set the mask bit of the allocated cores
        void
    ChildrenMaskBit_Clear(scGridPoint* C);  ///< Clear the mask bit of the allocated cores
*/    void Populate(vector<scGridPoint*>& Specials);
    void ConnectIGPCBs(void);
    void ConnectClusterHeadsToBus(scClusterBus* Bus);
        SC_GRIDPOINT_MASK_TYPE
    DeniedMask_Get(SC_HTHREAD_ID_TYPE H=0) {  return msSignalMask[H].Denied;}
         void
    DeniedMaskBit_Set(scGridPoint* GP, bool P=true);
         SC_GRIDPOINT_MASK_TYPE
    AllocatedMask_Get(SC_HTHREAD_ID_TYPE H=0) {  return msSignalMask[H].Allocated;}
         void
    AllocatedMask_Set(SC_GRIDPOINT_MASK_TYPE M, SC_HTHREAD_ID_TYPE H=0) {msSignalMask[H].Allocated = M;}
          void
    AllocatedMaskBit_Set(scGridPoint* GP, bool P=true);
          SC_GRIDPOINT_MASK_TYPE
    PreAllocatedMask_Get(SC_HTHREAD_ID_TYPE H=0) {  return msSignalMask[H].PreAllocated;}
         void
    PreAllocatedMask_Set(SC_GRIDPOINT_MASK_TYPE M, SC_HTHREAD_ID_TYPE H=0) { msSignalMask[H].PreAllocated = M;}
           void
    PreAllocatedMaskBit_Set(scGridPoint* GP, bool P=true);
        SC_GRIDPOINT_MASK_TYPE
    AvailableMask_Get(SC_HTHREAD_ID_TYPE H=0)
       {  return ~UnavailableMask_Get(H);}
        SC_GRIDPOINT_MASK_TYPE
    UnavailableMask_Get(SC_HTHREAD_ID_TYPE H=0);
        string
    StringOfMessage_Get(scIGPMessage* M);
         string
    StringOfRegisters_Get(scIGPMessage* M);
         string
    StringOfCooperation_Get(scIGPMessage* M);
         string
    StringOfID_Get(scHThread* H);
         string
    StringOfNeural_Get(scIGPMessage* M);
        string
    StringOfMemory_Get(scIGPMessage* M);
        string
    StringOfSender_Get(scIGPMessage* M);
        string
    StringOfReceiver_Get(scIGPMessage* M);
        string
    StringOfTime_Get(void){ return sc_time_to_nsec_Get();}
        string 
    RegisterName_Get(int Index);
        virtual scGridPoint*
    ChildAllocateFor(scGridPoint* Parent, CorePreference_t Pref = cpt_AnyCore); 
        virtual scHThread*
    HThreadAllocateFor(scHThread* Parent, HThreadPreference_t Pref = hpt_Any);
        scGridPoint*
    ChildPreAllocateFor(scGridPoint* Parent, CorePreference_t Pref = cpt_AnyCore); 
        scGridPoint*
    ChildFindFor(scGridPoint* Parent, CorePreference_t CPT); 
 
        void
    Child_Insert(scHThread* C);
        void
    Child_Remove(scHThread* C);
        int
    ChildCount_Get(void){return mChildren.size();}
        int
    Child_Find(scHThread* C);
 
        scHThread*
    HThreadFindFor(scHThread* Parent, HThreadPreference_t HPT); 
 
        virtual scGridPoint*
    doQCREATE(scGridPoint* TheParent, scGridPoint* TheChild,
                SC_GRIDPOINT_MASK_TYPE CloneMask,
                SC_GRIDPOINT_MASK_TYPE BackLinkMask,
                CorePreference_t CPT);
        virtual scHThread*
    doReboot(SC_ADDRESS_TYPE A){ return (scHThread*)NULL;}
 
//        scHThread*
//    ByAliasName_Get(string N);
        string
    StringOfClusterAddress_Get(scGridPoint* GP)
    {
        assert(GP);
        return GP->StringOfClusterAddress_Get();
    }
    struct{
            sc_core::sc_event
        START,
        STOP,
        SUSPEND,
        RESUME,
        HALT,
        QTERM,
        MasksChanged;   
    }EVENT_PROCESSOR;
        TopologyMask_t
     msSignalMask[MAX_HTHREADS];
        string 
    PrologString_Get(void);
        scProcessor* Processor_Get(void)
    { return this;}
         SC_GRIDPOINT_MASK_TYPE
    PreAllocatedForProcMask_Get(SC_HTHREAD_ID_TYPE H=0){ return msMask[H].PreAllocatedForTopology;}
    // Simple accessor functions, PC related stuff
         void
    PreAllocatedForProcMaskBit_Set(scGridPoint* C, bool V);
        bool
    IsSuspended(void){ return msSuspended;}
        void
    SuspendedBit_Set(bool b){msSuspended = b;}
        bool
    Halted_Get(void) { return msHalted;}
        void
    Halted_Set(bool B){ msHalted = B;}
//        uint32_t // Just for testing
//    DWord_Get(SC_ADDRESS_TYPE Address){ return MainMemory->DWord_Get(Address);}
 
        void
    Initialize_method(void);
        virtual void
    Reboot(void);
        int16_t
    InstanceCount_Get(void) {return mInstanceCount % 50;}
        string  // Return the string ID of the thread
    StringID_Get(scHThread* H);
        scHThread*
    HThreadByClusterAddress_Get(ClusterAddress_t CA)
        { return ByClusterAddress_Get(CA)->HThread_Get(CA.HThread);}
        bool
   Alias_Add(string A, scHThread* HT)
          { mAliases[A] = HT;
          return false;}
        bool
    StringOfAliasName_Set(string A, scHThread *H);
           void
       HandleAliases(string FileName);
           virtual void
       ReadTheThreeLevels(QString MyGroup);
           void
       HandleAliasesPass(string FileName, bool Pass2);
           void AliasesClear(void)
           {mAliases.clear();}
  protected:
        void
    SignalMaskBit_Set(SC_GRIDPOINT_MASK_TYPE &Signal, SC_GRIDPOINT_MASK_TYPE GPMask,
                      bool State, string S);
        void
    START_thread(void);
        void
    HALT_thread(void);
        void
    SUSPEND_thread(void);
        void
    RESUME_thread(void);
         void
    SetMasks_method(void);
         void
    QTERM_method(void);
         std::map<string,scHThread*>
     mAliases;      
        TopologyMask_t
    msMask[MAX_HTHREADS];
//        SC_GRIDPOINT_MASK_TYPE
//    msChildrenMask[MAX_HTHREADS];
        vector<scHThread*>
    mChildren;  // HThreads are allocated for directly to processor
        bool
    msSuspended;
        bool
    msHalted;  
        uint16_t
    mInstanceCount; // How many time was instantiated immediate QT
};// of class scProcessor
 
#endif // SCPROCESSOR_H