• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

sst/elements/PHXSimC/PHXSimC.h

00001 // Copyright 2009-2010 Sandia Corporation. Under the terms
00002 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
00003 // Government retains certain rights in this software.
00004 // 
00005 // Copyright (c) 2009-2010, Sandia Corporation
00006 // All rights reserved.
00007 // 
00008 // This file is part of the SST software package. For license
00009 // information, see the LICENSE file in the top level directory of the
00010 // distribution.
00011 
00012 
00013 #ifndef _PHXSIMC_H
00014 #define _PHXSIMC_H
00015 
00016 #include <sst/core/log.h>
00017 #include <sst/core/event.h>
00018 #include <sst/core/component.h>
00019 #include <memoryChannel.h>
00020 #include <Callback.h>
00021 //#include <LinearChain.h> /* currently broken */
00022 #include <SingleCube.h>
00023 #include <PHXEvent.h>
00024 
00025 
00026 /* THIS COMPLETELY CHANGES THE STREAM, COMMENT THIS LINE FOR REAL RUNS */
00027 //#define TEST_MODE
00028 
00029 using namespace std;
00030 using namespace SST;
00031 
00032 #ifndef PHXSIMC_DBG
00033 #define PHXSIMC_DBG
00034 #endif
00035 
00036 class PHXSimC : public Component {
00037 
00038 public: // functions
00039 
00040   PHXSimC( ComponentId_t id, Params_t& params );
00041   int Finish();
00042 
00043 private: // types
00044 
00045   typedef MemoryChannel<uint64_t> memChan_t;
00046 
00047 private: // functions
00048 
00049   PHXSimC( const PHXSimC& c );
00050   bool clock( Cycle_t  );
00051 
00052   inline PHXSim::PacketType convertType( memChan_t::event_t::reqType_t type );
00053   void packetReturn(PHXSim::Packet *pkt, uint64_t clockcycle);
00054 
00055   std::deque<PHXSim::Packet *> m_transQ;
00056 
00057   std::map <unsigned, PHXSim::Packet *> writeReturnMap;
00058   PHXSim::SingleCube *           m_memorySystem;
00059   memChan_t*              m_memChan;
00060   std::string             m_printStats;
00061   Link *advMem;
00062   int linksToUse;
00063   // unique transaction identifier
00064   unsigned int transaction_id;
00065   Log< PHXSIMC_DBG >&    m_dbg;
00066   Log<>&                  m_log;
00067   
00068   static const int FPMultLat = 4;
00069   static const int FPDivLat = 8;
00070   static const int FPAddLat = 3;
00071   bool hadFirstEvent;
00072   // counters
00073   uint64_t engFPMul;
00074   uint64_t engFPDiv;
00075   uint64_t engFPAdd;
00076   uint64_t engRW; /* should include addr calculation */
00077   uint64_t engPartialR;
00078   uint64_t engDidWork;
00079   uint64_t engFinishedUnit;
00080 
00081   // number of state machine engies
00082   int engines;
00083   void engRead(unsigned int addr, int eng, int size=64);
00084   void engWrite(unsigned int addr, int eng, int size=64);
00085   bool handleMatVec(PHXEvent*, int);
00086   bool handleForceCalc(PHXEvent*, int);
00087   bool handlePagerank(PHXEvent*, int);
00088   void handleAdvMem();
00089   void advanceEngine(int);
00090   void resetCounters();
00091   vector<int> engOutstandingReads;
00092   vector<int> engIdx;
00093   typedef map<unsigned int, int> transToEngMap_t;
00094   // map of read transaction IDs to the issuing Engine
00095   transToEngMap_t readTransToEng;
00096   transToEngMap_t writeTransToEng;
00097   vector<deque<PHXEvent*> > advMemEvents;
00098 
00099 #if WANT_CHECKPOINT_SUPPORT
00100   BOOST_SERIALIZE {
00101     _AR_DBG(PHXSimC,"start\n");
00102     BOOST_VOID_CAST_REGISTER( PHXSimC*, Component* );
00103     ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Component );
00104     ar & BOOST_SERIALIZATION_NVP( bus );
00105     _AR_DBG(PHXSimC,"done\n");
00106   }
00107   SAVE_CONSTRUCT_DATA( PHXSimC ) {
00108     _AR_DBG(PHXSimC,"\n");
00109     ComponentId_t     id     = t->_id;
00110     Clock*            clock  = t->_clock;
00111     Params_t          params = t->params;
00112     ar << BOOST_SERIALIZATION_NVP( id );
00113     ar << BOOST_SERIALIZATION_NVP( clock );
00114     ar << BOOST_SERIALIZATION_NVP( params );
00115   } 
00116   LOAD_CONSTRUCT_DATA( PHXSimC ) {
00117     _AR_DBG(PHXSimC,"\n");
00118     ComponentId_t     id;
00119     Clock*            clock;
00120     Params_t          params;
00121     ar >> BOOST_SERIALIZATION_NVP( id );
00122     ar >> BOOST_SERIALIZATION_NVP( clock );
00123     ar >> BOOST_SERIALIZATION_NVP( params );
00124     ::new(t)PHXSimC( id, clock, params );
00125   } 
00126 #endif
00127 };
00128 
00129 inline PHXSim::PacketType
00130 PHXSimC::convertType( memChan_t::event_t::reqType_t type )
00131 {
00132 #ifndef TEST_MODE
00133   switch( type ) {
00134   case memChan_t::event_t::READ:
00135     return PHXSim::DATA_READ;
00136   case memChan_t::event_t::WRITE:
00137     return PHXSim::DATA_WRITE;
00138   case memChan_t::event_t::RMW:
00139   case memChan_t::event_t::INV_REQ:
00140   default:
00141     ;
00142   }
00143   m_dbg.write("WARNING: Returning Bogus packet type from request type %d\n", type);
00144   return (PHXSim::PacketType)-1; 
00145 #else 
00146   //this is artificial just for the sake of testing returns; mostly writes, some reads
00147   static int number=1;
00148   PHXSim::PacketType p = (number++ % 64) == 0 ? PHXSim::DATA_READ : PHXSim::DATA_WRITE;
00149   m_dbg.write("==============WARNING: TEST_MODE (%d, type=%d)==============\n", number, p);
00150   return p; 
00151 #endif
00152 }
00153 
00154 #endif 
00155 

Generated on Fri Oct 22 2010 11:02:25 for SST by  doxygen 1.7.1