NeurerCore.h

Go to the documentation of this file.

 
#ifndef NeurerCore_h
#define NeurerCore_h
 
//#include "Config.h"
//#include "scTypes.h"
 
#include "NeurerProcessor.h"
//#include "scGridPoint.h"
 
using namespace sc_core;
using namespace sc_dt;
 
typedef SC_GRIDPOINT_ID_TYPE SC_CORE_ID_TYPE;
typedef SC_GRIDPOINT_MASK_TYPE  SC_CORE_MASK_TYPE;
/*
#ifdef MEASURE_PERFORMANCE
    #define PERFORMANCE_COUNTINSTRUCTION CountInstruction();
    #define PERFORMANCE_COUNTMETAINSTRUCTION CountMetaInstruction();
    #define PERFORMANCE_ADDINSTRUCTIONTIME(t) mInstructionTime +=t;
    #define PERFORMANCE_ADDMETAINSTRUCTIONTIME(t) mMetaInstructionTime +=t;
    #define PERFORMANCE_ADDMEMORYTIME(t) mMemoryTime +=t;
    #define PERFORMANCE_ADDFETCHTIME(t) mFetchTime +=t;
    #define PERFORMANCE_ADDWAITTIME(t) mWaitTime +=t;
#else
    #define PERFORMANCE_COUNTINSTRUCTION
    #define PERFORMANCE_COUNTMETAINSTRUCTION
    #define PERFORMANCE_ADDINSTRUCTIONTIME(t)
    #define PERFORMANCE_ADDMETAINSTRUCTIONTIME(t)
    #define PERFORMANCE_ADDMEMORYTIME(t)
    #define PERFORMANCE_ADDFETCHTIME(t)
    #define PERFORMANCE_ADDWAITTIME(t)
#endif // MEASURE_PERFORMANCE
 
*/
 
/*
#define  USE_DEBUG_DATA_TYPES
 
#ifdef USE_DEBUG_DATA_TYPES
typedef int32_t SC_REGISTER_TYPE;
typedef int SC_COOPERATION_MODE_TYPE;
typedef int32_t SC_REGISTER_MASK_TYPE;
#else
typedef sc_dt::sc_uint<CORE_REGISTER_BITS> SC_REGISTER_TYPE;
typedef sc_dt::sc_uint<COOPERATION_MODE_WIDTH> SC_COOPERATION_MODE_TYPE;
typedef sc_dt::sc_uint<MAX_NUMBER_OF_REGFteregicISTERS> SC_REGISTER_MASK_TYPE;
#endif //USE_DEBUG_DATA_TYPES
*/
/*
// These includes and structure fields are needed until made processor-independent
#ifdef __cplusplus
extern "C" {
#endif
 
#include "isaE.h"
#ifdef __cplusplus
}
#endif
*/
 
#if 0
/* Different QT operations */
typedef enum {
                Q_TERM, 
                Q_WAIT, Q_IWAIT, 
                Q_ALLOC,    
                Q_CREATE, Q_CREATER, Q_CREATET, Q_CREATEF, 
                Q_CALL, Q_MUTEX, 
 
                Q_HALT=0xE, 
                Q_INT, Q_ERR } qt_t; 
#endif//0
 
// Type for the one-hot bitmasks
//typedef int SC_CORE_MASK_TYPE;
typedef SC_GRIDPOINT_MASK_TYPE SC_CORE_MASK_TYPE;
typedef int SC_REGISTER_TYPE;
//#include "scIGPCB.h"
//#include <queue>
//#include <vector>
//#include <iostream>
 
using namespace sc_core; using namespace std;
 
class NeurerProcessor;
class NeurerCore:  public AbstractCore
{
    friend NeurerProcessor;
  public:
    NeurerCore(sc_core::sc_module_name nm
             ,NeurerProcessor* Proc
             ,const GridPoint GP
             ,bool StandAlone
            );
 
//    friend class TestY86Core;
    ~NeurerCore(void);
        SC_HAS_PROCESS(NeurerCore);  // We have the constructor in the .cpp file
        NeurerProcessor*
    Processor_Get(void);
        void
    Reset(void);
protected:
 /*       void
    doCreateQT(scIGPMessage* MyMessage);
        void
    doSkipQTCode(void){}
        void
    NEXT_thread(void);
        void
    EXECUTEMETA_thread(void);
        void
    FETCH_thread(void);
 
        void
    QHALT_thread(void);
        void
    QTERM_thread(void);
        void
    QWAIT_thread(void);
        void
    QCREATE_thread(void);
        void
    QCREATEMETA_thread(void);
        void
    QWAITMETA_thread(void);
        void
    QALLOC_thread(void);
        void
    QCALL_thread(void);
        void
    QMUTEX_thread(void);
        virtual AbstractCore*
    doFindHostToProcess(SC_ADDRESS_TYPE Offs, SC_GRIDPOINT_MASK_TYPE Mask)
        { return  dynamic_cast<AbstractCore*>(scGridPoint::doFindHostToProcess(Offs, Mask));}
 
        void
    doExecuteMetaInstruction();
        void
    HandleMetaInstruction(void);
        void ///< A helper function for NEXT_thread
    HandleConventionalInstruction(void);
        void ///< A helper function for NEXT_thread
    TerminateExecution(void);
 
        void
    FinishPrefetching(void);
    */
/*        bool
    doQTERM(void);
        void
    ReleasePreAllocatedCores(void);
 
        void
    doKillQT(void);
        uint64_t
    readInstrMem(SC_WORD_TYPE addr);
        void
    writeInstrMem(SC_WORD_TYPE addr, uint32_t C);
        bool
    msPC_Affected;  ///< If PC will be affected by executing this instruction
        short int
    mCSR;   ///< The Control and Status codes
    */
/*
#ifdef MAKE_PERFORMANCE_DIAGRAM
        sc_time
    msAllocationBegin;    ///< The beginning of the allocation
        sc_time
    msMetaBegin;    ///< The beginning of a meta instruction
 
        sc_time
    AllocationBegin_Get(void) { return msAllocationBegin;} // Just to record the beginning of being allocated
         void
    AllocationBegin_Set(sc_time T) {msAllocationBegin = T;} // Just to record the beginning of being allocated
#endif //MAKE_PERFORMANCE_DIAGRAM
        MetaEvent_Transfer_Type
    msMeta; // The metainstruction fetched by the core
*/
//    msVectorMode
/*        void    /// Make the actual inspection; overwritten in subclasses
    doInspect(vector<int32_t>& in, vector<int32_t>& out);*/
/*#ifdef MEASURE_PERFORMANCE
public:
        sc_time
    FetchTime_Get(){ return mFetchTime;}
        sc_time
    InstructionTime_Get(){ return mInstructionTime;}
        sc_time
    MetaInstructionTime_Get(){ return mMetaInstructionTime;}
        sc_time
    WaitTime_Get(){ return mFetchTime;}
        void
    AddFetchTime(sc_time T){mFetchTime += T;}
        void
    AddInstructionTime(sc_time T){mInstructionTime += T;}
        void
    AddMetaInstructionTime(sc_time T){mMetaInstructionTime += T;}
        void
    AddWaitTime(sc_time T){mFetchTime += T;}
        uint32_t    /// Return number of conventional instructions
    InstructionCount_Get(){return mInstructionCount;}
        uint32_t    /// Returm number of  metainstructions
    MetaInstructionCount_Get(){return mMetaInstructionCount;}
#endif //MEASURE_PERFORMANCE
    */
/*#ifdef MEASURE_PERFORMANCE
 
         uint32_t
    mInstructionCount,
    mMetaInstructionCount;
        sc_time
    mFetchTime,
    mInstructionTime,
    mMemoryTime,
    mMetaInstructionTime,
    mWaitTime;
#endif //MEASURE_PERFORMANCE
*/
}; // of NeurerCore
 
#endif // NeurerCore_h