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

sst/elements/xbarShell/dummy.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 _DUMMY_H
00014 #define _DUMMY_H
00015 
00016 #include <sst/eventFunctor.h>
00017 #include <sst/component.h>
00018 #include <sst/link.h>
00019 
00020 using namespace SST;
00021 
00022 #if DBG_DUMMY
00023 #define _DUMMY_DBG( fmt, args...)\
00024          printf( "%d:Dummy::%s():%d: "fmt, _debug_rank,__FUNCTION__,__LINE__, ## args )
00025 #else
00026 #define _DUMMY_DBG( fmt, args...)
00027 #endif
00028 
00029 class Dummy : public Component {
00030 
00031     public:
00032         Dummy( ComponentId_t id, Params_t& params ) :
00033             Component( id  ), 
00034             params( params ),
00035             frequency( "2.2GHz" )
00036         { 
00037             _DUMMY_DBG("new id=%lu\n",id);
00038 
00039             Params_t::iterator it = params.begin();
00040             while( it != params.end() ) {
00041                 _DUMMY_DBG("key=%s value=%s\n",
00042                             it->first.c_str(),it->second.c_str());
00043                 if ( ! it->first.compare("clock") ) {
00044 /*                     sscanf( it->second.c_str(), "%f", &frequency ); */
00045                     frequency = it->second;
00046                 }
00047                 ++it;
00048             }
00049 
00050 
00051 /*             eventHandler = new EventHandler< Dummy, bool, Time_t, Event* > */
00052 /*                                                 ( this, &Dummy::processEvent ); */
00053 
00054             eventHandler = new EventHandler< Dummy, bool, Event* >
00055                                                 ( this, &Dummy::processEvent );
00056 
00057             cpu= LinkAdd( "port0" );
00058             nic= LinkAdd( "port1", eventHandler );
00059 
00060 /*             clockHandler = new EventHandler< Dummy, bool, Cycle_t, Time_t > */
00061 /*                                                 ( this, &Dummy::clock ); */
00062 
00063             clockHandler = new EventHandler< Dummy, bool, Cycle_t >
00064                                                 ( this, &Dummy::clock );
00065 
00066             registerClock( frequency, clockHandler );
00067         }
00068 
00069     private:
00070 
00071         Dummy( const Dummy& c );
00072 /*         bool clock( Cycle_t, Time_t  ); */
00073 /*         bool processEvent( Time_t, Event*  ); */
00074         bool clock( Cycle_t );
00075         bool processEvent( Event*  );
00076 
00077         ClockHandler_t* clockHandler;
00078         Event::Handler_t* eventHandler;
00079 
00080         Params_t    params;
00081         Link*       cpu;
00082         Link*       nic;
00083         std::string frequency;
00084 
00085         friend class boost::serialization::access;
00086         template<class Archive>
00087         void serialize(Archive & ar, const unsigned int version )
00088         {
00089             _AR_DBG(Dummy,"start\n");
00090             boost::serialization::
00091                 void_cast_register(static_cast<Dummy*>(NULL), 
00092                                    static_cast<Component*>(NULL));
00093             ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Component );
00094             ar & BOOST_SERIALIZATION_NVP( cpu );
00095             ar & BOOST_SERIALIZATION_NVP( nic );
00096             ar & BOOST_SERIALIZATION_NVP( clockHandler );
00097             ar & BOOST_SERIALIZATION_NVP( eventHandler );
00098             _AR_DBG(Dummy,"done\n");
00099         }
00100         template<class Archive>
00101         friend void save_construct_data(Archive & ar, 
00102                                         const Dummy * t,
00103                                         const unsigned int file_version)
00104         {
00105             _AR_DBG(Dummy,"\n");
00106             ComponentId_t     id     = t->_id;
00107             Params_t          params = t->params;
00108             ar << BOOST_SERIALIZATION_NVP( id );
00109             ar << BOOST_SERIALIZATION_NVP( params );
00110         } 
00111 
00112         template<class Archive>
00113         friend void load_construct_data(Archive & ar, 
00114                                         Dummy * t, 
00115                                         const unsigned int file_version)
00116         {
00117             _AR_DBG(Dummy,"\n");
00118             ComponentId_t     id;
00119             Params_t          params;
00120             ar >> BOOST_SERIALIZATION_NVP( id );
00121             ar >> BOOST_SERIALIZATION_NVP( params );
00122             ::new(t)Dummy( id, params );
00123         } 
00124 };
00125 
00126 #endif

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