Question

I have a curve as follows:

float points[] = {1, 4, 6, 9, 14, 25, 69};
float images[] = {0.3, 0.4, 0.7, 0.9, 1, 2.5, 5.3};

In order to interpolate let’s say f(3) I would use linear interpolation between 1 and 4
In order to interpolate let’s say f(15) I would apply a binary search on the array of points and get the lowerBound which is 25 and consider interpolation in the interval [14,25] and so on..

I have found out this method is making my device function very slow. I’ve heard I can use texture memory and tex1D in order to do so ! is it possible even if points[] is not let’s say uniform (incremented by constant step)

Any idea ?

Answer 1

It looks like this problem can be broken into two parts:

1. Use the points array to convert the x value in f(x) to a floating point index between 0 and 7 (requires binary search on points[])
2. Use that floating point index to get a linearly interpolated value from the images array

Cuda texture memory can make step 2 very fast. I am guessing, however, that most of the time in your kernel is spent on step 1, and I don’t think texture memory can help you there.

If you aren’t already taking advantage of shared memory, moving your arrays to shared memory will give you a much bigger speedup than using texture memory. There is 48k of shared memory on recent hardware, so if your arrays are less than 24k (6k elements) they should both fit in shared memory. Step 1 can benefit greatly from shared memory because it requires non-contiguous reads of points[], which is very very slow in global memory.

If your arrays don’t fit in shared memory, you should break up your arrays into equally sized pieces with 6k elements each and assign each piece to a block. Have each block read through all of the points you are iterpolating, and have it ignore the point if it’s not within the portion of the points[] array stored in its shared memory.