mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 06:09:01 +00:00
[NFC] Reformat code in events test (#1497)
Signed-off-by: Stuart Brady <stuart.brady@arm.com>
This commit is contained in:
Stuart Brady
@@ -1,6 +1,6 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
@@ -19,7 +19,8 @@
|
||||
|
||||
const cl_uint BufferSizeReductionFactor = 20;
|
||||
|
||||
cl_int Action::IGetPreferredImageSize2D( cl_device_id device, size_t &outWidth, size_t &outHeight )
|
||||
cl_int Action::IGetPreferredImageSize2D(cl_device_id device, size_t &outWidth,
|
||||
size_t &outHeight)
|
||||
{
|
||||
cl_ulong maxAllocSize;
|
||||
size_t maxWidth, maxHeight;
|
||||
@@ -27,23 +28,27 @@ cl_int Action::IGetPreferredImageSize2D( cl_device_id device, size_t &outWidt
|
||||
|
||||
|
||||
// Get the largest possible buffer we could allocate
|
||||
error = clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
|
||||
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL );
|
||||
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL );
|
||||
test_error( error, "Unable to get device config" );
|
||||
error = clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
|
||||
sizeof(maxAllocSize), &maxAllocSize, NULL);
|
||||
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH,
|
||||
sizeof(maxWidth), &maxWidth, NULL);
|
||||
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_HEIGHT,
|
||||
sizeof(maxHeight), &maxHeight, NULL);
|
||||
test_error(error, "Unable to get device config");
|
||||
|
||||
// Create something of a decent size
|
||||
if( maxWidth * maxHeight * 4 > maxAllocSize / BufferSizeReductionFactor )
|
||||
if (maxWidth * maxHeight * 4 > maxAllocSize / BufferSizeReductionFactor)
|
||||
{
|
||||
float rootSize = sqrtf( (float)( maxAllocSize / ( BufferSizeReductionFactor * 4 ) ) );
|
||||
float rootSize =
|
||||
sqrtf((float)(maxAllocSize / (BufferSizeReductionFactor * 4)));
|
||||
|
||||
if( (size_t)rootSize > maxWidth )
|
||||
if ((size_t)rootSize > maxWidth)
|
||||
outWidth = maxWidth;
|
||||
else
|
||||
outWidth = (size_t)rootSize;
|
||||
outHeight = (size_t)( ( maxAllocSize / ( BufferSizeReductionFactor * 4 ) ) / outWidth );
|
||||
if( outHeight > maxHeight )
|
||||
outHeight = maxHeight;
|
||||
outHeight = (size_t)((maxAllocSize / (BufferSizeReductionFactor * 4))
|
||||
/ outWidth);
|
||||
if (outHeight > maxHeight) outHeight = maxHeight;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -51,19 +56,18 @@ cl_int Action::IGetPreferredImageSize2D( cl_device_id device, size_t &outWidt
|
||||
outHeight = maxHeight;
|
||||
}
|
||||
|
||||
outWidth /=2;
|
||||
outHeight /=2;
|
||||
outWidth /= 2;
|
||||
outHeight /= 2;
|
||||
|
||||
if (outWidth > 2048)
|
||||
outWidth = 2048;
|
||||
if (outHeight > 2048)
|
||||
outHeight = 2048;
|
||||
if (outWidth > 2048) outWidth = 2048;
|
||||
if (outHeight > 2048) outHeight = 2048;
|
||||
log_info("\tImage size: %d x %d (%gMB)\n", (int)outWidth, (int)outHeight,
|
||||
(double)((int)outWidth*(int)outHeight*4)/(1024.0*1024.0));
|
||||
(double)((int)outWidth * (int)outHeight * 4) / (1024.0 * 1024.0));
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int Action::IGetPreferredImageSize3D( cl_device_id device, size_t &outWidth, size_t &outHeight, size_t &outDepth )
|
||||
cl_int Action::IGetPreferredImageSize3D(cl_device_id device, size_t &outWidth,
|
||||
size_t &outHeight, size_t &outDepth)
|
||||
{
|
||||
cl_ulong maxAllocSize;
|
||||
size_t maxWidth, maxHeight, maxDepth;
|
||||
@@ -71,28 +75,34 @@ cl_int Action::IGetPreferredImageSize3D( cl_device_id device, size_t &outWidt
|
||||
|
||||
|
||||
// Get the largest possible buffer we could allocate
|
||||
error = clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
|
||||
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL );
|
||||
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL );
|
||||
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof( maxDepth ), &maxDepth, NULL );
|
||||
test_error( error, "Unable to get device config" );
|
||||
error = clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
|
||||
sizeof(maxAllocSize), &maxAllocSize, NULL);
|
||||
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_WIDTH,
|
||||
sizeof(maxWidth), &maxWidth, NULL);
|
||||
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_HEIGHT,
|
||||
sizeof(maxHeight), &maxHeight, NULL);
|
||||
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH,
|
||||
sizeof(maxDepth), &maxDepth, NULL);
|
||||
test_error(error, "Unable to get device config");
|
||||
|
||||
// Create something of a decent size
|
||||
if( (cl_ulong)maxWidth * maxHeight * maxDepth > maxAllocSize / ( BufferSizeReductionFactor * 4 ) )
|
||||
if ((cl_ulong)maxWidth * maxHeight * maxDepth
|
||||
> maxAllocSize / (BufferSizeReductionFactor * 4))
|
||||
{
|
||||
float rootSize = cbrtf( (float)( maxAllocSize / ( BufferSizeReductionFactor * 4 ) ) );
|
||||
float rootSize =
|
||||
cbrtf((float)(maxAllocSize / (BufferSizeReductionFactor * 4)));
|
||||
|
||||
if( (size_t)rootSize > maxWidth )
|
||||
if ((size_t)rootSize > maxWidth)
|
||||
outWidth = maxWidth;
|
||||
else
|
||||
outWidth = (size_t)rootSize;
|
||||
if( (size_t)rootSize > maxHeight )
|
||||
if ((size_t)rootSize > maxHeight)
|
||||
outHeight = maxHeight;
|
||||
else
|
||||
outHeight = (size_t)rootSize;
|
||||
outDepth = (size_t)( ( maxAllocSize / ( BufferSizeReductionFactor * 4 ) ) / ( outWidth * outHeight ) );
|
||||
if( outDepth > maxDepth )
|
||||
outDepth = maxDepth;
|
||||
outDepth = (size_t)((maxAllocSize / (BufferSizeReductionFactor * 4))
|
||||
/ (outWidth * outHeight));
|
||||
if (outDepth > maxDepth) outDepth = maxDepth;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -101,25 +111,25 @@ cl_int Action::IGetPreferredImageSize3D( cl_device_id device, size_t &outWidt
|
||||
outDepth = maxDepth;
|
||||
}
|
||||
|
||||
outWidth /=2;
|
||||
outHeight /=2;
|
||||
outDepth /=2;
|
||||
outWidth /= 2;
|
||||
outHeight /= 2;
|
||||
outDepth /= 2;
|
||||
|
||||
if (outWidth > 512)
|
||||
outWidth = 512;
|
||||
if (outHeight > 512)
|
||||
outHeight = 512;
|
||||
if (outDepth > 512)
|
||||
outDepth = 512;
|
||||
log_info("\tImage size: %d x %d x %d (%gMB)\n", (int)outWidth, (int)outHeight, (int)outDepth,
|
||||
(double)((int)outWidth*(int)outHeight*(int)outDepth*4)/(1024.0*1024.0));
|
||||
if (outWidth > 512) outWidth = 512;
|
||||
if (outHeight > 512) outHeight = 512;
|
||||
if (outDepth > 512) outDepth = 512;
|
||||
log_info("\tImage size: %d x %d x %d (%gMB)\n", (int)outWidth,
|
||||
(int)outHeight, (int)outDepth,
|
||||
(double)((int)outWidth * (int)outHeight * (int)outDepth * 4)
|
||||
/ (1024.0 * 1024.0));
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
#pragma mark -------------------- Execution Sub-Classes -------------------------
|
||||
|
||||
cl_int NDRangeKernelAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int NDRangeKernelAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
const char *long_kernel[] = {
|
||||
"__kernel void sample_test(__global float *src, __global int *dst)\n"
|
||||
@@ -132,101 +142,116 @@ cl_int NDRangeKernelAction::Setup( cl_device_id device, cl_context context, cl_c
|
||||
" dst[tid] = (int)src[tid] * 3;\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
"}\n" };
|
||||
"}\n"
|
||||
};
|
||||
|
||||
size_t threads[1] = { 1000 };
|
||||
int error;
|
||||
|
||||
if( create_single_kernel_helper( context, &mProgram, &mKernel, 1, long_kernel, "sample_test" ) )
|
||||
if (create_single_kernel_helper(context, &mProgram, &mKernel, 1,
|
||||
long_kernel, "sample_test"))
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
error = get_max_common_work_group_size( context, mKernel, threads[0], &mLocalThreads[0] );
|
||||
test_error( error, "Unable to get work group size to use" );
|
||||
error = get_max_common_work_group_size(context, mKernel, threads[0],
|
||||
&mLocalThreads[0]);
|
||||
test_error(error, "Unable to get work group size to use");
|
||||
|
||||
mStreams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
|
||||
sizeof(cl_float) * 1000, NULL, &error);
|
||||
test_error( error, "Creating test array failed" );
|
||||
test_error(error, "Creating test array failed");
|
||||
mStreams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
|
||||
sizeof(cl_int) * 1000, NULL, &error);
|
||||
test_error( error, "Creating test array failed" );
|
||||
test_error(error, "Creating test array failed");
|
||||
|
||||
/* Set the arguments */
|
||||
error = clSetKernelArg( mKernel, 0, sizeof( mStreams[0] ), &mStreams[0] );
|
||||
test_error( error, "Unable to set kernel arguments" );
|
||||
error = clSetKernelArg( mKernel, 1, sizeof( mStreams[1] ), &mStreams[1] );
|
||||
test_error( error, "Unable to set kernel arguments" );
|
||||
error = clSetKernelArg(mKernel, 0, sizeof(mStreams[0]), &mStreams[0]);
|
||||
test_error(error, "Unable to set kernel arguments");
|
||||
error = clSetKernelArg(mKernel, 1, sizeof(mStreams[1]), &mStreams[1]);
|
||||
test_error(error, "Unable to set kernel arguments");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int NDRangeKernelAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int NDRangeKernelAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
size_t threads[1] = { 1000 };
|
||||
cl_int error = clEnqueueNDRangeKernel( queue, mKernel, 1, NULL, threads, mLocalThreads, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to execute kernel" );
|
||||
cl_int error =
|
||||
clEnqueueNDRangeKernel(queue, mKernel, 1, NULL, threads, mLocalThreads,
|
||||
numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to execute kernel");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
#pragma mark -------------------- Buffer Sub-Classes -------------------------
|
||||
|
||||
cl_int BufferAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue, bool allocate )
|
||||
cl_int BufferAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue, bool allocate)
|
||||
{
|
||||
cl_int error;
|
||||
cl_ulong maxAllocSize;
|
||||
|
||||
|
||||
// Get the largest possible buffer we could allocate
|
||||
error = clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
|
||||
error = clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
|
||||
sizeof(maxAllocSize), &maxAllocSize, NULL);
|
||||
|
||||
// Don't create a buffer quite that big, just so we have some space left over for other work
|
||||
mSize = (size_t)( maxAllocSize / BufferSizeReductionFactor );
|
||||
// Don't create a buffer quite that big, just so we have some space left
|
||||
// over for other work
|
||||
mSize = (size_t)(maxAllocSize / BufferSizeReductionFactor);
|
||||
|
||||
// Cap at 128M so tests complete in a reasonable amount of time.
|
||||
if (mSize > 128 << 20)
|
||||
mSize = 128 << 20;
|
||||
if (mSize > 128 << 20) mSize = 128 << 20;
|
||||
|
||||
mSize /=2;
|
||||
mSize /= 2;
|
||||
|
||||
log_info("\tBuffer size: %gMB\n", (double)mSize/(1024.0*1024.0));
|
||||
log_info("\tBuffer size: %gMB\n", (double)mSize / (1024.0 * 1024.0));
|
||||
|
||||
mBuffer = clCreateBuffer( context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, mSize, NULL, &error );
|
||||
test_error( error, "Unable to create buffer to test against" );
|
||||
mBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
|
||||
mSize, NULL, &error);
|
||||
test_error(error, "Unable to create buffer to test against");
|
||||
|
||||
mOutBuffer = malloc( mSize );
|
||||
if( mOutBuffer == NULL )
|
||||
mOutBuffer = malloc(mSize);
|
||||
if (mOutBuffer == NULL)
|
||||
{
|
||||
log_error( "ERROR: Unable to allocate temp buffer (out of memory)\n" );
|
||||
log_error("ERROR: Unable to allocate temp buffer (out of memory)\n");
|
||||
return CL_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int ReadBufferAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int ReadBufferAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
return BufferAction::Setup( device, context, queue, true );
|
||||
return BufferAction::Setup(device, context, queue, true);
|
||||
}
|
||||
|
||||
cl_int ReadBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int ReadBufferAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
cl_int error = clEnqueueReadBuffer( queue, mBuffer, CL_FALSE, 0, mSize, mOutBuffer, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue buffer read" );
|
||||
cl_int error = clEnqueueReadBuffer(queue, mBuffer, CL_FALSE, 0, mSize,
|
||||
mOutBuffer, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue buffer read");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int WriteBufferAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int WriteBufferAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
return BufferAction::Setup( device, context, queue, true );
|
||||
return BufferAction::Setup(device, context, queue, true);
|
||||
}
|
||||
|
||||
cl_int WriteBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int WriteBufferAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
cl_int error = clEnqueueWriteBuffer( queue, mBuffer, CL_FALSE, 0, mSize, mOutBuffer, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue buffer write" );
|
||||
cl_int error = clEnqueueWriteBuffer(queue, mBuffer, CL_FALSE, 0, mSize,
|
||||
mOutBuffer, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue buffer write");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
@@ -234,40 +259,46 @@ cl_int WriteBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_
|
||||
MapBufferAction::~MapBufferAction()
|
||||
{
|
||||
if (mQueue)
|
||||
clEnqueueUnmapMemObject( mQueue, mBuffer, mMappedPtr, 0, NULL, NULL );
|
||||
clEnqueueUnmapMemObject(mQueue, mBuffer, mMappedPtr, 0, NULL, NULL);
|
||||
}
|
||||
|
||||
cl_int MapBufferAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int MapBufferAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
return BufferAction::Setup( device, context, queue, false );
|
||||
return BufferAction::Setup(device, context, queue, false);
|
||||
}
|
||||
|
||||
cl_int MapBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int MapBufferAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
cl_int error;
|
||||
mQueue = queue;
|
||||
mMappedPtr = clEnqueueMapBuffer( queue, mBuffer, CL_FALSE, CL_MAP_READ, 0, mSize, numWaits, waits, outEvent, &error );
|
||||
test_error( error, "Unable to enqueue buffer map" );
|
||||
mMappedPtr = clEnqueueMapBuffer(queue, mBuffer, CL_FALSE, CL_MAP_READ, 0,
|
||||
mSize, numWaits, waits, outEvent, &error);
|
||||
test_error(error, "Unable to enqueue buffer map");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int UnmapBufferAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int UnmapBufferAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error = BufferAction::Setup( device, context, queue, false );
|
||||
if( error != CL_SUCCESS )
|
||||
return error;
|
||||
cl_int error = BufferAction::Setup(device, context, queue, false);
|
||||
if (error != CL_SUCCESS) return error;
|
||||
|
||||
mMappedPtr = clEnqueueMapBuffer( queue, mBuffer, CL_TRUE, CL_MAP_READ, 0, mSize, 0, NULL, NULL, &error );
|
||||
test_error( error, "Unable to enqueue buffer map" );
|
||||
mMappedPtr = clEnqueueMapBuffer(queue, mBuffer, CL_TRUE, CL_MAP_READ, 0,
|
||||
mSize, 0, NULL, NULL, &error);
|
||||
test_error(error, "Unable to enqueue buffer map");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int UnmapBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int UnmapBufferAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
cl_int error = clEnqueueUnmapMemObject( queue, mBuffer, mMappedPtr, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue buffer unmap" );
|
||||
cl_int error = clEnqueueUnmapMemObject(queue, mBuffer, mMappedPtr, numWaits,
|
||||
waits, outEvent);
|
||||
test_error(error, "Unable to enqueue buffer unmap");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
@@ -275,349 +306,410 @@ cl_int UnmapBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_
|
||||
|
||||
#pragma mark -------------------- Read/Write Image Classes -------------------------
|
||||
|
||||
cl_int ReadImage2DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int ReadImage2DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize2D( device, mWidth, mHeight ) ) )
|
||||
if ((error = IGetPreferredImageSize2D(device, mWidth, mHeight)))
|
||||
return error;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mImage = create_image_2d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
mImage = create_image_2d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mOutput = malloc( mWidth * mHeight * 4 );
|
||||
if( mOutput == NULL )
|
||||
mOutput = malloc(mWidth * mHeight * 4);
|
||||
if (mOutput == NULL)
|
||||
{
|
||||
log_error( "ERROR: Unable to allocate buffer: out of memory\n" );
|
||||
log_error("ERROR: Unable to allocate buffer: out of memory\n");
|
||||
return CL_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int ReadImage2DAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int ReadImage2DAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, 1 };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, 1 };
|
||||
|
||||
cl_int error = clEnqueueReadImage( queue, mImage, CL_FALSE, origin, region, 0, 0, mOutput, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue image read" );
|
||||
cl_int error = clEnqueueReadImage(queue, mImage, CL_FALSE, origin, region,
|
||||
0, 0, mOutput, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue image read");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int ReadImage3DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int ReadImage3DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize3D( device, mWidth, mHeight, mDepth ) ) )
|
||||
if ((error = IGetPreferredImageSize3D(device, mWidth, mHeight, mDepth)))
|
||||
return error;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mOutput = malloc( mWidth * mHeight * mDepth * 4 );
|
||||
if( mOutput == NULL )
|
||||
mOutput = malloc(mWidth * mHeight * mDepth * 4);
|
||||
if (mOutput == NULL)
|
||||
{
|
||||
log_error( "ERROR: Unable to allocate buffer: out of memory\n" );
|
||||
log_error("ERROR: Unable to allocate buffer: out of memory\n");
|
||||
return CL_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int ReadImage3DAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int ReadImage3DAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, mDepth };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, mDepth };
|
||||
|
||||
cl_int error = clEnqueueReadImage( queue, mImage, CL_FALSE, origin, region, 0, 0, mOutput, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue image read" );
|
||||
cl_int error = clEnqueueReadImage(queue, mImage, CL_FALSE, origin, region,
|
||||
0, 0, mOutput, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue image read");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int WriteImage2DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int WriteImage2DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize2D( device, mWidth, mHeight ) ) )
|
||||
if ((error = IGetPreferredImageSize2D(device, mWidth, mHeight)))
|
||||
return error;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mImage = create_image_2d( context, CL_MEM_WRITE_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mImage = create_image_2d(context, CL_MEM_WRITE_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mOutput = malloc( mWidth * mHeight * 4 );
|
||||
if( mOutput == NULL )
|
||||
mOutput = malloc(mWidth * mHeight * 4);
|
||||
if (mOutput == NULL)
|
||||
{
|
||||
log_error( "ERROR: Unable to allocate buffer: out of memory\n" );
|
||||
log_error("ERROR: Unable to allocate buffer: out of memory\n");
|
||||
return CL_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int WriteImage2DAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int WriteImage2DAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, 1 };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, 1 };
|
||||
|
||||
cl_int error = clEnqueueWriteImage( queue, mImage, CL_FALSE, origin, region, 0, 0, mOutput, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue image write" );
|
||||
cl_int error =
|
||||
clEnqueueWriteImage(queue, mImage, CL_FALSE, origin, region, 0, 0,
|
||||
mOutput, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue image write");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int WriteImage3DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int WriteImage3DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize3D( device, mWidth, mHeight, mDepth ) ) )
|
||||
if ((error = IGetPreferredImageSize3D(device, mWidth, mHeight, mDepth)))
|
||||
return error;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mOutput = malloc( mWidth * mHeight * mDepth * 4 );
|
||||
if( mOutput == NULL )
|
||||
mOutput = malloc(mWidth * mHeight * mDepth * 4);
|
||||
if (mOutput == NULL)
|
||||
{
|
||||
log_error( "ERROR: Unable to allocate buffer: out of memory\n" );
|
||||
log_error("ERROR: Unable to allocate buffer: out of memory\n");
|
||||
return CL_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int WriteImage3DAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int WriteImage3DAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, mDepth };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, mDepth };
|
||||
|
||||
cl_int error = clEnqueueWriteImage( queue, mImage, CL_FALSE, origin, region, 0, 0, mOutput, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue image write" );
|
||||
cl_int error =
|
||||
clEnqueueWriteImage(queue, mImage, CL_FALSE, origin, region, 0, 0,
|
||||
mOutput, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue image write");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
#pragma mark -------------------- Copy Image Classes -------------------------
|
||||
|
||||
cl_int CopyImageAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int CopyImageAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, mDepth };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, mDepth };
|
||||
|
||||
cl_int error = clEnqueueCopyImage( queue, mSrcImage, mDstImage, origin, origin, region, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue image copy" );
|
||||
cl_int error =
|
||||
clEnqueueCopyImage(queue, mSrcImage, mDstImage, origin, origin, region,
|
||||
numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue image copy");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyImage2Dto2DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int CopyImage2Dto2DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize2D( device, mWidth, mHeight ) ) )
|
||||
if ((error = IGetPreferredImageSize2D(device, mWidth, mHeight)))
|
||||
return error;
|
||||
|
||||
mWidth /= 2;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mSrcImage = create_image_2d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mSrcImage = create_image_2d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDstImage = create_image_2d( context, CL_MEM_WRITE_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mDstImage = create_image_2d(context, CL_MEM_WRITE_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDepth = 1;
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyImage2Dto3DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int CopyImage2Dto3DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize3D( device, mWidth, mHeight, mDepth ) ) )
|
||||
if ((error = IGetPreferredImageSize3D(device, mWidth, mHeight, mDepth)))
|
||||
return error;
|
||||
|
||||
mDepth /= 2;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mSrcImage = create_image_2d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mSrcImage = create_image_2d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDstImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mDstImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDepth = 1;
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyImage3Dto2DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int CopyImage3Dto2DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize3D( device, mWidth, mHeight, mDepth ) ) )
|
||||
if ((error = IGetPreferredImageSize3D(device, mWidth, mHeight, mDepth)))
|
||||
return error;
|
||||
|
||||
mDepth /= 2;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mSrcImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mSrcImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDstImage = create_image_2d( context, CL_MEM_WRITE_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mDstImage = create_image_2d(context, CL_MEM_WRITE_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDepth = 1;
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyImage3Dto3DAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int CopyImage3Dto3DAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize3D( device, mWidth, mHeight, mDepth ) ) )
|
||||
if ((error = IGetPreferredImageSize3D(device, mWidth, mHeight, mDepth)))
|
||||
return error;
|
||||
|
||||
mDepth /= 2;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mSrcImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mSrcImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDstImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mDstImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
#pragma mark -------------------- Copy Image/Buffer Classes -------------------------
|
||||
|
||||
cl_int Copy2DImageToBufferAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int Copy2DImageToBufferAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize2D( device, mWidth, mHeight ) ) )
|
||||
if ((error = IGetPreferredImageSize2D(device, mWidth, mHeight)))
|
||||
return error;
|
||||
|
||||
mWidth /= 2;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mSrcImage = create_image_2d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mSrcImage = create_image_2d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDstBuffer = clCreateBuffer( context, CL_MEM_WRITE_ONLY, mWidth * mHeight * 4, NULL, &error );
|
||||
test_error( error, "Unable to create buffer to test against" );
|
||||
mDstBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
||||
mWidth * mHeight * 4, NULL, &error);
|
||||
test_error(error, "Unable to create buffer to test against");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int Copy2DImageToBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int Copy2DImageToBufferAction::Execute(cl_command_queue queue,
|
||||
cl_uint numWaits, cl_event *waits,
|
||||
cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, 1 };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, 1 };
|
||||
|
||||
cl_int error = clEnqueueCopyImageToBuffer( queue, mSrcImage, mDstBuffer, origin, region, 0, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue image to buffer copy" );
|
||||
cl_int error =
|
||||
clEnqueueCopyImageToBuffer(queue, mSrcImage, mDstBuffer, origin, region,
|
||||
0, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue image to buffer copy");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int Copy3DImageToBufferAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int Copy3DImageToBufferAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize3D( device, mWidth, mHeight, mDepth ) ) )
|
||||
if ((error = IGetPreferredImageSize3D(device, mWidth, mHeight, mDepth)))
|
||||
return error;
|
||||
|
||||
mDepth /= 2;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mSrcImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mSrcImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
mDstBuffer = clCreateBuffer( context, CL_MEM_WRITE_ONLY, mWidth * mHeight * mDepth * 4, NULL, &error );
|
||||
test_error( error, "Unable to create buffer to test against" );
|
||||
mDstBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
|
||||
mWidth * mHeight * mDepth * 4, NULL, &error);
|
||||
test_error(error, "Unable to create buffer to test against");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int Copy3DImageToBufferAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int Copy3DImageToBufferAction::Execute(cl_command_queue queue,
|
||||
cl_uint numWaits, cl_event *waits,
|
||||
cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, mDepth };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, mDepth };
|
||||
|
||||
cl_int error = clEnqueueCopyImageToBuffer( queue, mSrcImage, mDstBuffer, origin, region, 0, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue image to buffer copy" );
|
||||
cl_int error =
|
||||
clEnqueueCopyImageToBuffer(queue, mSrcImage, mDstBuffer, origin, region,
|
||||
0, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue image to buffer copy");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyBufferTo2DImageAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int CopyBufferTo2DImageAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize2D( device, mWidth, mHeight ) ) )
|
||||
if ((error = IGetPreferredImageSize2D(device, mWidth, mHeight)))
|
||||
return error;
|
||||
|
||||
mWidth /= 2;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
|
||||
mSrcBuffer = clCreateBuffer( context, CL_MEM_READ_ONLY, mWidth * mHeight * 4, NULL, &error );
|
||||
test_error( error, "Unable to create buffer to test against" );
|
||||
mSrcBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY, mWidth * mHeight * 4,
|
||||
NULL, &error);
|
||||
test_error(error, "Unable to create buffer to test against");
|
||||
|
||||
mDstImage = create_image_2d( context, CL_MEM_WRITE_ONLY, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mDstImage = create_image_2d(context, CL_MEM_WRITE_ONLY, &format, mWidth,
|
||||
mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyBufferTo2DImageAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int CopyBufferTo2DImageAction::Execute(cl_command_queue queue,
|
||||
cl_uint numWaits, cl_event *waits,
|
||||
cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, 1 };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, 1 };
|
||||
|
||||
cl_int error = clEnqueueCopyBufferToImage( queue, mSrcBuffer, mDstImage, 0, origin, region, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue buffer to image copy" );
|
||||
cl_int error =
|
||||
clEnqueueCopyBufferToImage(queue, mSrcBuffer, mDstImage, 0, origin,
|
||||
region, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue buffer to image copy");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyBufferTo3DImageAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int CopyBufferTo3DImageAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize3D( device, mWidth, mHeight, mDepth ) ) )
|
||||
if ((error = IGetPreferredImageSize3D(device, mWidth, mHeight, mDepth)))
|
||||
return error;
|
||||
|
||||
mDepth /= 2;
|
||||
|
||||
mSrcBuffer = clCreateBuffer( context, CL_MEM_READ_ONLY, mWidth * mHeight * mDepth * 4, NULL, &error );
|
||||
test_error( error, "Unable to create buffer to test against" );
|
||||
mSrcBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY,
|
||||
mWidth * mHeight * mDepth * 4, NULL, &error);
|
||||
test_error(error, "Unable to create buffer to test against");
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mDstImage = create_image_3d( context, CL_MEM_READ_ONLY, &format, mWidth, mHeight, mDepth, 0, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mDstImage = create_image_3d(context, CL_MEM_READ_ONLY, &format, mWidth,
|
||||
mHeight, mDepth, 0, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int CopyBufferTo3DImageAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int CopyBufferTo3DImageAction::Execute(cl_command_queue queue,
|
||||
cl_uint numWaits, cl_event *waits,
|
||||
cl_event *outEvent)
|
||||
{
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, mDepth };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, mDepth };
|
||||
|
||||
cl_int error = clEnqueueCopyBufferToImage( queue, mSrcBuffer, mDstImage, 0, origin, region, numWaits, waits, outEvent );
|
||||
test_error( error, "Unable to enqueue buffer to image copy" );
|
||||
cl_int error =
|
||||
clEnqueueCopyBufferToImage(queue, mSrcBuffer, mDstImage, 0, origin,
|
||||
region, numWaits, waits, outEvent);
|
||||
test_error(error, "Unable to enqueue buffer to image copy");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
@@ -627,34 +719,39 @@ cl_int CopyBufferTo3DImageAction::Execute( cl_command_queue queue, cl_uint numWa
|
||||
MapImageAction::~MapImageAction()
|
||||
{
|
||||
if (mQueue)
|
||||
clEnqueueUnmapMemObject( mQueue, mImage, mMappedPtr, 0, NULL, NULL );
|
||||
clEnqueueUnmapMemObject(mQueue, mImage, mMappedPtr, 0, NULL, NULL);
|
||||
}
|
||||
|
||||
cl_int MapImageAction::Setup( cl_device_id device, cl_context context, cl_command_queue queue )
|
||||
cl_int MapImageAction::Setup(cl_device_id device, cl_context context,
|
||||
cl_command_queue queue)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
|
||||
if( ( error = IGetPreferredImageSize2D( device, mWidth, mHeight ) ) )
|
||||
if ((error = IGetPreferredImageSize2D(device, mWidth, mHeight)))
|
||||
return error;
|
||||
|
||||
cl_image_format format = { CL_RGBA, CL_SIGNED_INT8 };
|
||||
mImage = create_image_2d( context, CL_MEM_READ_ONLY | CL_MEM_ALLOC_HOST_PTR, &format, mWidth, mHeight, 0, NULL, &error );
|
||||
test_error( error, "Unable to create image to test against" );
|
||||
mImage = create_image_2d(context, CL_MEM_READ_ONLY | CL_MEM_ALLOC_HOST_PTR,
|
||||
&format, mWidth, mHeight, 0, NULL, &error);
|
||||
test_error(error, "Unable to create image to test against");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
cl_int MapImageAction::Execute( cl_command_queue queue, cl_uint numWaits, cl_event *waits, cl_event *outEvent )
|
||||
cl_int MapImageAction::Execute(cl_command_queue queue, cl_uint numWaits,
|
||||
cl_event *waits, cl_event *outEvent)
|
||||
{
|
||||
cl_int error;
|
||||
|
||||
size_t origin[ 3 ] = { 0, 0, 0 }, region[ 3 ] = { mWidth, mHeight, 1 };
|
||||
size_t origin[3] = { 0, 0, 0 }, region[3] = { mWidth, mHeight, 1 };
|
||||
size_t outPitch;
|
||||
|
||||
mQueue = queue;
|
||||
mMappedPtr = clEnqueueMapImage( queue, mImage, CL_FALSE, CL_MAP_READ, origin, region, &outPitch, NULL, numWaits, waits, outEvent, &error );
|
||||
test_error( error, "Unable to enqueue image map" );
|
||||
mMappedPtr =
|
||||
clEnqueueMapImage(queue, mImage, CL_FALSE, CL_MAP_READ, origin, region,
|
||||
&outPitch, NULL, numWaits, waits, outEvent, &error);
|
||||
test_error(error, "Unable to enqueue image map");
|
||||
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user