text: //
  // 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 * 4), 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;
  }
  
  