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

sst/elements/cpu_data/cpu_data.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 // A cpu component that can have statistics introspected 
00013 // Built for testing the introspector.
00014 
00015 #ifndef _CPU_DATA_H
00016 #define _CPU_DATA_H
00017 
00018 #include <sst/core/introspectedComponent.h>
00019 #include <sst/core/link.h>
00020 
00021 
00022 
00023 using namespace SST;
00024 
00025 #if DBG_CPU_DATA
00026 #define _CPU_DATA_DBG( fmt, args...)\
00027          printf( "%d:Cpu_data::%s():%d: "fmt, _debug_rank, __FUNCTION__,__LINE__, ## args )
00028 #else
00029 #define _CPU_DATA_DBG( fmt, args...)
00030 #endif
00031 
00032 class Cpu_data : public IntrospectedComponent {
00033         typedef enum { WAIT, SEND } state_t;
00034         typedef enum { WHO_NIC, WHO_MEM } who_t;
00035     public:
00036         Cpu_data( ComponentId_t id, Params_t& params ) :
00037             IntrospectedComponent( id ),
00038             state(SEND),
00039             who(WHO_MEM), 
00040             frequency( "2.2GHz" )
00041         {
00042             _CPU_DATA_DBG( "new id=%lu\n", id );
00043 
00044             registerExit();
00045 
00046             Params_t::iterator it = params.begin(); 
00047             while( it != params.end() ) { 
00048                 _CPU_DATA_DBG("key=%s value=%s\n",
00049                             it->first.c_str(),it->second.c_str());
00050                 if ( ! it->first.compare("clock") ) {
00051                     frequency = it->second;
00052                 }    
00053                 else if ( ! it->first.compare("push_introspector") ) {
00054                     pushIntrospector = it->second;
00055                 }    
00056 
00057                 ++it;
00058             } 
00059             
00060             mem = configureLink( "MEM" );
00061 //             handler = new EventHandler< Cpu_data, bool, Cycle_t >
00062 //                                                 ( this, &Cpu_data::clock );
00063 //          handlerPush = new EventHandler< Cpu_data, bool, Cycle_t >
00064 //                                                 ( this, &Cpu_data::pushData );
00065 
00066 //             TimeConverter* tc = registerClock( frequency, handler );
00067 //          registerClock( frequency, handlerPush );
00068 
00069             TimeConverter* tc = registerClock( frequency, new Clock::Handler<Cpu_data>(this, &Cpu_data::clock) );
00070             registerClock( frequency, new Clock::Handler<Cpu_data>( this, &Cpu_data::pushData) );
00071             mem->setDefaultTimeBase(tc);
00072 
00073             printf("CPU_DATA period: %ld\n", (long int)tc->getFactor());
00074             _CPU_DATA_DBG("Done registering clock\n");
00075 
00076             counts = 0;
00077             num_il1_read = 0;
00078             num_branch_read = 0;
00079             num_branch_write = 0;
00080             num_RAS_read = 0;
00081             num_RAS_write = 0;
00082 
00083             registerMonitorInt("il1_read");
00084             registerMonitorInt("branch_read");
00085             registerMonitorInt("RAS_read");
00086             registerMonitorInt("RAS_write");
00087             registerMonitorDouble("core_temperature");
00088             
00089 
00090         }
00091         int Setup() {   
00092            return 0;
00093         }
00094         int Finish() {
00095             _CPU_DATA_DBG("\n");
00096             //unregisterExit();
00097             return 0;
00098         }
00099         
00100         uint64_t getIntData(int dataID, int index=0)
00101         { 
00102           switch(dataID)
00103           {
00104             case 1:
00105             //branch_read
00106                 return (num_branch_read);
00107                 break;
00108             case 2: 
00109             //branch_write
00110                 return (num_branch_write);
00111                 break;
00112             case 3: 
00113             //RAS_read 
00114                 return (num_RAS_read);
00115                 break;
00116             case 4:
00117             //RAS_write
00118                 return (num_RAS_write);
00119                 break;
00120             case 5:
00121             //il1_read
00122                 return (num_il1_read);
00123                 break;
00124             default:
00125                 return (0);
00126                 break;  
00127           }
00128         }
00129         
00130         double getDoubleData(int dataID, int index=0)
00131         { 
00132           switch(dataID)
00133           {
00134             case 0:
00135             //core_temperature
00136                 return (mycore_temperature);
00137                 break;
00138             default:
00139                 return (0);
00140                 break;  
00141           }
00142         }
00143         
00144 
00145     public:
00146         int counts;
00147         double mycore_temperature;
00148         uint64_t num_il1_read;
00149         uint64_t num_branch_read;
00150         uint64_t num_branch_write;
00151         uint64_t num_RAS_read;
00152         uint64_t num_RAS_write;
00153 
00154     private:
00155         Cpu_data( const Cpu_data& c );
00156         Cpu_data() :  IntrospectedComponent(-1) {}// for serialization only
00157 
00158         bool clock( Cycle_t );
00159         bool pushData( Cycle_t);
00160 
00161         Link*       mem;
00162         state_t     state;
00163         who_t       who;
00164         std::string frequency;
00165         std::string pushIntrospector;
00166 
00167         friend class boost::serialization::access;
00168     template<class Archive>
00169     void serialize(Archive & ar, const unsigned int version )
00170     {
00171         ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Component);
00172         ar & BOOST_SERIALIZATION_NVP(mem);
00173         ar & BOOST_SERIALIZATION_NVP(state);
00174         ar & BOOST_SERIALIZATION_NVP(who);
00175         ar & BOOST_SERIALIZATION_NVP(frequency);
00176     }
00177 };
00178 
00179 #endif

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