scGridPoint.h

Go to the documentation of this file.

 
 /*  @author János Végh (jvegh)
 *  @bug No known bugs.
 */
 
#ifndef scGridPoint_h
#define scGridPoint_h
 
//#include <iomanip>      // std::setfill, std::setw
//#include <systemc>
// "tlm.h"
//#include "tlm_utils/simple_initiator_socket.h"
//#include <cstring>
//#include "scIGPCB.h" //#include "scIGPfifo.h"
#include "scIGPMessage_if.h"
//#include "scLatchFIFO.h"
//#include "scGPMessagefifo.h"
//#include "scHThread.h" // Included by "scIGPMessage_if.h"
 
// These macros are used for benchmarking
// The work storage variable are defined as member functions, at the end
// Reset is done in constructor; the sum is collected and may be read in destructor
// The work storage also usable in derived classes
#define MAKE_TIME_BENCHMARKING  // uncomment to measure the time with benchmarking macros
#include "MacroTimeBenchmarking.h"    // Must be after the define to have its effect
#define SC_MAKE_TIME_BENCHMARKING  // uncomment to measure the time with benchmarking macros
#include "MacroScTimeBenchmarking.h"    // Must be after the define to have its effect
 
 
#include "scGridEnumTypes.h"    // Single bits related to operation
#include "scIGPMessage.h"
 
class scProcessor;
class scIGPMessage;
class scClusterBus;
class scIGPCB;
class scSynapticConnect;
extern string sc_time_to_nsec_Get(const int d, const int w, sc_time T);
 
// Define execution time measuring macros, per module
// Define this anyhow; if false no code is generated
 
// Functions to find out which type of memory is addressed
bool IsMemory(ClusterAddress_t CA);     
bool IsMemory0(ClusterAddress_t CA);    
bool IsMemory1(ClusterAddress_t CA);    
bool IsMemory2(ClusterAddress_t CA);    
bool IsMemory3(ClusterAddress_t CA);    
 
class scGridPoint :  public GridPoint
        ,public scClusterBusSlave_if
        ,public scIGPMessage_if
{
    friend class scHThread; //friend class scAbstractNeurerConnection;
    friend class scSynapticConnect;
public:
    //Port declarations : scGridPoint status bits
        GridPointSignalPort_t
    msPort;   // Port declarations
 
//        std::unique_ptr< scClusterBusMaster_blocking  >  bus_port;
//  sc_port<scClusterBus_blocking_if*> bus_port;
 
    //Channel/Submodule* definitions
        // TLM-2 socket, defaults to 32-bits wide, base protocol
        // TLM-2 blocking transport method
        //virtual
//        void ICB_b_transport(const ClusterNeighbor Index, unsigned char* data, const int size );
        
     // Constructor declaration:
    scGridPoint(sc_core::sc_module_name nm, // Just the SystemC name
                  scProcessor* Processor, // The present system is prepared for one processor only, but ...
                  const GridPoint GP
                , bool StandAlone
                );
   ~scGridPoint();//{}
        SC_HAS_PROCESS(scGridPoint);  // We have the constructor in the .cpp file
        // Group dealing with identification
        // The physical ID and the corresponding mask cannot be changed
/*        SC_GRIDPOINT_ID_TYPE
    FETCHID_Get(void){   return msFETCHTHREADID;} ///< Get internal ID (sequence number) of the scGridPoint
        SC_GRIDPOINT_ID_TYPE
    EXECHID_Get(void){   return msEXECTHREADID;} ///< Get internal ID (sequence number) of the scGridPoint
    */
                void
        AddDefaultAliasNames(void) ;
        SC_GRIDPOINT_ID_TYPE    
    ID_Get(){return msID;}
        SC_GRIDPOINT_MASK_TYPE 
    IDMask_Get(void){   return msMask.ID;}
     // Directly HW-related functionality
        string 
    Name_Get(void){ return string(name());}
 
        void    
    AddHThread(unsigned int H, scHThread* P)
        {  assert(P);
           assert(H<MAX_HTHREADS);
            mHThreads[H] = P;}
        scHThread*
    AllocateAHThread(void);
        virtual void    
    CreateThreads(void);
        void
    Reset(void);
 
 
        void
    ResetForParent(scGridPoint* Parent);
        bool
    Deallocate(void);
        void
    RouteMessage(scIGPMessage* Message);
         void
    SendDirectMessageTo(scGridPoint* Target, scIGPMessage* Message);
        scGridPoint*
    Parent_Get(void) { return  msParent;}       
      void
    Parent_Set(scGridPoint *P) { msParent = P;} 
    // Implement the inter-gridpoint direct and inter-cluster bus  communication
        scIGPCB*    
    IGPCB_Get(ClusterNeighbor index)
        {
            assert(!(index<cm_Head || index>=cm_Broadcast));
            return msIGPCB[index];
        }
      scIGPCB*
    msIGPCB[7];  // The  Inter-scGridPoint facilities from (!) Head to NW
      SC_WORD_TYPE
      Register_Get(int R){ return HThreadExec_Get()->Register_Get(R);}
  // direct Slave Interface; mainly for testing without the bus
        bool
    direct_read(int *data, unsigned int address);
        bool
    direct_write(int *data, unsigned int address);
        bool
    direct_read(scIGPMessage* M);
        bool
    direct_write(scIGPMessage* M);
 
  // Slave Interface, through the bus
        ClusterBusStatus
    read(int *data, unsigned int address){return CLUSTER_BUS_OK;}
        ClusterBusStatus
    write(int *data, unsigned int address){return CLUSTER_BUS_OK;}
        ClusterBusStatus
    read(scIGPMessage* M);
        ClusterBusStatus
    write(scIGPMessage* M);
 
      // State-bits-related functionality
        void
    AllocatedBit_Set(bool V=true);
        bool
    AllocatedBit_Get(void) {  return msStatus.Allocated;}
        void
    PreAllocatedBit_Set(bool V=true);
        bool // The GridPoints can have own preallocated GridPoints;  must be administered both here and at Topology level
    PreAllocatedBit_Get(void){  return msStatus.PreAllocated;}
        void
    DeniedBit_Set(bool P=true);
        bool
    DeniedBit_Get(void)
        {  return msStatus.Denied;}
        bool
    AvailableBit_Get(void)
        { return msStatus.Available;}
        void
    MetaBit_Set(bool P=true);
        bool
    MetaBit_Get(void){  return msStatus.Meta;}
        void
    WaitBit_Set(bool P=true);
        bool
    WaitBit_Get(void){  return msStatus.Wait;}
        bool
    IsAvailable(void)
        { return AvailableBit_Get();} 
        bool
    IsAllocated(void) { return AllocatedBit_Get();}
        bool
    IsPreAllocated(void) { return PreAllocatedBit_Get();}
        bool
    IsDenied(void) { return DeniedBit_Get();}
        bool
    IsWaiting(void) {   return msStatus.Wait;}
        struct{
            sc_core::sc_event
         MakeFetch, FetchReady // These event signals the begin and end of the instruction fetch process
        ,MakeExec, ExecReady   // These event signals the begin and end of the instruction execute process
        ,MakeSend, SendReady   // These event signals the begin and end of the message sending process
        ,TransportedToIGPCB    // No dedicated method, just wait after sending the message
        ,SIGNAL_StateBit
            ,Msg_Reg_Received   // The core received a register-type message
            ,Msg_Qt_Received   // The core received a QT-type message
            ,Msg_Mem_Received   // The core received a memory-type message
            ;
    }EVENT_GRID; //< These events are handled at gridpoint level
//        ,NEXT       // The required action is carrried ot, may take the next one
 
        string
    StringOfMemoryAddress_Get(void)
        {
            ostringstream oss;
            oss << "0x" << hex << std::setfill('0') << std::setw((FMEMORY_ADDRESS_WIDTH+3)/4) << msMemoryAddress << dec;
            return oss.str();
        }
        // Return a hexa word dscribing the status
        string
    StringOfMessage_Get(scIGPMessage* Message);
 
        string
    StringOfStatus_Get(void)
        {
            ostringstream oss;
            oss << "0x" << hex << std::setfill('0') << std::setw(4) << mStatus << dec;
            return oss.str();
        }
        string 
    StringOfClusterAddress_Get(void);
        void
    SIGNAL_method(void);
    void
    doWriteSignals(void);
        SC_GRIDPOINT_MASK_TYPE
    PreAllocatedMask_Get(void);
        bool
    PreAllocatedMask_Set(SC_GRIDPOINT_MASK_TYPE Mask);
        virtual void
    ProcessMessage(scIGPMessage* Message);
 
        void
    ChildrenMaskBit_Set(scGridPoint* C);
        void
    ChildrenMaskBit_Clear( scGridPoint* C);
        SC_GRIDPOINT_MASK_TYPE
    ChildrenMask_Get(void) { return msMask.Children;}   
        void
    ChildrenMask_Set(SC_GRIDPOINT_MASK_TYPE M) { msMask.Children = M;} 
 
        SC_HTHREAD_MASK_TYPE
    HThreadsMask_Get(void){SC_HTHREAD_MASK_TYPE MyMask =(int16_t)(msMask.AllocatedHThreads).to_ulong();
            return MyMask;} 
 
        void
    PreAllocatedMaskBit_Set(scGridPoint* C, bool V=true); 
        bool 
    IsPreAllocatedFor(scGridPoint* C);
        virtual bool
    IsMorphingInstructionFetched(scHThread* H){return true;}
    // Bits directly handling signals
        uint32_t readDataMem(uint32_t addr, int size);
        void
    HandleSuspending(void);
        scHThread*
    HThread_Get(SC_HTHREAD_ID_TYPE H)
        { assert((H>=0) && (H<MAX_HTHREADS));
            return mHThreads[H];}
/*        void
    HThread_Set(SC_HTHREAD_ID_TYPE H){ assert((H>=0) && (H<MAX_HTHREADS));  mHThread = mHThreads[H];}/// Set the actual HThread
*/
        scHThread*  
    HThreadExec_Get(void) { //assert(mHThreadExec);
                            return mHThreadExec;}
        scHThread*  
    HThreadFetch_Get(void) { //assert(mHThreadFetch);
                             return mHThreadFetch;}
        scHThread*  
    HThreadSend_Get(void) { //assert(mHThreadFetch);
                             return mHThreadSend;}
        scHThread*  
    HThreadReceive_Get(void) { //assert(mHThreadFetch);
                             return mHThreadReceive;}
        void
    HThreadExec_Set(scHThread* H){mHThreadExec = H; }
        void
    HThreadFetch_Set(scHThread* H){mHThreadFetch = H; }
        void
    HThreadSend_Set(scHThread* H){mHThreadSend = H; }
        void
    HThreadReceive_Set(scHThread* H){mHThreadReceive = H; }
         core_cooperationmode_t
    CooperationMode_Get(void) { return msCooperationMode;}
        void
    CooperationMode_Set(core_cooperationmode_t M) { msCooperationMode = M;}
       string 
    PrologString_Get(void);
        void
    MemoryAddress_Set(SC_ADDRESS_TYPE MA) { msMemoryAddress = MA;}
        SC_ADDRESS_TYPE
    QTOffset_Get(SC_HTHREAD_ID_TYPE H)
        {   assert((H>=0)&(H<MAX_HTHREADS)); return mHThreads[H]->QTOffset_Get();}
        string
    StringOfName_Get(SC_HTHREAD_ID_TYPE H)
        { assert((H>=0)&(H<MAX_HTHREADS)); return mHThreads[H]->StringOfName_Get();}   
 
        bool
    CatchedAllocationError(scGridPoint* Parent);
        scGridPoint*
    AllocateFor(scGridPoint* Parent); 
        scGridPoint* 
    PreAllocateFor(scGridPoint* Parent);
 
        scIGPMessage*
    CreateRegisterMessageTo(scGridPoint* To, SC_GRIDPOINT_MASK_TYPE Mask);
        scIGPMessage*
    CreateQtCreateMessageTo(scGridPoint* To, SC_ADDRESS_TYPE PC,  SC_GRIDPOINT_MASK_TYPE Mask, SC_GRIDPOINT_MASK_TYPE BackMask);
        scIGPMessage*
    CreateQtKillMessageTo(scGridPoint* To);
        scIGPMessage*
    CreateSpecialMessageTo(scGridPoint* To, int16_t Key, int8_t RegNo,  int32_t R);
        void
    Status_Set(uint16_t S) {mStatus = S;}
        uint16_t
    Status_Get(void) { return mStatus;}
        void 
    ConnectToClusterBus(scClusterBus* ClusterBus);  // Connect this gridpoint to the inter-cluster bus
        scIGPMessage*
    CreateMemoryReadMessage(unsigned int Address, int Length);
        scIGPMessage*
    CreateMemoryWriteMessage(unsigned int Address, int Length);
        int32_t
    FlagWordLength_Get(void) {return 0;}
        int32_t
    ConditionCode_Get(void) {return 0;}
        void
    ConditionCode_Set(int32_t C){}
        SC_GRIDPOINT_MASK_TYPE
    doWaitMask_Get(SC_ADDRESS_TYPE Offset);
        virtual scGridPoint*
    doFindHostToProcess(SC_ADDRESS_TYPE Offs, SC_GRIDPOINT_MASK_TYPE Mask);
        bool
    doCanTerminate( SC_GRIDPOINT_MASK_TYPE Address);
        virtual void
    doCreateQT(scIGPMessage* Message){};
        bool
    doProcessMMessage(scIGPMessage* Message);
        virtual bool
    doProcessQMessage(scIGPMessage* Message);
        bool
    doProcessRMessage(scIGPMessage* Message);
        virtual void
    doSetQTAddresses(scGridPoint* Parent)
        { }
 
        virtual void
    doSkipQTCode(void){}
/*        SC_ADDRESS_TYPE
    PC_Get() { return exec.PC;}
        void
    PC_Set(SC_ADDRESS_TYPE P) {exec.PC = P;}
        void
    fetchNewPC_Set(SC_ADDRESS_TYPE PC){ fetch.NewPC = PC;}      ///< Set the PC of the core for fetching the next instruction
        SC_ADDRESS_TYPE
    fetchPC_Get(void) {return fetch.PC;}        ///< Get PC of the core where the instruction is/was fetched
        void
    fetchPC_Set(SC_ADDRESS_TYPE PC){ fetch.PC = PC;}    ///< Set PC of the core where the instruction will be fetched
*/
        void
    FETCH_thread();
        virtual bool
    doFetchInstruction(scHThread* H);
        void
    EXEC_thread();
        void
    SEND_thread();
        virtual bool
    doExecInstruction(scHThread* H);
       void NotifyThreadOnMemoryArrival()
    {  mHThreadFetch->EVENT_HTHREAD.MemoryContentArrived.notify();}
 
    // It is administered in the scGridPoint if a HThread is allocated
        void    
    HThreadAllocatedBit_Set(SC_HTHREAD_ID_TYPE H, bool B)
        { assert(H < MAX_HTHREADS); msMask.AllocatedHThreads[H] = B;}
        bool    
    HThreadAllocatedBit_Get(SC_HTHREAD_ID_TYPE H)
        { assert(H < MAX_HTHREADS); return msMask.AllocatedHThreads[H];}
 
 
        bool
    OperatingBit_Get(GridPointOperatingBit_t B);
        bool
    OperatingGroup_Get(GridPointOperatingBit_t G);
    int OperatingBits_Get(void){return mGridPointOperatingStateBit.to_ulong();}
    bool IsObserved(void) 
    {return  mObservedHThreads;}
        void
    ObservedHThreadBit_Set(SC_HTHREAD_MASK_TYPE M, bool B);
   protected:
        SC_HTHREAD_MASK_TYPE
    mObservedHThreads;                
        int16_t
    InstanceCount_Get(void) {return mInstanceCount % 50;}
 
        scIGPMessage*
    CreateMessageTo(scGridPoint* To, IGPMessageType Type, int Length);
        void
    AvailableBit_Set(void);
        void
    SleepingBit_Set(void);
        void
    SetupMessageAddressTo(scGridPoint* GP);
 
        SC_GRIDPOINT_ID_TYPE
    msID;   
        scHThread
    *mHThreadFetch,  *mHThreadExec, *mHThreadSend, *mHThreadReceive;
        scGridPoint*
    msParent;           
        GridPointStatusBit_t
    msStatus;
        GridPointSignal_t
    msSignal;   
        GridPointMask_t
    msMask;     
        RegisterLatch_fifo*
    msRegisterLatch;
        SC_ADDRESS_TYPE
    msMemoryAddress;
        SC_ADDRESS_TYPE
    msWaitOffset; // The offset of the QT we are waiting for
        sc_time
    msWaitBegin;  
 
//    int32_t    mMemoryBuffer[MAX_HTHREADS_LIMIT][MAX_IGPCBUFFER_SIZE];
    // Simple accessor functions
        core_cooperationmode_t
    msCooperationMode;
        uint16_t
    mInstanceCount; // How many times this object was instantiated
        scHThread*
    mHThreads[MAX_HTHREADS];    
        void OperatingGroup_Set(GridPointOperatingBit_t G, bool B);
        void OperatingBit_Set(GridPointOperatingBit_t B, bool V);
    protected:
        // -- These bits are used in monitoring (by the simulator) gridpoint
        std::bitset<gob_Max>
    mGridPointOperatingStateBit;
        // -- These variables are used to benchmark the running time spent in the objects
        chrono::steady_clock::time_point
    m_running_time; // A work variable, do not touch outside the macros
        std::chrono::duration< int64_t, nano>
    m_part_time, m_sum_time;    // Work variables, contain actual benchmark duration and their sum
 
}; // of scGridPoint
 
#endif // scGridPoint_h
 
// Fast memory; reset