scIGPMessage_if.h

Go to the documentation of this file.

 
/*  @author János Végh (jvegh)
 *  @bug No known bugs.
 */
 
#ifndef scIGPMessage_if_h
#define scIGPMessage_if_h
 
//#include <iomanip>      // std::setfill, std::setw
//#include <systemc>
// "tlm.h"
//#include "tlm_utils/simple_initiator_socket.h"
//#include "scIGPCB.h" //#include "scIGPfifo.h"
//#include "GridPoint.h"
//#include "scIGPMessage.h"
#include "scClusterBusSlave_if.h"
#include "scClusterBusMaster_blocking.h"
#include "scLatchFIFO.h"
#include "scGPMessagefifo.h"
#include "scTimedFIFO.h"
#include "scHThread.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
*/
 
using namespace std;
using namespace sc_core;
using namespace sc_dt;
 
class scProcessor;
class scIGPMessage;
class scClusterBus;
class scIGPCB;
extern string sc_time_to_nsec_Get(const int d, const int w, sc_time T);
extern string DebugRoute;
 
#define DEBUG_CONTRIBUTE_STRING(D,S,M) \
    DebugRoute.append(StringOfClusterAddress_Get() +"%" +string(S).append(M));
 
// Define execution time measuring macros, per module
// Define this anyhow; if false no code is generated
 
 
using namespace sc_core; using namespace std;
 
class scIGPMessage_if :    // The IGPMessage related routines
        public sc_core::sc_module
{
public:
/*        sc_in_clk
    clock;
*/        scClusterBusMaster_blocking*
    mMaster_if;
 
//        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 );
public:
     // Constructor declaration:
    scIGPMessage_if(sc_core::sc_module_name nm // Just the systemC name
                    ,scProcessor* Proc   // The processor we belong to
                );
   ~scIGPMessage_if();//{}
        SC_HAS_PROCESS(scIGPMessage_if);  // We have the constructor in the .cpp file
        // Group dealing with identification
        // The physical ID and the corresponding mask cannot be changed
        uint16_t
    BusPriority_Get(void){return mBusPriority;}
        scProcessor*
    Processor_Get(void) {    return msProcessor;}
        scTimedIGPMessage_fifo*
    TimedFIFO;  
        scGPMessagefifo*
    GPMessagefifo;  
        virtual string
    StringOfClusterAddress_Get(void) = 0;
        virtual string
    StringOfMessage_Get(scIGPMessage* Message) = 0;
        ClusterBusStatus
    SendClusterMessage(scIGPMessage* M);
        ClusterBusStatus
    ReceiveClusterMessage(scIGPMessage* M);
    protected:
        void
    Reset(void);
        // process
       void bus_action(void);
       void
   ReceiveMessage_thread(void);
       void
   ReceiveTimedMessage_thread(void);
       virtual void // Must be implemented in scGridPoint and scClusterBusMemorySlow
   RouteMessage(scIGPMessage* Message) = 0; // How to forward a message in the bottom layer
#if 0
        SC_GRIDPOINT_ID_TYPE
    ID_Get(void){   return msID;} 
        SC_GRIDPOINT_MASK_TYPE
    IDMask_Get(void){   return msMask.ID;}  
     // Directly HW-related functionality
        void
    Reset(void);
 
        void
    ResetForParent(scGridPoint* Parent);
        bool
    Deallocate(void);
        void
    ReceiveMessage_thread(void);
        void
    ReceiveTimedMessage_thread(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 HThread_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);
   // process
  void bus_action(void);
        bool
        struct{
            sc_core::sc_event
//        TIMEOUT    // The required timeout is over
//        ,
         MakeFetch, FetchReady// These event signal the begin and end of the process
        ,TransportedToIGPCB // No dedicated method, just wait after sending the message
        ,SIGNAL_StateBit
            ,Msg_Reg_Received   // The core received a register-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);
        void 
    ProcessMessage(scIGPMessage* Message);
 
 
        void
    PreAllocatedMaskBit_Set(scGridPoint* C, bool V=true); 
        bool 
    IsPreAllocatedFor(scGridPoint* C);
    // Bits directly handling signals
        uint32_t readDataMem(uint32_t addr, int size);
//        Performance *
    scProcessor* Processor_Get(void) {    return msProcessor;}
        void
    HandleSuspending(void);
 
        scHThread*
    HThread_Get(void) { return mHThread;}
        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
    StringOfQT_Get(SC_HTHREAD_ID_TYPE H)
        { assert((H>=0)&(H<MAX_HTHREADS)); return mHThreads[H]->StringOfQT_Get();}   
 
        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;}
        scTimedIGPMessage_fifo*
    TimedFIFO;  
        scGPMessagefifo*
    GPMessagefifo;  
        void 
    ConnectToClusterBus(scClusterBus* ClusterBus);  // Connect this gridpoint to the inter-cluster bus
        ClusterBusStatus
    SendClusterMessage(scIGPMessage* M);
        ClusterBusStatus 
    ReceiveClusterMessage(scIGPMessage* M);
        scIGPMessage*
    CreateMemoryReadMessage(unsigned int Address, int Length);
        scIGPMessage*
    CreateMemoryWriteMessage(unsigned int Address, int Length);
        int32_t
    FlagWordLength_Get(void) {return 0;}
         bool
    doProcessMMessage(scIGPMessage* Message);
        virtual bool
    doProcessQMessage(scIGPMessage* Message);
        bool
    doProcessRMessage(scIGPMessage* Message);
        scIGPMessage*
    CreateMessageTo(scGridPoint* To, IGPMessageType Type, int Length);
    SetupMessageAddressTo(scGridPoint* GP);
 
        SC_GRIDPOINT_ID_TYPE
    msID;
        SC_ADDRESS_TYPE
    msMemoryAddress;
#endif //0
        scProcessor*
    msProcessor; 
        uint16_t
    mStatus;    // This is a status bit of the gridpoint
        uint16_t
    mBusPriority;  
        bool
    m_lock; // It the bus is to be locked
}; // of scIGPMessage_if
 
#endif // scIGPMessage_if