add inner sub-loop testing from svstep Rc=1

[openpower-isa.git] / src / openpower / decoder / isa / remap_fft_yield.py

diff --git a/src/openpower/decoder/isa/remap_fft_yield.py b/src/openpower/decoder/isa/remap_fft_yield.py
index 4b1f411e4997d3b87e9f25b1afd5fea980edf6e3..422c2187867bba75c5a33d395e74d2d1081199d1 100644 (file)
--- a/src/openpower/decoder/isa/remap_fft_yield.py
+++ b/src/openpower/decoder/isa/remap_fft_yield.py
@@ -2,22 +2,22 @@
 # original code for the FFT Tukey-Cooley schedul:
 # https://www.nayuki.io/res/free-small-fft-in-multiple-languages/fft.py
 """
-       # Radix-2 decimation-in-time FFT
-       size = 2
-       while size <= n:
-               halfsize = size // 2
-               tablestep = n // size
-               for i in range(0, n, size):
-                       k = 0
-                       for j in range(i, i + halfsize):
+    # Radix-2 decimation-in-time FFT (real, not complex)
+    size = 2
+    while size <= n:
+        halfsize = size // 2
+        tablestep = n // size
+        for i in range(0, n, size):
+            k = 0
+            for j in range(i, i + halfsize):
                 jh = j+halfsize
                 jl = j
-                               temp1 = vec[jh] * exptable[k]
-                               temp2 = vec[jl]
-                               vec[jh] = temp2 - temp1
-                               vec[jl] = temp2 + temp1
-                               k += tablestep
-               size *= 2
+                temp1 = vec[jh] * exptable[k]
+                temp2 = vec[jl]
+                vec[jh] = temp2 - temp1
+                vec[jl] = temp2 + temp1
+                k += tablestep
+        size *= 2
 """
 
 # python "yield" can be iterated. use this to make it clear how
@@ -43,6 +43,7 @@ def iterate_butterfly_indices(SVSHAPE):
     skip = 0
     while True:
         for size in x_r:           # loop over 3rd order dimension (size)
+            x_end = size == x_r[-1]
             # y_r schedule depends on size
             halfsize = size // 2
             tablestep = n // size
@@ -52,6 +53,7 @@ def iterate_butterfly_indices(SVSHAPE):
             # invert if requested
             if SVSHAPE.invxyz[1]: y_r.reverse()
             for i in y_r:       # loop over 2nd order dimension
+                y_end = i == y_r[-1]
                 k_r = []
                 j_r = []
                 k = 0
@@ -63,10 +65,7 @@ def iterate_butterfly_indices(SVSHAPE):
                 if SVSHAPE.invxyz[2]: k_r.reverse()
                 if SVSHAPE.invxyz[2]: j_r.reverse()
                 for j, k in zip(j_r, k_r):   # loop over 1st order dimension
-                    # skip the first entries up to offset
-                    if skip < SVSHAPE.offset:
-                        skip += 1
-                        continue
+                    z_end = j == j_r[-1]
                     # now depending on MODE return the index
                     if SVSHAPE.skip == 0b00:
                         result = j              # for vec[j]
@@ -75,11 +74,15 @@ def iterate_butterfly_indices(SVSHAPE):
                     elif SVSHAPE.skip == 0b10:
                         result = k              # for exptable[k]
 
-                    yield result
+                    loopends = (z_end |
+                               ((y_end and z_end)<<1) |
+                                ((y_end and x_end and z_end)<<2))
+
+                    yield result + SVSHAPE.offset, loopends
 
 def demo():
     # set the dimension sizes here
-    xdim = 16
+    xdim = 8
     ydim = 0 # not needed
     zdim = 0 # again, not needed
 
@@ -103,29 +106,32 @@ def demo():
     SVSHAPE0 = SVSHAPE()
     SVSHAPE0.lims = [xdim, ydim, zdim]
     SVSHAPE0.order = [0,1,2]  # experiment with different permutations, here
-    SVSHAPE0.mode = 0b00
+    SVSHAPE0.mode = 0b01
+    SVSHAPE0.skip = 0b00
     SVSHAPE0.offset = 0       # experiment with different offset, here
     SVSHAPE0.invxyz = [0,0,0] # inversion if desired
     # j+halfstep schedule
     SVSHAPE1 = SVSHAPE()
     SVSHAPE1.lims = [xdim, ydim, zdim]
     SVSHAPE1.order = [0,1,2]  # experiment with different permutations, here
-    SVSHAPE1.mode = 0b01
+    SVSHAPE0.mode = 0b01
+    SVSHAPE1.skip = 0b01
     SVSHAPE1.offset = 0       # experiment with different offset, here
     SVSHAPE1.invxyz = [0,0,0] # inversion if desired
     # k schedule
     SVSHAPE2 = SVSHAPE()
     SVSHAPE2.lims = [xdim, ydim, zdim]
     SVSHAPE2.order = [0,1,2]  # experiment with different permutations, here
-    SVSHAPE2.mode = 0b10
+    SVSHAPE0.mode = 0b01
+    SVSHAPE2.skip = 0b10
     SVSHAPE2.offset = 0       # experiment with different offset, here
     SVSHAPE2.invxyz = [0,0,0] # inversion if desired
 
     # enumerate over the iterator function, getting new indices
     schedule = []
-    for idx, (jl, jh, k) in enumerate(zip(iterate_indices(SVSHAPE0),
-                                          iterate_indices(SVSHAPE1),
-                                          iterate_indices(SVSHAPE2))):
+    for idx, (jl, jh, k) in enumerate(zip(iterate_butterfly_indices(SVSHAPE0),
+                                          iterate_butterfly_indices(SVSHAPE1),
+                                          iterate_butterfly_indices(SVSHAPE2))):
         if idx >= VL:
             break
         schedule.append((jl, jh, k))
@@ -142,11 +148,13 @@ def demo():
             prefix = "i %d\t" % i
             k = 0
             for j in range(i, i + halfsize):
-                jl, jh, ks = schedule[idx]
+                (jl, je), (jh, he), (ks, ke) = schedule[idx]
                 print ("  %-3d\t%s j=%-2d jh=%-2d k=%-2d -> "
-                        "j[jl=%-2d] j[jh=%-2d] exptable[k=%d]" % \
+                        "j[jl=%-2d] j[jh=%-2d] ex[k=%d]" % \
                                 (idx, prefix, j, j+halfsize, k,
-                                      jl, jh, ks))
+                                      jl, jh, ks,
+                                ),
+                                "end", bin(je)[2:], bin(je)[2:], bin(ke)[2:])
                 k += tablestep
                 idx += 1
         size *= 2