| // |
| // 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. |
| // |
| #ifndef test_conformance_checker_Image_MEM_HOST_READ_ONLY_h |
| #define test_conformance_checker_Image_MEM_HOST_READ_ONLY_h |
| |
| #include "checker.h" |
| |
| template < class T> class cImage_check_mem_host_read_only : public cBuffer_checker<T> |
| { |
| public: |
| cImage_check_mem_host_read_only(cl_device_id deviceID, cl_context context, cl_command_queue queue) |
| : cBuffer_checker <T> (deviceID, context, queue) |
| { |
| m_cl_image_format.image_channel_order = CL_RGBA; |
| m_cl_image_format.image_channel_data_type = CL_UNSIGNED_INT8; |
| |
| m_cl_Image_desc.image_type = CL_MEM_OBJECT_IMAGE1D; |
| m_cl_Image_desc.image_width = 0; |
| m_cl_Image_desc.image_height = 0; |
| m_cl_Image_desc.image_depth = 0; |
| m_cl_Image_desc.image_array_size = 0; |
| m_cl_Image_desc.image_row_pitch = 0; |
| m_cl_Image_desc.image_slice_pitch = 0; |
| m_cl_Image_desc.num_mip_levels = 0; |
| m_cl_Image_desc.num_samples = 0; |
| m_cl_Image_desc.mem_object = NULL; |
| |
| m_Image = NULL; |
| }; |
| |
| ~cImage_check_mem_host_read_only() |
| { |
| }; |
| |
| cl_int get_image_elements(); |
| |
| cl_image_format m_cl_image_format; |
| cl_image_desc m_cl_Image_desc; |
| clMemWrapper m_Image; |
| |
| virtual cl_int SetupImage(); |
| virtual cl_int SetupBuffer(); |
| virtual cl_int verify_RW_Image(); |
| |
| virtual cl_int verify_RW_Image_Mapping(); |
| virtual cl_int verify_data(T *pdtaIn); |
| virtual cl_int verify_data_with_offset(T *pdtaIn, size_t *offset); |
| |
| cl_int get_image_content_size(); |
| cl_int get_image_data_size(); |
| |
| virtual cl_int verify_RW_Buffer(); |
| virtual cl_int verify_RW_Buffer_rect(); |
| virtual cl_int verify_RW_Buffer_mapping(); |
| cl_int verify_mapping_ptr(T *ptr); |
| }; |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_mapping_ptr( T* dataPtr) |
| { |
| int offset_pixel = (int)(this->buffer_origin[0] + this->buffer_origin[1] * |
| this->buffer_row_pitch_bytes/ sizeof(T) + this->buffer_origin[2] * |
| this->buffer_slice_pitch_bytes/sizeof(T)); |
| |
| dataPtr = dataPtr - offset_pixel; |
| |
| cl_int err = CL_SUCCESS; |
| |
| if (this->buffer_mem_flag & CL_MEM_USE_HOST_PTR) |
| { |
| if (this->pHost_ptr != this->host_m_1.pData) |
| { |
| log_error("Host memory pointer difference found\n"); |
| return FAILURE; |
| } |
| |
| if(dataPtr != this->host_m_1.pData) |
| { |
| log_error("Mapped host pointer difference found\n"); |
| return FAILURE; |
| } |
| } |
| |
| return err; |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_RW_Buffer() { return CL_SUCCESS; }; |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_RW_Buffer_rect() { return CL_SUCCESS; }; |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_RW_Buffer_mapping() { return CL_SUCCESS; }; |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::SetupBuffer() |
| { |
| return cBuffer_checker< T >::SetupBuffer(); |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::get_image_content_size() |
| { |
| return ((cl_int)(m_cl_Image_desc.image_width*m_cl_Image_desc.image_height * |
| m_cl_Image_desc.image_depth * m_cl_Image_desc.image_array_size)); |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::get_image_data_size() |
| { |
| size_t slice_pitch = m_cl_Image_desc.image_slice_pitch ? m_cl_Image_desc.image_slice_pitch : |
| (m_cl_Image_desc.image_height * m_cl_Image_desc.image_width); |
| return (slice_pitch * m_cl_Image_desc.image_depth * m_cl_Image_desc.image_array_size); |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::get_image_elements() |
| { |
| return ((cl_int)(m_cl_Image_desc.image_width*m_cl_Image_desc.image_height * |
| m_cl_Image_desc.image_depth * m_cl_Image_desc.image_array_size)); |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::SetupImage() |
| { |
| int all = (int)(m_cl_Image_desc.image_width * m_cl_Image_desc.image_height * |
| m_cl_Image_desc.image_depth * m_cl_Image_desc.image_array_size); |
| |
| T v = TEST_VALUE; |
| this->host_m_1.Init(all, v); |
| |
| cl_int err = CL_SUCCESS; |
| this-> m_Image = clCreateImage(this->m_context, this->buffer_mem_flag, |
| &( this-> m_cl_image_format), &(this-> m_cl_Image_desc), |
| this->host_m_1.pData, &err); |
| test_error(err , "clCreateImage error"); |
| |
| this-> pHost_ptr = (void *) (this->host_m_1.pData); |
| |
| return err; |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_data(T *pDataIN) |
| { |
| cl_int err = CL_SUCCESS; |
| if (!this->host_m_1.Equal_rect_from_orig(pDataIN, this->buffer_origin, |
| this->region, this->host_row_pitch, |
| this->host_slice_pitch)) { |
| log_error("Buffer data difference found\n"); |
| return FAILURE; |
| } |
| |
| return err; |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_data_with_offset(T *pDataIN, |
| size_t *offset) |
| { |
| cl_int err = CL_SUCCESS; |
| if (!this->host_m_2.Equal_rect_from_orig(pDataIN, offset, this->region, |
| this->host_row_pitch, |
| this->host_slice_pitch)) { |
| log_error("Buffer data difference found\n"); |
| return FAILURE; |
| } |
| |
| return err; |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_RW_Image() |
| { |
| this->Init_rect(); |
| |
| int imge_content_size = this->get_image_content_size(); |
| T v = 0; |
| this->host_m_2.Init( imge_content_size, v); |
| |
| cl_event event; |
| cl_int err = CL_SUCCESS; |
| err = clEnqueueReadImage(this->m_queue, this->m_Image, this->m_blocking, |
| this->buffer_origin, this->region, |
| this-> buffer_row_pitch_bytes, this->buffer_slice_pitch_bytes, |
| this->host_m_2.pData, 0, NULL, &event); |
| |
| test_error(err, "clEnqueueReadImage error"); |
| |
| if ( !this->m_blocking) { |
| err = clWaitForEvents(1, &event); |
| test_error(err, "clWaitForEvents error"); |
| } |
| |
| err = clReleaseEvent(event); |
| test_error(err, "clReleaseEvent error"); |
| |
| err = this->verify_data(this->host_m_2.pData); |
| test_error(err, "verify_data error"); |
| |
| err = clEnqueueWriteImage(this->m_queue, this->m_Image, this->m_blocking, |
| this->buffer_origin, this->region, |
| this->buffer_row_pitch_bytes, this->buffer_slice_pitch_bytes, |
| this->host_m_2.pData, 0, NULL, &event); |
| |
| if (err == CL_SUCCESS) { |
| log_error("Calling clEnqueueWriteImage on a memory object created with the CL_MEM_HOST_READ_ONLY flag should not return CL_SUCCESS\n"); |
| err = FAILURE; |
| return FAILURE; |
| |
| } else { |
| log_info("Test succeeded\n\n"); |
| err = CL_SUCCESS; |
| } |
| |
| return err; |
| } |
| |
| template < class T > |
| cl_int cImage_check_mem_host_read_only< T >::verify_RW_Image_Mapping() |
| { |
| cl_event event; |
| cl_int err = CL_SUCCESS; |
| |
| T * dataPtr = (T*) clEnqueueMapImage(this->m_queue, this->m_Image, this->m_blocking, |
| CL_MAP_READ, |
| this->buffer_origin, this->region, |
| &(this-> buffer_row_pitch_bytes), |
| &(this->buffer_slice_pitch_bytes), |
| 0, NULL, &event, &err); |
| |
| if (!this->m_blocking) { |
| err = clWaitForEvents(1, &event); |
| test_error(err, "clWaitForEvents error"); |
| } |
| |
| err = clReleaseEvent(event); |
| test_error(err, "clReleaseEvent error"); |
| |
| err= this->verify_mapping_ptr(dataPtr); |
| test_error(err, "clEnqueueMapImage error"); |
| |
| err = this->verify_data(dataPtr); |
| test_error(err, "verify_data error"); |
| |
| err= clEnqueueUnmapMemObject (this->m_queue, this->m_Image, dataPtr, 0, NULL, &event); |
| test_error(err, "clEnqueueUnmapMemObject error"); |
| |
| err = clWaitForEvents(1, &event); |
| test_error(err, "clWaitForEvents error"); |
| |
| err = clReleaseEvent(event); |
| test_error(err, "clReleaseEvent error"); |
| |
| dataPtr = (T*) clEnqueueMapImage(this->m_queue, this->m_Image, this->m_blocking, |
| CL_MAP_WRITE, |
| this->buffer_origin, |
| this->region, |
| &(this-> buffer_row_pitch_bytes), |
| &(this->buffer_slice_pitch_bytes), |
| 0, NULL, &event, &err); |
| |
| if (err == CL_SUCCESS) { |
| log_error("Calling clEnqueueMapImage (CL_MAP_WRITE) on a memory object created with the CL_MEM_HOST_READ_ONLY flag should not return CL_SUCCESS\n"); |
| err = FAILURE; |
| return FAILURE; |
| |
| } else { |
| log_info("Test succeeded\n\n"); |
| err = CL_SUCCESS; |
| } |
| |
| return err; |
| } |
| |
| #endif |