src/cpu/o3/fu_pool.cc

   1 /*
   2  * Copyright (c) 2006 The Regents of The University of Michigan
   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  * Authors: Kevin Lim
  29  */
  30
  31 #include <sstream>
  32
  33 #include "cpu/o3/fu_pool.hh"
  34 #include "cpu/func_unit.hh"
  35 #include "params/FUPool.hh"
  36
  37 using namespace std;
  38
  39 ////////////////////////////////////////////////////////////////////////////
  40 //
  41 //  A pool of function units
  42 //
  43
  44 inline void
  45 FUPool::FUIdxQueue::addFU(int fu_idx)
  46 {
  47     funcUnitsIdx.push_back(fu_idx);
  48     ++size;
  49 }
  50
  51 inline int
  52 FUPool::FUIdxQueue::getFU()
  53 {
  54     int retval = funcUnitsIdx[idx++];
  55
  56     if (idx == size)
  57         idx = 0;
  58
  59     return retval;
  60 }
  61
  62 FUPool::~FUPool()
  63 {
  64     fuListIterator i = funcUnits.begin();
  65     fuListIterator end = funcUnits.end();
  66     for (; i != end; ++i)
  67         delete *i;
  68 }
  69
  70
  71 // Constructor
  72 FUPool::FUPool(string name, vector<FUDesc *> paramList)
  73     : SimObject(name)
  74 {
  75     numFU = 0;
  76
  77     funcUnits.clear();
  78
  79     for (int i = 0; i < Num_OpClasses; ++i) {
  80         maxOpLatencies[i] = 0;
  81         maxIssueLatencies[i] = 0;
  82     }
  83
  84     //
  85     //  Iterate through the list of FUDescData structures
  86     //
  87     for (FUDDiterator i = paramList.begin(); i != paramList.end(); ++i) {
  88
  89         //
  90         //  Don't bother with this if we're not going to create any FU's
  91         //
  92         if ((*i)->number) {
  93             //
  94             //  Create the FuncUnit object from this structure
  95             //   - add the capabilities listed in the FU's operation
  96             //     description
  97             //
  98             //  We create the first unit, then duplicate it as needed
  99             //
 100             FuncUnit *fu = new FuncUnit;
 101
 102             OPDDiterator j = (*i)->opDescList.begin();
 103             OPDDiterator end = (*i)->opDescList.end();
 104             for (; j != end; ++j) {
 105                 // indicate that this pool has this capability
 106                 capabilityList.set((*j)->opClass);
 107
 108                 // Add each of the FU's that will have this capability to the
 109                 // appropriate queue.
 110                 for (int k = 0; k < (*i)->number; ++k)
 111                     fuPerCapList[(*j)->opClass].addFU(numFU + k);
 112
 113                 // indicate that this FU has the capability
 114                 fu->addCapability((*j)->opClass, (*j)->opLat, (*j)->issueLat);
 115
 116                 if ((*j)->opLat > maxOpLatencies[(*j)->opClass])
 117                     maxOpLatencies[(*j)->opClass] = (*j)->opLat;
 118
 119                 if ((*j)->issueLat > maxIssueLatencies[(*j)->opClass])
 120                     maxIssueLatencies[(*j)->opClass] = (*j)->issueLat;
 121             }
 122
 123             numFU++;
 124
 125             //  Add the appropriate number of copies of this FU to the list
 126             ostringstream s;
 127
 128             s << (*i)->name() << "(0)";
 129             fu->name = s.str();
 130             funcUnits.push_back(fu);
 131
 132             for (int c = 1; c < (*i)->number; ++c) {
 133                 ostringstream s;
 134                 numFU++;
 135                 FuncUnit *fu2 = new FuncUnit(*fu);
 136
 137                 s << (*i)->name() << "(" << c << ")";
 138                 fu2->name = s.str();
 139                 funcUnits.push_back(fu2);
 140             }
 141         }
 142     }
 143
 144     unitBusy.resize(numFU);
 145
 146     for (int i = 0; i < numFU; i++) {
 147         unitBusy[i] = false;
 148     }
 149 }
 150
 151 void
 152 FUPool::annotateMemoryUnits(unsigned hit_latency)
 153 {
 154     maxOpLatencies[MemReadOp] = hit_latency;
 155
 156     fuListIterator i = funcUnits.begin();
 157     fuListIterator iend = funcUnits.end();
 158     for (; i != iend; ++i) {
 159         if ((*i)->provides(MemReadOp))
 160             (*i)->opLatency(MemReadOp) = hit_latency;
 161
 162         if ((*i)->provides(MemWriteOp))
 163             (*i)->opLatency(MemWriteOp) = hit_latency;
 164     }
 165 }
 166
 167 int
 168 FUPool::getUnit(OpClass capability)
 169 {
 170     //  If this pool doesn't have the specified capability,
 171     //  return this information to the caller
 172     if (!capabilityList[capability])
 173         return -2;
 174
 175     int fu_idx = fuPerCapList[capability].getFU();
 176     int start_idx = fu_idx;
 177
 178     // Iterate through the circular queue if needed, stopping if we've reached
 179     // the first element again.
 180     while (unitBusy[fu_idx]) {
 181         fu_idx = fuPerCapList[capability].getFU();
 182         if (fu_idx == start_idx) {
 183             // No FU available
 184             return -1;
 185         }
 186     }
 187
 188     assert(fu_idx < numFU);
 189
 190     unitBusy[fu_idx] = true;
 191
 192     return fu_idx;
 193 }
 194
 195 void
 196 FUPool::freeUnitNextCycle(int fu_idx)
 197 {
 198     assert(unitBusy[fu_idx]);
 199     unitsToBeFreed.push_back(fu_idx);
 200 }
 201
 202 void
 203 FUPool::processFreeUnits()
 204 {
 205     while (!unitsToBeFreed.empty()) {
 206         int fu_idx = unitsToBeFreed.back();
 207         unitsToBeFreed.pop_back();
 208
 209         assert(unitBusy[fu_idx]);
 210
 211         unitBusy[fu_idx] = false;
 212     }
 213 }
 214
 215 void
 216 FUPool::dump()
 217 {
 218     cout << "Function Unit Pool (" << name() << ")\n";
 219     cout << "======================================\n";
 220     cout << "Free List:\n";
 221
 222     for (int i = 0; i < numFU; ++i) {
 223         if (unitBusy[i]) {
 224             continue;
 225         }
 226
 227         cout << "  [" << i << "] : ";
 228
 229         cout << funcUnits[i]->name << " ";
 230
 231         cout << "\n";
 232     }
 233
 234     cout << "======================================\n";
 235     cout << "Busy List:\n";
 236     for (int i = 0; i < numFU; ++i) {
 237         if (!unitBusy[i]) {
 238             continue;
 239         }
 240
 241         cout << "  [" << i << "] : ";
 242
 243         cout << funcUnits[i]->name << " ";
 244
 245         cout << "\n";
 246     }
 247 }
 248
 249 void
 250 FUPool::switchOut()
 251 {
 252 }
 253
 254 void
 255 FUPool::takeOverFrom()
 256 {
 257     for (int i = 0; i < numFU; i++) {
 258         unitBusy[i] = false;
 259     }
 260     unitsToBeFreed.clear();
 261 }
 262
 263 //
 264
 265 ////////////////////////////////////////////////////////////////////////////
 266 //
 267 //  The SimObjects we use to get the FU information into the simulator
 268 //
 269 ////////////////////////////////////////////////////////////////////////////
 270
 271 //
 272 //    FUPool - Contails a list of FUDesc objects to make available
 273 //
 274
 275 //
 276 //  The FuPool object
 277 //
 278 FUPool *
 279 FUPoolParams::create()
 280 {
 281     return new FUPool(name, FUList);
 282 }