src/gpu-compute/misc.hh

   1 /*
   2  * Copyright (c) 2011-2015 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 contributors
  18  * may be used to endorse or promote products derived from this software
  19  * 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  * Author: Steve Reinhardt
  34  */
  35
  36 #ifndef __MISC_HH__
  37 #define __MISC_HH__
  38
  39 #include <bitset>
  40 #include <memory>
  41
  42 #include "base/misc.hh"
  43
  44 class GPUDynInst;
  45
  46 // wavefront size of the machine
  47 static const int VSZ = 64;
  48
  49 /*
  50  This check is necessary because std::bitset only provides conversion to
  51  unsigned long or unsigned long long via to_ulong() or to_ullong(). there are
  52  a few places in the code where to_ullong() is used, however if VSZ is larger
  53  than a value the host can support then bitset will throw a runtime exception.
  54
  55  we should remove all use of to_long() or to_ullong() so we can have VSZ
  56  greater than 64b, however until that is done this assert is required.
  57  */
  58 static_assert(VSZ <= sizeof(unsigned long long) * 8,
  59               "VSZ is larger than the host can support");
  60
  61 typedef std::bitset<VSZ> VectorMask;
  62 typedef std::shared_ptr<GPUDynInst> GPUDynInstPtr;
  63
  64 class WaitClass
  65 {
  66   public:
  67     WaitClass() : nxtAvail(0), lookAheadAvail(0), tcnt(0) { }
  68     void init(uint64_t *_tcnt, uint32_t _numStages=0)
  69     {
  70         tcnt = _tcnt;
  71         numStages = _numStages;
  72     }
  73
  74     void set(uint32_t i)
  75     {
  76         fatal_if(nxtAvail > *tcnt,
  77                  "Can't allocate resource because it is busy!!!");
  78         nxtAvail = *tcnt + i;
  79     }
  80     void preset(uint32_t delay)
  81     {
  82         lookAheadAvail = std::max(lookAheadAvail, delay + (*tcnt) - numStages);
  83     }
  84     bool rdy() const { return *tcnt >= nxtAvail; }
  85     bool prerdy() const { return *tcnt >= lookAheadAvail; }
  86
  87   private:
  88     // timestamp indicating when resource will be available
  89     uint64_t nxtAvail;
  90     // timestamp indicating when resource will be available including
  91     // pending uses of the resource (when there is a cycle gap between
  92     // rdy() and set()
  93     uint64_t lookAheadAvail;
  94     // current timestamp
  95     uint64_t *tcnt;
  96     // number of stages between checking if a resource is ready and
  97     // setting the resource's utilization
  98     uint32_t numStages;
  99 };
 100
 101 class Float16
 102 {
 103   public:
 104     uint16_t val;
 105
 106     Float16() { val = 0; }
 107
 108     Float16(const Float16 &x) : val(x.val) { }
 109
 110     Float16(float x)
 111     {
 112         uint32_t ai = *(uint32_t *)&x;
 113
 114         uint32_t s = (ai >> 31) & 0x1;
 115         uint32_t exp = (ai >> 23) & 0xff;
 116         uint32_t mant = (ai >> 0) & 0x7fffff;
 117
 118         if (exp == 0 || exp <= 0x70) {
 119             exp = 0;
 120             mant = 0;
 121         } else if (exp == 0xff) {
 122             exp = 0x1f;
 123         } else if (exp >= 0x8f) {
 124             exp = 0x1f;
 125             mant = 0;
 126         } else {
 127             exp = exp - 0x7f + 0x0f;
 128         }
 129
 130         mant = mant >> 13;
 131
 132         val = 0;
 133         val |= (s << 15);
 134         val |= (exp << 10);
 135         val |= (mant << 0);
 136     }
 137
 138     operator float() const
 139     {
 140         uint32_t s = (val >> 15) & 0x1;
 141         uint32_t exp = (val >> 10) & 0x1f;
 142         uint32_t mant = (val >> 0) & 0x3ff;
 143
 144         if (!exp) {
 145             exp = 0;
 146             mant = 0;
 147         } else if (exp == 0x1f) {
 148             exp = 0xff;
 149         } else {
 150             exp = exp - 0x0f + 0x7f;
 151         }
 152
 153         uint32_t val1 = 0;
 154         val1 |= (s << 31);
 155         val1 |= (exp << 23);
 156         val1 |= (mant << 13);
 157
 158         return *(float*)&val1;
 159     }
 160 };
 161
 162 #endif // __MISC_HH__