src/mem/ruby/libruby.cc

   1
   2 #include <sys/wait.h>
   3 #include <algorithm>
   4
   5 #include "config/gems_root.hh"
   6 #include "mem/ruby/libruby_internal.hh"
   7 #include "mem/ruby/system/RubyPort.hh"
   8 #include "mem/ruby/system/System.hh"
   9 #include "mem/ruby/eventqueue/RubyEventQueue.hh"
  10 #include "mem/ruby/system/MemoryVector.hh"
  11 #include "mem/ruby/common/Address.hh"
  12 #include "mem/ruby/recorder/Tracer.hh"
  13
  14 string RubyRequestType_to_string(const RubyRequestType& obj)
  15 {
  16   switch(obj) {
  17   case RubyRequestType_IFETCH:
  18     return "IFETCH";
  19   case RubyRequestType_LD:
  20     return "LD";
  21   case RubyRequestType_ST:
  22     return "ST";
  23   case RubyRequestType_Locked_Read:
  24     return "Locked_Read";
  25   case RubyRequestType_Locked_Write:
  26     return "Locked_Write";
  27   case RubyRequestType_RMW_Read:
  28     return "RMW_Read";
  29   case RubyRequestType_RMW_Write:
  30     return "RMW_Write";
  31   case RubyRequestType_NULL:
  32   default:
  33     assert(0);
  34     return "";
  35   }
  36 }
  37
  38 RubyRequestType string_to_RubyRequestType(std::string str)
  39 {
  40   if (str == "IFETCH")
  41     return RubyRequestType_IFETCH;
  42   else if (str == "LD")
  43     return RubyRequestType_LD;
  44   else if (str == "ST")
  45     return RubyRequestType_ST;
  46   else if (str == "Locked_Read")
  47     return RubyRequestType_Locked_Read;
  48   else if (str == "Locked_Write")
  49     return RubyRequestType_Locked_Write;
  50   else if (str == "RMW_Read")
  51     return RubyRequestType_RMW_Read;
  52   else if (str == "RMW_Write")
  53     return RubyRequestType_RMW_Write;
  54   else
  55     assert(0);
  56   return RubyRequestType_NULL;
  57 }
  58
  59 ostream& operator<<(ostream& out, const RubyRequestType& obj)
  60 {
  61   cerr << "in op" << endl;
  62   out << RubyRequestType_to_string(obj);
  63   cerr << "flushing" << endl;
  64   out << flush;
  65   cerr << "done" << endl;
  66   return out;
  67 }
  68
  69 vector<string> tokenizeString(string str, string delims)
  70 {
  71   vector<string> tokens;
  72   char* pch;
  73   char* tmp;
  74   const char* c_delims = delims.c_str();
  75   tmp = new char[str.length()+1];
  76   strcpy(tmp, str.c_str());
  77   pch = strtok(tmp, c_delims);
  78   while (pch != NULL) {
  79     string tmp_str(pch);
  80     if (tmp_str == "null") tmp_str = "";
  81     tokens.push_back(tmp_str);
  82
  83     pch = strtok(NULL, c_delims);
  84   }
  85   delete [] tmp;
  86   return tokens;
  87 }
  88
  89 void libruby_init(const char* cfg_filename)
  90 {
  91   ifstream cfg_output(cfg_filename);
  92
  93   vector<RubyObjConf> * sys_conf = new vector<RubyObjConf>;
  94
  95   string line;
  96   getline(cfg_output, line) ;
  97   while ( !cfg_output.eof() ) {
  98     vector<string> tokens = tokenizeString(line, " ");
  99     assert(tokens.size() >= 2);
 100     vector<string> argv;
 101     for (size_t i=2; i<tokens.size(); i++) {
 102       std::replace(tokens[i].begin(), tokens[i].end(), '%', ' ');
 103       std::replace(tokens[i].begin(), tokens[i].end(), '#', '\n');
 104       argv.push_back(tokens[i]);
 105     }
 106     sys_conf->push_back(RubyObjConf(tokens[0], tokens[1], argv));
 107     tokens.clear();
 108     argv.clear();
 109     getline(cfg_output, line);
 110   }
 111
 112   RubySystem::create(*sys_conf);
 113   delete sys_conf;
 114 }
 115
 116 RubyPortHandle libruby_get_port(const char* port_name, void (*hit_callback)(int64_t access_id))
 117 {
 118   return static_cast<RubyPortHandle>(RubySystem::getPort(port_name, hit_callback));
 119 }
 120
 121 RubyPortHandle libruby_get_port_by_name(const char* port_name)
 122 {
 123   return static_cast<RubyPortHandle>(RubySystem::getPortOnly(port_name));
 124 }
 125
 126 void libruby_write_ram(uint64_t paddr, uint8_t* data, int len)
 127 {
 128   RubySystem::getMemoryVector()->write(Address(paddr), data, len);
 129 }
 130
 131 void libruby_read_ram(uint64_t paddr, uint8_t* data, int len)
 132 {
 133   RubySystem::getMemoryVector()->read(Address(paddr), data, len);
 134 }
 135
 136 int64_t libruby_issue_request(RubyPortHandle p, struct RubyRequest request)
 137 {
 138   return static_cast<RubyPort*>(p)->makeRequest(request);
 139 }
 140
 141 int libruby_tick(int n)
 142 {
 143   RubySystem::getEventQueue()->triggerEvents(RubySystem::getEventQueue()->getTime() + n);
 144   return 0;
 145 }
 146
 147 void libruby_destroy()
 148 {
 149 }
 150
 151 const char* libruby_last_error()
 152 {
 153   return "";
 154 }
 155
 156 void libruby_print_config(std::ostream & out)
 157 {
 158   RubySystem::printConfig(out);
 159 }
 160
 161 void libruby_print_stats(std::ostream & out)
 162 {
 163   RubySystem::printStats(out);
 164 }
 165 void libruby_playback_trace(char * trace_filename)
 166 {
 167   RubySystem::getTracer()->playbackTrace(trace_filename);
 168 }
 169
 170 void libruby_start_tracing(char * record_filename) {
 171   // start the trace
 172   RubySystem::getTracer()->startTrace(record_filename);
 173 }
 174
 175 void libruby_stop_tracing() {
 176   // start the trace
 177   RubySystem::getTracer()->stopTrace();
 178 }
 179
 180 uint64_t libruby_get_time() {
 181   return RubySystem::getCycleCount(0);
 182 }