test_conformance/basic/test_enqueue_map.cpp - external/github.com/KhronosGroup/OpenCL-CTS - Git at Google

 //
 // 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
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 #include "harness/compat.h"

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>


 #include "procs.h"
 #include "harness/conversions.h"
 #include "harness/typeWrappers.h"

 const cl_mem_flags flag_set[] = {
   CL_MEM_ALLOC_HOST_PTR,
   CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR,
   CL_MEM_USE_HOST_PTR,
   CL_MEM_COPY_HOST_PTR,
   0
 };
 const char* flag_set_names[] = {
   "CL_MEM_ALLOC_HOST_PTR",
   "CL_MEM_ALLOC_HOST_PTR | CL_MEM_COPY_HOST_PTR",
   "CL_MEM_USE_HOST_PTR",
   "CL_MEM_COPY_HOST_PTR",
   "0"
 };

 int test_enqueue_map_buffer(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
 {
     int error;
     const size_t bufferSize = 256*256;
     MTdataHolder d{gRandomSeed};
     BufferOwningPtr<cl_char> hostPtrData{ malloc(bufferSize) };
     BufferOwningPtr<cl_char> referenceData{ malloc(bufferSize) };
     BufferOwningPtr<cl_char> finalData{malloc(bufferSize)};

     for (int src_flag_id=0; src_flag_id < ARRAY_SIZE(flag_set); src_flag_id++)
     {
         clMemWrapper memObject;
         log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]);

         generate_random_data(kChar, (unsigned int)bufferSize, d, hostPtrData);
         memcpy(referenceData, hostPtrData, bufferSize);

         void *hostPtr = nullptr;
         cl_mem_flags flags = flag_set[src_flag_id];
         bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR);
         if (hasHostPtr) hostPtr = hostPtrData;
         memObject = clCreateBuffer(context, flags,  bufferSize, hostPtr, &error);
         test_error( error, "Unable to create testing buffer" );

         if (!hasHostPtr)
         {
             error =
             clEnqueueWriteBuffer(queue, memObject, CL_TRUE, 0, bufferSize,
                                  hostPtrData, 0, NULL, NULL);
             test_error( error, "clEnqueueWriteBuffer failed");
         }

         for( int i = 0; i < 128; i++ )
         {

           size_t offset = (size_t)random_in_range( 0, (int)bufferSize - 1, d );
           size_t length = (size_t)random_in_range( 1, (int)( bufferSize - offset ), d );

           cl_char *mappedRegion = (cl_char *)clEnqueueMapBuffer( queue, memObject, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE,
                                                                 offset, length, 0, NULL, NULL, &error );
           if( error != CL_SUCCESS )
           {
             print_error( error, "clEnqueueMapBuffer call failed" );
             log_error( "\tOffset: %d  Length: %d\n", (int)offset, (int)length );
             return -1;
           }

           // Write into the region
           for( size_t j = 0; j < length; j++ )
           {
             cl_char spin = (cl_char)genrand_int32( d );

             // Test read AND write in one swipe
             cl_char value = mappedRegion[ j ];
             value = spin - value;
             mappedRegion[ j ] = value;

             // Also update the initial data array
             value = referenceData[offset + j];
             value = spin - value;
             referenceData[offset + j] = value;
           }

           // Unmap
           error = clEnqueueUnmapMemObject( queue, memObject, mappedRegion, 0, NULL, NULL );
           test_error( error, "Unable to unmap buffer" );
         }

         // Final validation: read actual values of buffer and compare against our reference
         error = clEnqueueReadBuffer( queue, memObject, CL_TRUE, 0, bufferSize, finalData, 0, NULL, NULL );
         test_error( error, "Unable to read results" );

         for( size_t q = 0; q < bufferSize; q++ )
         {
             if (referenceData[q] != finalData[q])
             {
                 log_error(
                 "ERROR: Sample %d did not validate! Got %d, expected %d\n",
                 (int)q, (int)finalData[q], (int)referenceData[q]);
                 return -1;
             }
         }
     } // cl_mem flags

     return 0;
 }

 int test_enqueue_map_image(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
 {
     int error;
     cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT32 };
     const size_t imageSize = 256;
     const size_t imageDataSize = imageSize * imageSize * 4 * sizeof(cl_uint);

     PASSIVE_REQUIRE_IMAGE_SUPPORT( deviceID )

     BufferOwningPtr<cl_uint> hostPtrData{ malloc(imageDataSize) };
     BufferOwningPtr<cl_uint> referenceData{ malloc(imageDataSize) };
     BufferOwningPtr<cl_uint> finalData{malloc(imageDataSize)};

     MTdataHolder d{gRandomSeed};
   for (int src_flag_id=0; src_flag_id < ARRAY_SIZE(flag_set); src_flag_id++) {
     clMemWrapper memObject;
     log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]);

     generate_random_data(kUInt, (unsigned int)(imageSize * imageSize), d,
                          hostPtrData);
     memcpy(referenceData, hostPtrData, imageDataSize);

     cl_mem_flags flags = flag_set[src_flag_id];
     bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR);
     void *hostPtr = nullptr;
     if (hasHostPtr) hostPtr = hostPtrData;
     memObject = create_image_2d(context, CL_MEM_READ_WRITE | flags, &format,
                                 imageSize, imageSize, 0, hostPtr, &error );
     test_error( error, "Unable to create testing buffer" );

     if (!hasHostPtr) {
       size_t write_origin[3]={0,0,0}, write_region[3]={imageSize, imageSize, 1};
       error =
       clEnqueueWriteImage(queue, memObject, CL_TRUE, write_origin, write_region,
                           0, 0, hostPtrData, 0, NULL, NULL);
       test_error( error, "Unable to write to testing buffer" );
     }

     for( int i = 0; i < 128; i++ )
     {

       size_t offset[3], region[3];
       size_t rowPitch;

       offset[ 0 ] = (size_t)random_in_range( 0, (int)imageSize - 1, d );
       region[ 0 ] = (size_t)random_in_range( 1, (int)( imageSize - offset[ 0 ] - 1), d );
       offset[ 1 ] = (size_t)random_in_range( 0, (int)imageSize - 1, d );
       region[ 1 ] = (size_t)random_in_range( 1, (int)( imageSize - offset[ 1 ] - 1), d );
       offset[ 2 ] = 0;
       region[ 2 ] = 1;
       cl_uint *mappedRegion = (cl_uint *)clEnqueueMapImage( queue, memObject, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE,
                                                            offset, region, &rowPitch, NULL, 0, NULL, NULL, &error );
       if( error != CL_SUCCESS )
       {
         print_error( error, "clEnqueueMapImage call failed" );
         log_error( "\tOffset: %d,%d  Region: %d,%d\n", (int)offset[0], (int)offset[1], (int)region[0], (int)region[1] );
         return -1;
       }

       // Write into the region
       cl_uint *mappedPtr = mappedRegion;
       for( size_t y = 0; y < region[ 1 ]; y++ )
       {
         for( size_t x = 0; x < region[ 0 ] * 4; x++ )
         {
           cl_int spin = (cl_int)random_in_range( 16, 1024, d );

           cl_int value;
           // Test read AND write in one swipe
           value = mappedPtr[ ( y * rowPitch/sizeof(cl_uint) ) + x ];
           value = spin - value;
           mappedPtr[ ( y * rowPitch/sizeof(cl_uint) ) + x ] = value;

           // Also update the initial data array
           value =
           referenceData[((offset[1] + y) * imageSize + offset[0]) * 4 + x];
           value = spin - value;
           referenceData[((offset[1] + y) * imageSize + offset[0]) * 4 + x] =
           value;
         }
       }

       // Unmap
       error = clEnqueueUnmapMemObject( queue, memObject, mappedRegion, 0, NULL, NULL );
       test_error( error, "Unable to unmap buffer" );
     }

     // Final validation: read actual values of buffer and compare against our reference
     size_t finalOrigin[3] = { 0, 0, 0 }, finalRegion[3] = { imageSize, imageSize, 1 };
     error = clEnqueueReadImage( queue, memObject, CL_TRUE, finalOrigin, finalRegion, 0, 0, finalData, 0, NULL, NULL );
     test_error( error, "Unable to read results" );

     for( size_t q = 0; q < imageSize * imageSize * 4; q++ )
     {
         if (referenceData[q] != finalData[q])
         {
             log_error("ERROR: Sample %d (coord %d,%d) did not validate! Got "
                       "%d, expected %d\n",
                       (int)q, (int)((q / 4) % imageSize),
                       (int)((q / 4) / imageSize), (int)finalData[q],
                       (int)referenceData[q]);
             return -1;
         }
     }
   } // cl_mem_flags

     return 0;
 }
	//
	// 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
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//
	#include "harness/compat.h"

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/types.h>
	#include <sys/stat.h>


	#include "procs.h"
	#include "harness/conversions.h"
	#include "harness/typeWrappers.h"

	const cl_mem_flags flag_set[] = {
	CL_MEM_ALLOC_HOST_PTR,
	CL_MEM_ALLOC_HOST_PTR \| CL_MEM_COPY_HOST_PTR,
	CL_MEM_USE_HOST_PTR,
	CL_MEM_COPY_HOST_PTR,
	0
	};
	const char* flag_set_names[] = {
	"CL_MEM_ALLOC_HOST_PTR",
	"CL_MEM_ALLOC_HOST_PTR \| CL_MEM_COPY_HOST_PTR",
	"CL_MEM_USE_HOST_PTR",
	"CL_MEM_COPY_HOST_PTR",
	"0"
	};

	int test_enqueue_map_buffer(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
	{
	int error;
	const size_t bufferSize = 256*256;
	MTdataHolder d{gRandomSeed};
	BufferOwningPtr<cl_char> hostPtrData{ malloc(bufferSize) };
	BufferOwningPtr<cl_char> referenceData{ malloc(bufferSize) };
	BufferOwningPtr<cl_char> finalData{malloc(bufferSize)};

	for (int src_flag_id=0; src_flag_id < ARRAY_SIZE(flag_set); src_flag_id++)
	{
	clMemWrapper memObject;
	log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]);

	generate_random_data(kChar, (unsigned int)bufferSize, d, hostPtrData);
	memcpy(referenceData, hostPtrData, bufferSize);

	void *hostPtr = nullptr;
	cl_mem_flags flags = flag_set[src_flag_id];
	bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) \|\| (flags & CL_MEM_COPY_HOST_PTR);
	if (hasHostPtr) hostPtr = hostPtrData;
	memObject = clCreateBuffer(context, flags, bufferSize, hostPtr, &error);
	test_error( error, "Unable to create testing buffer" );

	if (!hasHostPtr)
	{
	error =
	clEnqueueWriteBuffer(queue, memObject, CL_TRUE, 0, bufferSize,
	hostPtrData, 0, NULL, NULL);
	test_error( error, "clEnqueueWriteBuffer failed");
	}

	for( int i = 0; i < 128; i++ )
	{

	size_t offset = (size_t)random_in_range( 0, (int)bufferSize - 1, d );
	size_t length = (size_t)random_in_range( 1, (int)( bufferSize - offset ), d );

	cl_char mappedRegion = (cl_char )clEnqueueMapBuffer( queue, memObject, CL_TRUE, CL_MAP_READ \| CL_MAP_WRITE,
	offset, length, 0, NULL, NULL, &error );
	if( error != CL_SUCCESS )
	{
	print_error( error, "clEnqueueMapBuffer call failed" );
	log_error( "\tOffset: %d Length: %d\n", (int)offset, (int)length );
	return -1;
	}

	// Write into the region
	for( size_t j = 0; j < length; j++ )
	{
	cl_char spin = (cl_char)genrand_int32( d );

	// Test read AND write in one swipe
	cl_char value = mappedRegion[ j ];
	value = spin - value;
	mappedRegion[ j ] = value;

	// Also update the initial data array
	value = referenceData[offset + j];
	value = spin - value;
	referenceData[offset + j] = value;
	}

	// Unmap
	error = clEnqueueUnmapMemObject( queue, memObject, mappedRegion, 0, NULL, NULL );
	test_error( error, "Unable to unmap buffer" );
	}

	// Final validation: read actual values of buffer and compare against our reference
	error = clEnqueueReadBuffer( queue, memObject, CL_TRUE, 0, bufferSize, finalData, 0, NULL, NULL );
	test_error( error, "Unable to read results" );

	for( size_t q = 0; q < bufferSize; q++ )
	{
	if (referenceData[q] != finalData[q])
	{
	log_error(
	"ERROR: Sample %d did not validate! Got %d, expected %d\n",
	(int)q, (int)finalData[q], (int)referenceData[q]);
	return -1;
	}
	}
	} // cl_mem flags

	return 0;
	}

	int test_enqueue_map_image(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
	{
	int error;
	cl_image_format format = { CL_RGBA, CL_UNSIGNED_INT32 };
	const size_t imageSize = 256;
	const size_t imageDataSize = imageSize * imageSize * 4 * sizeof(cl_uint);

	PASSIVE_REQUIRE_IMAGE_SUPPORT( deviceID )

	BufferOwningPtr<cl_uint> hostPtrData{ malloc(imageDataSize) };
	BufferOwningPtr<cl_uint> referenceData{ malloc(imageDataSize) };
	BufferOwningPtr<cl_uint> finalData{malloc(imageDataSize)};

	MTdataHolder d{gRandomSeed};
	for (int src_flag_id=0; src_flag_id < ARRAY_SIZE(flag_set); src_flag_id++) {
	clMemWrapper memObject;
	log_info("Testing with cl_mem_flags src: %s\n", flag_set_names[src_flag_id]);

	generate_random_data(kUInt, (unsigned int)(imageSize * imageSize), d,
	hostPtrData);
	memcpy(referenceData, hostPtrData, imageDataSize);

	cl_mem_flags flags = flag_set[src_flag_id];
	bool hasHostPtr = (flags & CL_MEM_USE_HOST_PTR) \|\| (flags & CL_MEM_COPY_HOST_PTR);
	void *hostPtr = nullptr;
	if (hasHostPtr) hostPtr = hostPtrData;
	memObject = create_image_2d(context, CL_MEM_READ_WRITE \| flags, &format,
	imageSize, imageSize, 0, hostPtr, &error );
	test_error( error, "Unable to create testing buffer" );

	if (!hasHostPtr) {
	size_t write_origin[3]={0,0,0}, write_region[3]={imageSize, imageSize, 1};
	error =
	clEnqueueWriteImage(queue, memObject, CL_TRUE, write_origin, write_region,
	0, 0, hostPtrData, 0, NULL, NULL);
	test_error( error, "Unable to write to testing buffer" );
	}

	for( int i = 0; i < 128; i++ )
	{

	size_t offset[3], region[3];
	size_t rowPitch;

	offset[ 0 ] = (size_t)random_in_range( 0, (int)imageSize - 1, d );
	region[ 0 ] = (size_t)random_in_range( 1, (int)( imageSize - offset[ 0 ] - 1), d );
	offset[ 1 ] = (size_t)random_in_range( 0, (int)imageSize - 1, d );
	region[ 1 ] = (size_t)random_in_range( 1, (int)( imageSize - offset[ 1 ] - 1), d );
	offset[ 2 ] = 0;
	region[ 2 ] = 1;
	cl_uint mappedRegion = (cl_uint )clEnqueueMapImage( queue, memObject, CL_TRUE, CL_MAP_READ \| CL_MAP_WRITE,
	offset, region, &rowPitch, NULL, 0, NULL, NULL, &error );
	if( error != CL_SUCCESS )
	{
	print_error( error, "clEnqueueMapImage call failed" );
	log_error( "\tOffset: %d,%d Region: %d,%d\n", (int)offset[0], (int)offset[1], (int)region[0], (int)region[1] );
	return -1;
	}

	// Write into the region
	cl_uint *mappedPtr = mappedRegion;
	for( size_t y = 0; y < region[ 1 ]; y++ )
	{
	for( size_t x = 0; x < region[ 0 ] * 4; x++ )
	{
	cl_int spin = (cl_int)random_in_range( 16, 1024, d );

	cl_int value;
	// Test read AND write in one swipe
	value = mappedPtr[ ( y * rowPitch/sizeof(cl_uint) ) + x ];
	value = spin - value;
	mappedPtr[ ( y * rowPitch/sizeof(cl_uint) ) + x ] = value;

	// Also update the initial data array
	value =
	referenceData[((offset[1] + y) * imageSize + offset[0]) * 4 + x];
	value = spin - value;
	referenceData[((offset[1] + y) * imageSize + offset[0]) * 4 + x] =
	value;
	}
	}

	// Unmap
	error = clEnqueueUnmapMemObject( queue, memObject, mappedRegion, 0, NULL, NULL );
	test_error( error, "Unable to unmap buffer" );
	}

	// Final validation: read actual values of buffer and compare against our reference
	size_t finalOrigin[3] = { 0, 0, 0 }, finalRegion[3] = { imageSize, imageSize, 1 };
	error = clEnqueueReadImage( queue, memObject, CL_TRUE, finalOrigin, finalRegion, 0, 0, finalData, 0, NULL, NULL );
	test_error( error, "Unable to read results" );

	for( size_t q = 0; q < imageSize * imageSize * 4; q++ )
	{
	if (referenceData[q] != finalData[q])
	{
	log_error("ERROR: Sample %d (coord %d,%d) did not validate! Got "
	"%d, expected %d\n",
	(int)q, (int)((q / 4) % imageSize),
	(int)((q / 4) / imageSize), (int)finalData[q],
	(int)referenceData[q]);
	return -1;
	}
	}
	} // cl_mem_flags

	return 0;
	}