def gpu_fprop_tune()

in src/dev/spatial_conv.py [0:0]

• 60 lines of code
• 16 McCabe index (conditional complexity)

    def gpu_fprop_tune(self):

        C, H, W, N, P, Q, R, S, pad_r, pad_s, std = self.fprop_params
        results = list()
        TILE_P  = 8;
        TILE_Q  = 8;
        TILE_N  = 16;
        TILE_H  = TILE_P + R - 1;
        TILE_W1 = TILE_Q + S - 1;
        TILE_W  = ceil_div(TILE_W1, 8)*8;
        TILE_PQ = TILE_P * TILE_Q;
        TILE_HW = TILE_H * TILE_W;
        TILE_RW =      R * TILE_W;
        #wys = (4,2,1) if R <= 10 else (2,1)
        for WARP_Y in (2,):
            for WARP_X in range(1,5):
                THREADS = WARP_X * WARP_Y * 32;

                TILE_X   = ceil_div(TILE_RW, WARP_X*8)*8
                TILE_Y   = TILE_P // WARP_Y
                TILE_RW4 = TILE_X  * WARP_X

                STRD_RW  = TILE_RW4 if TILE_RW4 & (16|8|4) else TILE_RW4 + 4
                STRD_HW  = (TILE_HW + TILE_RW4 - TILE_RW) | 4

                SIZE_F = STRD_RW*4 + 8;
                SIZE_I = STRD_HW * TILE_N;
                SIZE_O = WARP_X*TILE_PQ*TILE_N if WARP_X > 1 else 0

                F_LOOPS = ceil_div(STRD_RW, THREADS)
                I_LOOPS = ceil_div(STRD_HW, THREADS)

                SHARE  = max((SIZE_F + SIZE_I)*2, SIZE_O*4)
                BLOCKS = min(49152*2 // SHARE, 1024 // THREADS)
                if 64 <= THREADS <= 1024 and SHARE <= 49152:
                    for b in range(1, BLOCKS+1):
                        op = f"k:8 t:{THREADS:4d} wy:{WARP_Y:d} wx:{WARP_X:d} b:{b:2d} ma:{TILE_X//2:4d} fl:{F_LOOPS:2d} il:{I_LOOPS:2d} sh:{SHARE:5d}"
                        #print(op)

                        kernel, devO, cpuO = xprop_kernel(self.gpu_fprop_params, self.fprop_params, fprop=1, config=(8,WARP_Y,WARP_X,b))
                        results.append(self.execute(kernel, devO, cpuO, op))

        TILE_W  = ceil_div(TILE_W1, 4)*4;
        TILE_PQ = TILE_P * TILE_Q;
        TILE_HW = TILE_H * TILE_W;
        TILE_RW =      R * TILE_W;
        #wys = (4,2,1) if R <= 10 else (2,1)
        for WARP_Y in (2,1):
            for WARP_X in range(1,9):
                THREADS = WARP_X * WARP_Y * 32;

                TILE_X   = ceil_div(TILE_RW, WARP_X*4)*4
                TILE_Y   = 4 // WARP_Y
                TILE_RW4 = TILE_X  * WARP_X

                STRD_RW  = TILE_RW4 | 4
                STRD_HW  = (TILE_HW + TILE_RW4 - TILE_RW) | 4

                SIZE_F = STRD_RW*4 + 8;
                SIZE_I = STRD_HW * TILE_N;
                SIZE_O = WARP_X*TILE_PQ*TILE_N

                F_LOOPS = ceil_div(STRD_RW, THREADS)
                I_LOOPS = ceil_div(STRD_HW, THREADS)

                SHARE  = max((SIZE_F + SIZE_I)*2, SIZE_O*4)
                BLOCKS = min(49152*2 // SHARE, 1024 // THREADS)
                if 64 <= THREADS <= 1024 and SHARE <= 49152:
                    for b in range(1, BLOCKS+1):
                        op = f"k:4 t:{THREADS:4d} wy:{WARP_Y:d} wx:{WARP_X:d} b:{b:2d} ma:{TILE_X:4d} fl:{F_LOOPS:2d} il:{I_LOOPS:2d} sh:{SHARE:5d}"
                        #print(op)

                        kernel, devO, cpuO = xprop_kernel(self.gpu_fprop_params, self.fprop_params, fprop=1, config=(4, WARP_Y, WARP_X, b))
                        results.append(self.execute(kernel, devO, cpuO, op))
        print(R, S)
        for g, s in sorted(results):
            print(s)
        print("", flush=True)