src/mem/ruby/slicc_interface/RubySlicc_Util.hh

   1 /*
   2  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * These are the functions that exported to slicc from ruby.
  31  */
  32
  33 #ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
  34 #define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
  35
  36 #include <cassert>
  37
  38 #include "debug/RubySlicc.hh"
  39 #include "mem/ruby/common/Address.hh"
  40 #include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh"
  41 #include "mem/packet.hh"
  42
  43 inline int
  44 random(int n)
  45 {
  46   return random() % n;
  47 }
  48
  49 inline Time
  50 zero_time()
  51 {
  52     return 0;
  53 }
  54
  55 inline Cycles TimeToCycles(Time t) { return Cycles(t); }
  56
  57 inline NodeID
  58 intToID(int nodenum)
  59 {
  60     NodeID id = nodenum;
  61     return id;
  62 }
  63
  64 inline int
  65 IDToInt(NodeID id)
  66 {
  67     int nodenum = id;
  68     return nodenum;
  69 }
  70
  71 inline Time
  72 getTimeModInt(Time time, int modulus)
  73 {
  74     return time % modulus;
  75 }
  76
  77 inline Time
  78 getTimePlusInt(Time addend1, int addend2)
  79 {
  80     return (Time) addend1 + addend2;
  81 }
  82
  83 inline Time
  84 getTimeMinusTime(Time t1, Time t2)
  85 {
  86     assert(t1 >= t2);
  87     return t1 - t2;
  88 }
  89
  90 // Return type for time_to_int is "Time" and not "int" so we get a
  91 // 64-bit integer
  92 inline Time
  93 time_to_int(Time time)
  94 {
  95     return time;
  96 }
  97
  98 // Appends an offset to an address
  99 inline Address
 100 setOffset(Address addr, int offset)
 101 {
 102     Address result = addr;
 103     result.setOffset(offset);
 104     return result;
 105 }
 106
 107 // Makes an address into a line address
 108 inline Address
 109 makeLineAddress(Address addr)
 110 {
 111     Address result = addr;
 112     result.makeLineAddress();
 113     return result;
 114 }
 115
 116 inline int
 117 addressOffset(Address addr)
 118 {
 119     return addr.getOffset();
 120 }
 121
 122 inline int
 123 mod(int val, int mod)
 124 {
 125     return val % mod;
 126 }
 127
 128 inline int max_tokens()
 129 {
 130   return 1024;
 131 }
 132
 133 /**
 134  * This function accepts an address, a data block and a packet. If the address
 135  * range for the data block contains the address which the packet needs to
 136  * read, then the data from the data block is written to the packet. True is
 137  * returned if the data block was read, otherwise false is returned.
 138  */
 139 inline bool
 140 testAndRead(Address addr, DataBlock& blk, Packet *pkt)
 141 {
 142     Address pktLineAddr(pkt->getAddr());
 143     pktLineAddr.makeLineAddress();
 144
 145     Address lineAddr = addr;
 146     lineAddr.makeLineAddress();
 147
 148     if (pktLineAddr == lineAddr) {
 149         uint8_t *data = pkt->getPtr<uint8_t>(true);
 150         unsigned int size_in_bytes = pkt->getSize();
 151         unsigned startByte = pkt->getAddr() - lineAddr.getAddress();
 152
 153         for (unsigned i = 0; i < size_in_bytes; ++i) {
 154             data[i] = blk.getByte(i + startByte);
 155         }
 156         return true;
 157     }
 158     return false;
 159 }
 160
 161 /**
 162  * This function accepts an address, a data block and a packet. If the address
 163  * range for the data block contains the address which the packet needs to
 164  * write, then the data from the packet is written to the data block. True is
 165  * returned if the data block was written, otherwise false is returned.
 166  */
 167 inline bool
 168 testAndWrite(Address addr, DataBlock& blk, Packet *pkt)
 169 {
 170     Address pktLineAddr(pkt->getAddr());
 171     pktLineAddr.makeLineAddress();
 172
 173     Address lineAddr = addr;
 174     lineAddr.makeLineAddress();
 175
 176     if (pktLineAddr == lineAddr) {
 177         uint8_t *data = pkt->getPtr<uint8_t>(true);
 178         unsigned int size_in_bytes = pkt->getSize();
 179         unsigned startByte = pkt->getAddr() - lineAddr.getAddress();
 180
 181         for (unsigned i = 0; i < size_in_bytes; ++i) {
 182             blk.setByte(i + startByte, data[i]);
 183         }
 184         return true;
 185     }
 186     return false;
 187 }
 188
 189 #endif // __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__