src/openpower/decoder/isa/svshape.py

   1 from openpower.decoder.selectable_int import (FieldSelectableInt, SelectableInt,
   2                                         selectconcat)
   3 from openpower.decoder.isa.remapyield import iterate_indices
   4 from openpower.decoder.isa.remap_fft_yield import iterate_butterfly_indices
   5 from openpower.decoder.isa.remap_dct_yield import (
   6                                 iterate_dct_inner_butterfly_indices,
   7                                 iterate_dct_inner_costable_indices,
   8                                 iterate_dct_outer_butterfly_indices)
   9 from openpower.sv.svp64 import SVP64SHAPE
  10 import os
  11 from copy import deepcopy
  12 from openpower.util import log
  13
  14
  15 class SVSHAPE(SelectableInt):
  16     def __init__(self, value):
  17         SelectableInt.__init__(self, value, 32)
  18         offs = 0
  19         # set up sub-fields from Record layout
  20         self.fsi = {}
  21         l = deepcopy(SVP64SHAPE.layout)
  22         l.reverse()
  23         for field, width in l:
  24             end =  offs+width
  25             fs = tuple(range(offs, end))
  26             v = FieldSelectableInt(self, fs)
  27             self.fsi[field] = v
  28             log("SVSHAPE setup field", field, offs, end)
  29             offs = end
  30
  31     @property
  32     def submode2(self):
  33         return self.fsi['permute'].asint(msb0=True)
  34
  35     @submode2.setter
  36     def submode2(self, value):
  37         self.fsi['permute'].eq(value)
  38
  39     @property
  40     def order(self):
  41         permute = self.fsi['permute'].asint(msb0=True)
  42         return SVP64SHAPE.order(permute)
  43
  44     @order.setter
  45     def order(self, value):
  46         rorder = SVP64SHAPE.rorder(value)
  47         self.fsi['permute'].eq(rorder)
  48
  49     @property
  50     def xdimsz(self):
  51         return self.fsi['xdimsz'].asint(msb0=True)+1
  52
  53     @xdimsz.setter
  54     def xdimsz(self, value):
  55         self.fsi['xdimsz'].eq(value-1)
  56
  57     @property
  58     def ydimsz(self):
  59         return self.fsi['ydimsz'].asint(msb0=True)+1
  60
  61     @ydimsz.setter
  62     def ydimsz(self, value):
  63         self.fsi['ydimsz'].eq(value-1)
  64
  65     @property
  66     def zdimsz(self):
  67         return self.fsi['zdimsz'].asint(msb0=True)+1
  68
  69     @zdimsz.setter
  70     def zdimsz(self, value):
  71         self.fsi['zdimsz'].eq(value-1)
  72
  73     @property
  74     def lims(self):
  75         return [self.xdimsz, self.ydimsz, self.zdimsz]
  76
  77     @lims.setter
  78     def lims(self, value):
  79         self.xdimsz = value[0]
  80         self.ydimsz = value[1]
  81         self.zdimsz = value[2]
  82
  83     @property
  84     def invxyz(self):
  85         inv = self.fsi['invxyz'].asint(msb0=True)
  86         return [(inv & 0b1), (inv & 0b10) >> 1, (inv & 0b100) >> 2]
  87
  88     @invxyz.setter
  89     def invxyz(self, value):
  90         self.fsi['invxyz'].eq(value[0] | (value[1]<<1) | (value[2]<<2))
  91
  92     @property
  93     def mode(self):
  94         return self.fsi['mode'].asint(msb0=True)
  95
  96     @mode.setter
  97     def mode(self, value):
  98         self.fsi['mode'].eq(value)
  99
 100     @property
 101     def skip(self):
 102         return self.fsi['skip'].asint(msb0=True)
 103
 104     @skip.setter
 105     def skip(self, value):
 106         self.fsi['skip'].eq(value)
 107
 108     @property
 109     def offset(self):
 110         return self.fsi['offset'].asint(msb0=True)
 111
 112     @offset.setter
 113     def offset(self, value):
 114         self.fsi['offset'].eq(value)
 115
 116     def get_iterator(self):
 117         log ("SVSHAPE get_iterator", self.mode, self.ydimsz)
 118         if self.mode == 0b00:
 119             iterate_fn = iterate_indices
 120         elif self.mode == 0b01:
 121             # further sub-selection
 122             if self.ydimsz == 1:
 123                 iterate_fn = iterate_butterfly_indices
 124             elif self.ydimsz in [2, 4]:
 125                 iterate_fn = iterate_dct_inner_butterfly_indices
 126             elif self.ydimsz == 3:
 127                 iterate_fn = iterate_dct_outer_butterfly_indices
 128             elif self.ydimsz == 5:
 129                 iterate_fn = iterate_dct_inner_costable_indices
 130         # create a **NEW** iterator each time this is called
 131         return iterate_fn(deepcopy(self))
 132
 133
 134 if __name__ == '__main__':
 135     os.environ['SILENCELOG'] = "1"
 136     xdim = 3
 137     ydim = 2
 138     zdim = 1
 139     SVSHAPE0 = SVSHAPE(0)
 140     SVSHAPE0.lims = [xdim, ydim, zdim]
 141     SVSHAPE0.order = [1,0,2]  # experiment with different permutations, here
 142     SVSHAPE0.mode = 0b00
 143     SVSHAPE0.skip = 0b00
 144     SVSHAPE0.offset = 0       # experiment with different offset, here
 145     SVSHAPE0.invxyz = [0,0,0] # inversion if desired
 146
 147     VL = xdim * ydim * zdim
 148
 149     print ("Matrix Mode")
 150     for idx, new_idx in enumerate(SVSHAPE0.get_iterator()):
 151         if idx >= VL:
 152             break
 153         print ("%d->%d" % (idx, new_idx))
 154
 155     print ("")
 156     print ("FFT Mode")
 157
 158     # set the dimension sizes here
 159     xdim = 8
 160     ydim = 0 # not needed
 161     zdim = 0 # again, not needed
 162
 163     # set total. err don't know how to calculate how many there are...
 164     # do it manually for now
 165
 166     VL = 0
 167     size = 2
 168     n = xdim
 169     while size <= n:
 170         halfsize = size // 2
 171         tablestep = n // size
 172         for i in range(0, n, size):
 173             for j in range(i, i + halfsize):
 174                 VL += 1
 175         size *= 2
 176
 177     # j schedule
 178     SVSHAPE0 = SVSHAPE(0)
 179     SVSHAPE0.lims = [xdim, ydim, zdim]
 180     SVSHAPE0.order = [0,1,2]  # experiment with different permutations, here
 181     SVSHAPE0.mode = 0b00
 182     SVSHAPE0.offset = 0       # experiment with different offset, here
 183     SVSHAPE0.invxyz = [0,0,0] # inversion if desired
 184     # j+halfstep schedule
 185     SVSHAPE1 = SVSHAPE(0)
 186     SVSHAPE1.lims = [xdim, ydim, zdim]
 187     SVSHAPE1.order = [0,1,2]  # experiment with different permutations, here
 188     SVSHAPE1.mode = 0b01
 189     SVSHAPE1.offset = 0       # experiment with different offset, here
 190     SVSHAPE1.invxyz = [0,0,0] # inversion if desired
 191     # k schedule
 192     SVSHAPE2 = SVSHAPE(0)
 193     SVSHAPE2.lims = [xdim, ydim, zdim]
 194     SVSHAPE2.order = [0,1,2]  # experiment with different permutations, here
 195     SVSHAPE2.mode = 0b10
 196     SVSHAPE2.offset = 0       # experiment with different offset, here
 197     SVSHAPE2.invxyz = [0,0,0] # inversion if desired
 198
 199     # enumerate over the iterator function, getting new indices
 200     schedule = []
 201     for idx, (jl, jh, k) in enumerate(zip(iterate_indices(SVSHAPE0),
 202                                           iterate_indices(SVSHAPE1),
 203                                           iterate_indices(SVSHAPE2))):
 204         if idx >= VL:
 205             break
 206         schedule.append((jl, jh, k))
 207
 208     # ok now pretty-print the results, with some debug output
 209     size = 2
 210     idx = 0
 211     while size <= n:
 212         halfsize = size // 2
 213         tablestep = n // size
 214         print ("size %d halfsize %d tablestep %d" % \
 215                 (size, halfsize, tablestep))
 216         for i in range(0, n, size):
 217             prefix = "i %d\t" % i
 218             k = 0
 219             for j in range(i, i + halfsize):
 220                 jl, jh, ks = schedule[idx]
 221                 print ("  %-3d\t%s j=%-2d jh=%-2d k=%-2d -> "
 222                         "j[jl=%-2d] j[jh=%-2d] exptable[k=%d]" % \
 223                                 (idx, prefix, j, j+halfsize, k,
 224                                       jl, jh, ks))
 225                 k += tablestep
 226                 idx += 1
 227         size *= 2
 228