C[omp]ute

From: "andrew cooke" <andrew@...>

Date: Mon, 28 Jul 2008 20:36:24 -0400 (CLT)

I wrote the following code to simulate (perhaps not exactly) the memory
loads that would occur using CUDA if the data were processed using a
tiling that overlaps (so something like the Matrix example, but with
leaking across the boundaries of the box - perhaps for convolving with a
kernel, for example, or, as in my case, calculating "life").

Using the approach shown in the code (large integer types and a single
overlap) is inefficient because (at least for CUDA 1.0 ad 1.1) the reads
cannot be coalesced - either the half weft is the wrong width, or the
shift (which is less than the half-weft to allow for overlapping) is
wrong.

I'm going to see now if using a smaller integer type and overlapping a
whole half-weft makes more sense (sounds crazy, but might work...).

Andrew


(these is just the core block to give some idea of what's happening)

// run through each tile position
int count = 0;
for (int j = 0; j < nY; j++) {
    for (int i = 0; i < nX; i++) {
        // for each tile, run through the half-warps
        for (int k = 0; k < nHalfWarps; k++) {
            for (int l = 0; l < halfWarp; l++) {
                int localOffset = k * halfWarpWidth + l * word;
                int localX = localOffset % windowX;
                int localY = localOffset / windowX;
                int globalX = i * strideX + localX;
                int globalY = j * strideY + localY;
                int globalOffset = globalY * (*paddedX) + globalX;
                int segStart = globalOffset / segment;
                int segEnd =                                        \
                    (globalOffset + halfWarpWidth - word) / segment;

                if (prop.minor < 2) {
                    // 1.0 and 1.1 are really strict about what will
                    // be coalesced.
                    if (segStart == segEnd) {
                        count = count + 1;
                    } else {
                        count = count + halfWarp;
                    }
                } else {
                    // 1.2 is more lenient and simply groups as
                    // necessary
                    count = count + segEnd - segStart + 1;
                }
            }
        }
    }
}


And the output:

Loads for 1234,1234 using  184,  20 stepping  176,  19
8 bytes/word; 128 segments; 16 half-warp
Best count 3180010 for 184, 20 over 1240,1236

See how the stepping here is 8 bytes in 8 because I used 8 byte ints (even
though I only need 1 bit overlap)

The total number of theeads per block would be 184*20/8 = 460.