scHThread.h

Go to the documentation of this file.

 
/*  @author János Végh (jvegh)
*  @bug No known bugs.
*/
 
#ifndef scHThread_h
#define scHThread_h
 
class scGridPoint;
#include <iomanip>      // std::setfill, std::setw
#include <systemc>
#include <bitset>
//#include "BasicConfig.h"
#include "GridPoint.h"
using namespace sc_core; using namespace std; using namespace sc_dt;
 
typedef enum { hpt_System, hpt_Head, hpt_Same, hpt_Near, hpt_Any} HThreadPreference_t;
typedef struct{
        SC_ADDRESS_TYPE 
    Offset;
        size_t 
    Length;
        string 
    ID;
} QTattributes_t; typedef QTattributes_t *QTattributes_Ptr;
 
typedef enum
{
    tob_Regime, 
    tob_Allocated,  
    tob_PreAllocated,  
    tob_Blocked,    
    tob_MemoryExpected, 
    tob_DataExpected, 
    // The scGridPoint can make ONE fetch at a time, the threads must share its capacity
    // These two bits describe the status of the scGridPoint
    tob_FetchPending, 
    tob_FetchValid, 
    // The scThread is executing an instruction on the  scGridPoint
    tob_ExecPending, 
    tob_MorphFetched,   
    tob_Morphing,   
    tob_PCAffected, 
    tob_Observed,   
    tob_Max
} ThreadOperatingBits_t;
 
typedef  struct{
  bool
  okc,okFetch;
        int8_t
    byte1,
    OpCode,     
    FunctCode,  
    FunctCode7,  
    RSource1,   
    RSource2,   
    RDest;      
        SC_WORD_TYPE
    immediate;
} CoreStage_t; typedef CoreStage_t *CoreStage_Ptr;
 
typedef struct{
    uint32_t PC;    
    uint32_t NewPC; 
    SC_WORD_TYPE* InstBufferPosition; 
    SC_WORD_TYPE* DataBufferPosition; 
    CoreStage_t Stage; 
        sc_time
        WaitTimeBegin,  
    ExecutionTime;  
} CoreFetch_t; typedef CoreFetch_t *CoreFetch_Ptr;
 
typedef struct{
    uint32_t PC;    
//    sc_core::sc_time    Delay;///< Remember the time of fetching the instruction
    CoreStage_t Stage; 
    uint32_t val,dval;
    sc_time ExecutionTime; 
} CoreExecute_t; typedef CoreExecute_t *CoreExecute_Ptr;
 
/* \class scHThread The scHThread is the "work horse" of the system
 *
 * In order to avoid using an scHThread for two different goals,
 * it must be activated before directing an instruction stream to it
 * and must be deactivated after the execution of the stream terminated.
 * The state flag whether the scHThread is active, is administered in its owner scGridPoint,
 * with setting the bit corresponding to the scHThread's IDMask.
 *
 * A scHThread can be activated either by another scHThread, or the scProcessor
 * of the scGridpoint owing the scHThread.
 * The first form is only possible using a morphing instruction,
 * the latter is possible without morphing (corresponds to the classic computing).
 * The scProcessor, in this way, can start several scHThread processes,
 * either the conventional or scHThread-initiated ones.
 
 * The OS has the right to allocate and preallocate some scGridPoint and scHThread resources for a task,
 * and the different tasks do not have the right to activate each other's resources.
 * There are, however, unallocated resources; and (as a "free pool") the
 * tasks can activate those resources.
 
 */
 
class scHThread : public sc_core::sc_module
{
    friend class scGridPoint;
    friend class scAbstractCore;
    friend class Y86Core;
 
  public:
    scHThread(sc_core::sc_module_name nm
              , scGridPoint* GP, SC_HTHREAD_ID_TYPE ID) ;
   ~scHThread(void);
    SC_HAS_PROCESS(scHThread);  // We have the constructor in the .cpp file
        struct{
            sc_core::sc_event
            FETCH       
            ,FETCHED    //< Fetch finished
            ,EXEC       
            ,EXECUTED   
            ,NEXT       
            ,TIMEOUT    //< The required timeout is over
            ,MemoryContentArrived //< The physical core informs the the top layer, per HThread
            ;
    }EVENT_HTHREAD; 
        bool    
    IsTimedOut(void) const
        { return mTimedOut;}
        void    
    Reset(void);
        void    
    Timeout_Set(sc_time &T)
        { mTimedOut = false; EVENT_HTHREAD.TIMEOUT.notify(T);}
        void    
    AllocatedBit_Set(bool B);
        bool    
    AllocatedBit_Get(bool B);
 
        void 
    PreAllocatedBit_Set(bool V=true);
       // { OperatingBit_Set(tob_PreAllocated,V);}
        bool 
    PreAllocatedBit_Get(void){  return  OperatingBit_Get(tob_PreAllocated);}
        SC_HTHREAD_ID_TYPE
    ID_Get(void){return mID;}
        SC_HTHREAD_MASK_TYPE
    ID_Mask_Get(void) { return 1 << mID;}
        string
    StringOfID_Get(void);
        ClusterAddress_t 
    ClusterAddress_Get(void);
 
        string
    PrologString_Get(void);
    // QT handling
/*        bool
    QTRegime_Get(void) { return mQT.Regime;}
        void
    QTRegime_Set(bool R) { mQT.Regime = R;}*/
        SC_ADDRESS_TYPE
    QTOffset_Get(void){ return mQT.Offset;}
        void
    QTOffset_Set(SC_ADDRESS_TYPE O){mQT.Offset = O;}
        size_t
    QTLength_Get(void){ return mQT.Length;}
        void
    QTLength_Set(size_t L){mQT.Length = L;}
/*        string
    QTID_Get(void){ return mQT.ID;}
        void
    QTID_Set(string S){mQT.ID = S;}
        string
    StringOfQT_Get(void); { return mQT.ID;}   */
        string
    StringOfDefaultName_Get(void);
        string
    StringOfClusterName_Get(void);
        string
    StringOfAliasName_Get(void){ return mAliasName;}
        bool
    StringOfAliasName_Set(string A);
//    QT_AssembleID( scHThread* Parent);
        scGridPoint*
    Owner_Get(void){ return mGridPoint;}
    // Allocation-related
        scHThread*
    Parent_Get(void){ return mParent;}
        void
    Parent_Set(scHThread* P){mParent = P;}
        void
    ResetForParent(scHThread* Parent);   
        scHThread* 
    AllocateFor(scHThread* Parent);
        scHThread* 
    PreAllocateFor(scHThread* Parent);
 
 
        // State-bits-related functionality
         void
    AllocatedBit_Set(SC_HTHREAD_ID_TYPE H,  bool V=true);
        bool
    AllocatedBit_Get(void)
        {  return OperatingBit_Get(tob_Allocated); }
/*        bool
    IsAllocated(void) { return OperatingBit_Get(tob_Allocated);}*/
        bool
    Deallocate(void);
        SC_WORD_TYPE
    Register_Get(int R)
    {assert((R>=0) && (R<32)); return REGS[R];}
        void
    Register_Set(int R, SC_WORD_TYPE C)
    {assert((R>=0) && (R<32)); REGS[R] = C;}
 
        SC_ADDRESS_TYPE
    PC_Get()
        { assert(((exec.PC>=0) && (exec.PC<FMAX_MEMORY_SIZE)) || (exec.PC==(unsigned)-1));
            return exec.PC;}
        void
    PC_Set(SC_ADDRESS_TYPE P)
        {  assert(((P>=0) && (P<FMAX_MEMORY_SIZE)) || (P==(unsigned)-1));
            exec.PC = P;}
        void
    fetchNewPC_Set(SC_ADDRESS_TYPE PC)
        { assert((PC>=0) && (PC<FMAX_MEMORY_SIZE));
            fetch.NewPC = PC;}  
        SC_ADDRESS_TYPE
    fetchPC_Get(void)
        {   return fetch.PC;}   
        int8_t
    fetchFunctionCode_Get(void)
            { return fetch.Stage.FunctCode;}    
        void
    fetchPC_Set(SC_ADDRESS_TYPE PC){ assert((PC>=0) && (PC<FMAX_MEMORY_SIZE));
            fetch.PC = PC;}     
        SC_WORD_TYPE
    fetchImmediate_Get(void)
            { return fetch.Stage.immediate; }
        void
    PC_Affected_Set(bool B)  
        { OperatingBit_Set(tob_PCAffected,B);}
        bool
    PC_Affected_Get(void)   
        { return OperatingBit_Get(tob_PCAffected);}
        string 
    StringOfPC_Get(void)
    {
        ostringstream oss;
        oss << "0x" << hex << std::setfill('0') << std::setw((FMEMORY_ADDRESS_WIDTH+3)/4) << PC_Get() << dec;
        return oss.str();
    }
        string
     StringOfClusterAddress_Get(void);
 
        bool
    IsMemoryExpected(void) { return mThreadOperatingBits[tob_MemoryExpected];}
        bool
    IsDataMemoryExpected(void) {return mThreadOperatingBits[tob_DataExpected];}
        void
    MemoryExpected_Set(bool B, bool D=true)
        {mThreadOperatingBits[tob_MemoryExpected] = B; mThreadOperatingBits[tob_DataExpected] = D; }
        SC_WORD_TYPE*   
    InstPositionInBuffer(SC_ADDRESS_TYPE A=CORE_DEFAULT_ADDRESS);
        SC_WORD_TYPE*   
    DataPositionInBuffer(SC_ADDRESS_TYPE A);
 
        virtual void
    FinishPrefetching(void);
        void
    PrepareNextInstruction();
        virtual bool
    CatchedAllocationError(scHThread* Parent){return false;}
        void
    OperatingBit_Set(ThreadOperatingBits_t B, bool V);
        bool
    OperatingBit_Get(ThreadOperatingBits_t B){return mThreadOperatingBits[B];};
        void    
    ObservedBit_Set(bool B);
        void
    Child_Insert(scHThread* C);
        void
    Child_Remove(scHThread* C);
        int
    ChildCount_Get(void){return mChildren.size();}
        int
    Child_Find(scHThread* C);
        bool
    Y86doFetchInstruction();
        bool
     Y86doExecuteInstruction(void);
        int16_t
    InstanceCount_Get(){  return mInstanceCount % 50;;}
        string
    StringID_Get(void);
 
        void
        HandleMorphingInstruction();
    void
    HandleConventionalInstruction();
        string
    StringOfName_Get(void);
 
protected:
        void
    TIMEOUT_method(void);   //
        SC_WORD_TYPE*
    REGS;
        CoreFetch_t
    fetch;  
        CoreExecute_t
    exec; 
        SC_WORD_TYPE
    mDataMemoryBuffer[MAX_IGPCBUFFER_SIZE],     // This a per thread cache
    mInstrMemoryBuffer[MAX_IGPCBUFFER_SIZE];    
        SC_ADDRESS_TYPE
    mDataMemoryAddressBegin, mDataMemoryAddressEnd, // This a per thread cache
    mInstrMemoryAddressBegin, mInstrMemoryAddressEnd;    
 
//        void
//    NEXT_thread(void);
 
        void
    FETCH_method(void);
 
        void
    EXEC_method(void);
 
//        void
//    FETCH_thread(void);
        void
    NEXT_method(void);
        void
    MemoryContentArrived_method(void);
        virtual void
        doGetMemoryContent(void){}
        bool
    mTimedOut;      
        short int
    msWaitTimeout;  // The waiting can be time-limited; 0 means no wait
        void
    AllocationBegin_Set(sc_core::sc_time T)
        {   msAllocationBegin = T;}
private:
        bitset<tob_Max>
    mThreadOperatingBits;   
        QTattributes_t
    mQT;   
        scGridPoint*
    mGridPoint; 
        scHThread*
    mParent;    
        vector<scHThread*>
    mChildren;
        SC_ADDRESS_TYPE
    mMemoryRequestAddress;
        const SC_HTHREAD_ID_TYPE
    mID;
        string
    mStringID;  // Store here
        bool
    msPC_Affected;  
        short int
    mCSR;   
        uint16_t
    mInstanceCount; // How many times this object was instantiated
        sc_core::sc_time
    msAllocationBegin;  // When this scHThread was allocated
        string  //
    mAliasName;
}; // of scHThread
#endif // scHThread_h