src/mem/ruby/libruby.hh

   1
   2 #ifndef LIBRUBY_H
   3 #define LIBRUBY_H
   4
   5 #include <stdint.h>
   6 #include <ostream>
   7
   8 typedef void* RubyPortHandle;
   9 enum RubyRequestType {
  10   RubyRequestType_NULL,
  11   RubyRequestType_IFETCH,
  12   RubyRequestType_LD,
  13   RubyRequestType_ST,
  14   RubyRequestType_Locked_Read,
  15   RubyRequestType_Locked_Write,
  16   RubyRequestType_RMW_Read,
  17   RubyRequestType_RMW_Write,
  18   RubyRequestType_NUM
  19 };
  20
  21 enum RubyAccessMode {
  22   RubyAccessMode_User,
  23   RubyAccessMode_Supervisor,
  24   RubyAccessMode_Device
  25 };
  26
  27 struct RubyRequest {
  28   uint64_t paddr;
  29   uint8_t* data;
  30   int len;
  31   uint64_t pc;
  32   RubyRequestType type;
  33   RubyAccessMode access_mode;
  34   unsigned proc_id;
  35
  36   RubyRequest() {}
  37   RubyRequest(uint64_t _paddr, uint8_t* _data, int _len, uint64_t _pc, RubyRequestType _type, RubyAccessMode _access_mode, unsigned _proc_id = 0)
  38     : paddr(_paddr), data(_data), len(_len), pc(_pc), type(_type), access_mode(_access_mode), proc_id(_proc_id)
  39   {}
  40 };
  41
  42 /**
  43  * Initialize the system.  cfg_file is a Ruby-lang configuration script
  44  */
  45 void libruby_init(const char* cfg_file);
  46
  47 /**
  48  * Tear down a configured system.  Must be invoked after a call to libruby_init.
  49  */
  50 void libruby_destroy();
  51
  52 /**
  53  * Print the last error encountered by ruby.  Currently unimplemented.
  54  */
  55 const char* libruby_last_error();
  56
  57 /**
  58  *  Retrieve a handle to a RubyPort object, identified by name in the
  59  *  configuration.  You also pass in the callback function you want
  60  *  this port to use when a request completes.  Only one handle to a
  61  *  port is allowed at a time.
  62  */
  63 RubyPortHandle libruby_get_port(const char* name, void (*hit_callback)(int64_t access_id));
  64
  65 /**
  66  *  Retrieve a handle to a RubyPort object, identified by name in the
  67  *  configuration.
  68  */
  69 RubyPortHandle libruby_get_port_by_name(const char* name);
  70
  71
  72 /**
  73  * issue_request returns a unique access_id to identify the ruby
  74  * transaction. This access_id is later returned to the caller via
  75  * hit_callback (passed to libruby_get_port)
  76  */
  77 int64_t libruby_issue_request(RubyPortHandle p, struct RubyRequest request);
  78
  79 /**
  80  * writes data directly into Ruby's data array.  Note that this
  81  * ignores caches, and should be considered incoherent after
  82  * simulation starts.
  83  */
  84 void libruby_write_ram(uint64_t paddr, uint8_t * data, int len);
  85
  86 /**
  87  * reads data directory from Ruby's data array.  Note that this
  88  * ignores caches, and should be considered incoherent after
  89  * simulation starts
  90  */
  91 void libruby_read_ram(uint64_t paddr, uint8_t * data, int len);
  92
  93 /**
  94  * tick the system n cycles.  Eventually, will return the number of
  95  * cycles until the next event, but for now it always returns 0
  96  */
  97 int libruby_tick(int n);
  98
  99 /**
 100  *  self explainitory
 101  */
 102 void libruby_print_config(std::ostream & out);
 103
 104 /**
 105  * self explainitory
 106  */
 107 void libruby_print_stats(std::ostream & out);
 108
 109 /**
 110  * does not return until done
 111  */
 112 void libruby_playback_trace(char * trace_filename);
 113
 114 /*
 115  * enables the tracer and opens the trace file
 116  */
 117 void libruby_start_tracing(char * record_filename);
 118
 119 /*
 120  * closes the trace file
 121  */
 122 void libruby_stop_tracing();
 123
 124 /**
 125  * get time
 126  */
 127 uint64_t libruby_get_time();
 128 #endif