src/gpu-compute/misc.hh

   1 /*
   2  * Copyright (c) 2011-2017 Advanced Micro Devices, Inc.
   3  * All rights reserved.
   4  *
   5  * For use for simulation and test purposes only
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright notice,
  11  * this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright notice,
  14  * this list of conditions and the following disclaimer in the documentation
  15  * and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the copyright holder nor the names of its
  18  * contributors may be used to endorse or promote products derived from this
  19  * software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #ifndef __MISC_HH__
  35 #define __MISC_HH__
  36
  37 #include <bitset>
  38 #include <limits>
  39 #include <memory>
  40
  41 #include "base/logging.hh"
  42 #include "sim/clocked_object.hh"
  43
  44 class GPUDynInst;
  45
  46 typedef std::bitset<std::numeric_limits<unsigned long long>::digits>
  47     VectorMask;
  48 typedef std::shared_ptr<GPUDynInst> GPUDynInstPtr;
  49
  50 enum InstMemoryHop : int {
  51     Initiate = 0,
  52     CoalsrSend = 1,
  53     CoalsrRecv = 2,
  54     GMEnqueue = 3,
  55     Complete = 4,
  56     InstMemoryHopMax = 5
  57 };
  58
  59 enum BlockMemoryHop : int {
  60     BlockSend = 0,
  61     BlockRecv = 1
  62 };
  63
  64 class WaitClass
  65 {
  66   public:
  67     WaitClass() : nxtAvail(0), lookAheadAvail(0), clockedObject(nullptr) { }
  68
  69     WaitClass(ClockedObject *_clockedObject, uint64_t _numStages=0)
  70         : nxtAvail(0), lookAheadAvail(0), clockedObject(_clockedObject),
  71           numStages(_numStages) { }
  72
  73     void init(ClockedObject *_clockedObject, uint64_t _numStages=0)
  74     {
  75         clockedObject = _clockedObject;
  76         numStages = _numStages;
  77     }
  78
  79     void set(uint64_t i)
  80     {
  81         fatal_if(nxtAvail > clockedObject->clockEdge(),
  82                  "Can't allocate resource because it is busy!!!");
  83         nxtAvail = clockedObject->clockEdge() + i;
  84     }
  85     void preset(uint64_t delay)
  86     {
  87         lookAheadAvail = std::max(lookAheadAvail, delay +
  88                 (clockedObject->clockEdge()) - numStages);
  89     }
  90     bool rdy(Cycles cycles = Cycles(0)) const
  91     {
  92         return clockedObject->clockEdge(cycles) >= nxtAvail;
  93     }
  94     bool prerdy() const
  95     {
  96         return clockedObject->clockEdge() >= lookAheadAvail;
  97     }
  98
  99   private:
 100     // timestamp indicating when resource will be available
 101     uint64_t nxtAvail;
 102     // timestamp indicating when resource will be available including
 103     // pending uses of the resource (when there is a cycle gap between
 104     // rdy() and set()
 105     uint64_t lookAheadAvail;
 106     // clockedObject for current timestamp
 107     ClockedObject *clockedObject;
 108     // number of stages between checking if a resource is ready and
 109     // setting the resource's utilization
 110     uint64_t numStages;
 111 };
 112
 113 class Float16
 114 {
 115   public:
 116     uint16_t val;
 117
 118     Float16() { val = 0; }
 119
 120     Float16(const Float16 &x) : val(x.val) { }
 121
 122     Float16(float x)
 123     {
 124         uint32_t ai = *(reinterpret_cast<uint32_t *>(&x));
 125
 126         uint32_t s = (ai >> 31) & 0x1;
 127         uint32_t exp = (ai >> 23) & 0xff;
 128         uint32_t mant = (ai >> 0) & 0x7fffff;
 129
 130         if (exp == 0 || exp <= 0x70) {
 131             exp = 0;
 132             mant = 0;
 133         } else if (exp == 0xff) {
 134             exp = 0x1f;
 135         } else if (exp >= 0x8f) {
 136             exp = 0x1f;
 137             mant = 0;
 138         } else {
 139             exp = exp - 0x7f + 0x0f;
 140         }
 141
 142         mant = mant >> 13;
 143
 144         val = 0;
 145         val |= (s << 15);
 146         val |= (exp << 10);
 147         val |= (mant << 0);
 148     }
 149
 150     operator float() const
 151     {
 152         uint32_t s = (val >> 15) & 0x1;
 153         uint32_t exp = (val >> 10) & 0x1f;
 154         uint32_t mant = (val >> 0) & 0x3ff;
 155
 156         if (!exp) {
 157             exp = 0;
 158             mant = 0;
 159         } else if (exp == 0x1f) {
 160             exp = 0xff;
 161         } else {
 162             exp = exp - 0x0f + 0x7f;
 163         }
 164
 165         uint32_t val1 = 0;
 166         val1 |= (s << 31);
 167         val1 |= (exp << 23);
 168         val1 |= (mant << 13);
 169
 170         return *(reinterpret_cast<float *>(&val1));
 171     }
 172 };
 173
 174 #endif // __MISC_HH__