In this example, we compare different methods for memory copy. Again, we create a 2000*2000 Shepp Logan phantom on CPU. Then we use different methods to copy the phantom data into GPU memory.

Method 1: We make a new OpenCL grid from a CPU grid and iterate for number iterations.

for (int i = 0; i < number; i++){
            OpenCLGrid2D grid = new OpenCLGrid2D(shepp, context, device);
            grid.getDelegate().release();}    

Method 2: We make a new OpenCL grid from a previously existing OpenCL grid and iterate for the same number.

for (int i = 0; i < number; i++){
            OpenCLGrid2D grid = sheppCL.clone();
            grid.getDelegate().release();}

Method 3: For every iteration, we copy the phantom data from CPU memory to OpenCL memory using a linear buffer.

for (int i = 0; i < number; i++){
            queue.putWriteBuffer(sheppCL.getDelegate().getCLBuffer(), true);}

Method 4: First, allocate an OpenCL texture (called image in OpenCL language) and then overwrite the texture memory for number iterations. Note that the code below uses only buffers allocated in the OpenCL memory. We just copy data from OpenCL linear memory to the same OpenCL device into the texture memory.

CLImage2d<FloatBuffer> image = context.createImage2d(sheppCL.getDelegate().getCLBuffer().getBuffer(), sheppCL.getSize()[0], sheppCL.getSize()[1], format);
       
        for (int i = 0; i < number; i++){
            queue.putCopyBufferToImage(sheppCL.getDelegate().getCLBuffer(), image).finish();
        }
        image.release();

Method 5: For every iteration, we allocate a new texture on the OpenCL device and copy the image data from CPU memory to OpenCL texture memory:

for (int i = 0; i < number; i++){
            CLImage2d<FloatBuffer> image2 = context.createImage2d(sheppCL.getDelegate().getCLBuffer().getBuffer(), sheppCL.getSize()[0], sheppCL.getSize()[1], format);
            queue.putWriteImage(image2, true);
            queue.finish();
            image2.release();
}

Method 6:First, we allocate the OpenCL texture memory for the image data and then for every iteration we only write the image data into the OpenCL texture memory. This means we copy for every iteration data from CPU to the OpenCL device but don't need to reallocate OpenCL texture memory.

CLImage2d<FloatBuffer> image2 = context.createImage2d(sheppCL.getDelegate().getCLBuffer().getBuffer(), sheppCL.getSize()[0], sheppCL.getSize()[1], format);
       
        for (int i = 0; i < number; i++){
            queue.putWriteImage(image2, true);
            queue.finish();
        }
        image2.release();

Comparing the results for different methods displayed in Figure 1, we can observe that:

1. Overwriting OpenCL texture (Method 4) performs best as it is just copying inside the GPU texture memory. No memory from the host has to be accessed.
2. Method 3, Method 5, and Method 6 have almost the same time cost. Comparing Method 3 and Method 6, we can see copying data into the OpenCL linear memory is a little faster than texture memory. And Method 5 is faster than Method 6 because it doesn't need to reallocate OpenCL texture memory. There is, however, only a small difference.
3. Making a new OpenCL grid from a CPU grid (Method 1) or from an OpenCL grid (Method 2) is quite time consuming. Note that these two Methods operate both on CPU and OpenCL, and need to allocate and initialize memory on CPU and OpenCL plus data transfers.
4. For each method, with an increase in the iteration number, the time cost per iteration is decreasing slightly and converges to a constant. In order to avoid random time measurement results, a large number of iterations is necessary. Here, we chose 10,000 repeatitions (cf. Figure 2).