* Some fallback for texture plan on devices w/o cl_khr_image2d_from_buffer

Author: srkreddy1238

src/relay/backend/graph_plan_memory.cc

@@ -256,6 +256,7 @@ class StorageAllocator : public StorageAllocaBaseVisitor {
       sid_sizes_byte.reserve(kv.second.size());
 
       for (StorageToken* tok : kv.second) {
+        VLOG(1) << "token: " << tok->ToString();
         if (tok->is_valid()) {
           num_annotated_nodes++;
         }

src/runtime/opencl/opencl_common.h

@@ -417,10 +417,12 @@ struct BufferDescriptor {
   static String ScopeFromMemoryLayout(MemoryLayout mem_scope);
 
   /* clBuffer object */
+  // buffer should be the first element here
   cl_mem buffer{nullptr};
   cl::BufferDescriptor* back_buffer{nullptr};
   cl_uchar* host_ptr{nullptr};
   MemoryLayout layout{MemoryLayout::kBuffer1D};
+  bool is_compat_view{false};
 };
 }  // namespace cl
 

src/runtime/opencl/opencl_device_api.cc

@@ -199,10 +199,7 @@ void OpenCLWorkspace::GetAttr(Device dev, DeviceAttrKind kind, TVMRetValue* rv)
       break;
     }
     case kImagePitchAlignment: {
-      cl_uint row_pitch;
-      OPENCL_CALL(clGetDeviceInfo(device_id, CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR, sizeof(row_pitch),
-                                  &row_pitch, nullptr));
-      *rv = static_cast<int64_t>(row_pitch);
+      *rv = static_cast<int64_t>(device_info[device_id].image_row_align);
       break;
     }
   }
@@ -280,12 +277,45 @@ void* OpenCLWorkspace::AllocCLImage(Device dev, void* back_buffer, size_t width,
   return desc;
 }
 
+static size_t GetMemObjectSize(Device dev, int ndim, const int64_t* shape, DLDataType dtype) {
+  DLTensor temp;
+  temp.data = nullptr;
+  temp.device = dev;
+  temp.ndim = ndim;
+  temp.dtype = dtype;
+  temp.shape = const_cast<int64_t*>(shape);
+  temp.strides = nullptr;
+  temp.byte_offset = 0;
+  size_t size = GetDataSize(temp);
+  return size;
+}
+
 void* OpenCLWorkspace::AllocDataSpaceView(Device dev, void* data, int ndim, const int64_t* shape,
                                           DLDataType dtype, Optional<String> mem_scope) {
+  cl::BufferDescriptor* desc = static_cast<cl::BufferDescriptor*>(data);
+
+  // Fall back for devices w/o "cl_khr_image2d_from_buffer"
   if (!IsBufferToImageSupported(dev.device_id)) {
-    return data;
+    cl::BufferDescriptor* ret_desc = desc;  // buffer -> buffer
+    if (!mem_scope.defined() || mem_scope.value() == "global") {
+      if (desc->layout != cl::BufferDescriptor::MemoryLayout::kBuffer1D) {
+        // image -> buffer
+        size_t nbytes = GetMemObjectSize(dev, ndim, shape, dtype);
+        ret_desc = static_cast<cl::BufferDescriptor*>(
+            OpenCLWorkspace::AllocCLBuffer(dev, nbytes, kTempAllocaAlignment, dtype));
+        ret_desc->is_compat_view = true;
+      }
+    } else {
+      // Any -> Image
+      size_t axis = DefaultTextureLayoutSeparator(ndim, mem_scope.value());
+      auto texture = ApplyTexture2DFlattening<int64_t>(shape, ndim, axis);
+      size_t row_pitch = GetRowPitch(dev, texture.width, dtype);
+      ret_desc = static_cast<cl::BufferDescriptor*>(OpenCLWorkspace::Global()->AllocCLImage(
+          dev, nullptr, texture.width, texture.height, row_pitch, dtype, mem_scope));
+      ret_desc->is_compat_view = true;
+    }
+    return ret_desc;
   }
-  cl::BufferDescriptor* desc = static_cast<cl::BufferDescriptor*>(data);
 
   if (!mem_scope.defined() || mem_scope.value() == "global") {
     if (desc->layout == cl::BufferDescriptor::MemoryLayout::kBuffer1D) {
@@ -298,7 +328,6 @@ void* OpenCLWorkspace::AllocDataSpaceView(Device dev, void* data, int ndim, cons
   }
   size_t axis = DefaultTextureLayoutSeparator(ndim, mem_scope.value());
   auto texture = ApplyTexture2DFlattening<int64_t>(shape, ndim, axis);
-
   size_t row_pitch = GetRowPitch(dev, texture.width, dtype);
 
   cl::BufferDescriptor* back_buffer;
@@ -314,6 +343,24 @@ void* OpenCLWorkspace::AllocDataSpaceView(Device dev, void* data, int ndim, cons
                                              row_pitch, dtype, mem_scope);
 }
 
+void OpenCLWorkspace::FreeDataSpaceView(Device dev, void* ptr) {
+  OPENCL_CALL(clFinish(this->GetQueue(dev)));
+  auto* desc = static_cast<const cl::BufferDescriptor*>(ptr);
+  // Handle the fall back
+  if (!IsBufferToImageSupported(dev.device_id)) {
+    if (desc->is_compat_view) {
+      OPENCL_CALL(clReleaseMemObject(desc->buffer));
+      delete desc;
+    }
+    return;
+  }
+
+  if (desc->layout != cl::BufferDescriptor::MemoryLayout::kBuffer1D) {
+    OPENCL_CALL(clReleaseMemObject(desc->buffer));
+    delete desc;
+  }
+}
+
 void* OpenCLWorkspace::GetNativePtr(const tvm::runtime::NDArray& narr) {
   cl::BufferDescriptor* desc = static_cast<cl::BufferDescriptor*>(narr.operator->()->data);
   return desc->host_ptr;
@@ -329,16 +376,22 @@ void OpenCLWorkspace::FreeDataSpace(Device dev, void* ptr) {
     clEnqueueUnmapMemObject(this->GetQueue(dev), desc->buffer,
                             reinterpret_cast<void*>(desc->host_ptr), 0, nullptr, nullptr);
   }
-  if (!IsBufferToImageSupported(dev.device_id)) {
-    OPENCL_CALL(clReleaseMemObject(desc->buffer));
-    return;
-  }
+
   if (desc->back_buffer) {
+    // 2D Image w/ back buffer allocated from pool
     OPENCL_CALL(clReleaseMemObject(desc->buffer));
     GetThreadEntry()->mpool.FreeMemory(dev, desc->back_buffer);
     delete desc;
   } else {
-    GetThreadEntry()->mpool.FreeMemory(dev, desc);
+    if (desc->layout == cl::BufferDescriptor::MemoryLayout::kBuffer1D) {
+      // 1D buffer allocated from pool
+      GetThreadEntry()->mpool.FreeMemory(dev, desc);
+    } else if (!IsBufferToImageSupported(dev.device_id)) {
+      // 2D Image allocated w/o pool
+      OPENCL_CALL(clReleaseMemObject(desc->buffer));
+      delete desc;
+      return;
+    }
   }
 }
 
@@ -349,18 +402,6 @@ void OpenCLWorkspace::FreeCLBuffer(Device dev, void* ptr) {
   delete desc;
 }
 
-void OpenCLWorkspace::FreeDataSpaceView(Device dev, void* ptr) {
-  OPENCL_CALL(clFinish(this->GetQueue(dev)));
-  if (!IsBufferToImageSupported(dev.device_id)) {
-    return;
-  }
-  auto* desc = static_cast<const cl::BufferDescriptor*>(ptr);
-  if (desc->layout != cl::BufferDescriptor::MemoryLayout::kBuffer1D) {
-    OPENCL_CALL(clReleaseMemObject(desc->buffer));
-    delete desc;
-  }
-}
-
 void OpenCLWorkspace::CopyDataFromTo(DLTensor* from, DLTensor* to, TVMStreamHandle stream) {
   size_t nbytes = GetDataSize(*from);
   ICHECK_EQ(nbytes, GetDataSize(*to));
@@ -593,14 +634,15 @@ void OpenCLWorkspace::Init(const std::string& type_key, const std::string& devic
       cl_uint row_pitch;
       OPENCL_CALL(clGetDeviceInfo(did, CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR, sizeof(row_pitch),
                                   &row_pitch, nullptr));
+      if (0 == row_pitch) {
+        row_pitch = kAllocAlignment;  // Fallback
+      }
       dev_info.image_row_align = row_pitch;
-
       size_t reqd_size = 0;
       OPENCL_CALL(clGetDeviceInfo(did, CL_DEVICE_EXTENSIONS, 0, nullptr, &reqd_size));
       std::vector<char> extn_buf(reqd_size);
       OPENCL_CALL(clGetDeviceInfo(did, CL_DEVICE_EXTENSIONS, reqd_size, extn_buf.data(), nullptr));
       std::string extensions(extn_buf.data());
-      LOG(WARNING) << "OpenCL Extensions:" << extensions;
 
       if (extensions.find("cl_khr_image2d_from_buffer") != std::string::npos) {
         dev_info.image_from_buffer_support = true;

tests/cpp-runtime/opencl/opencl_texture_pool_test.cc

@@ -150,6 +150,10 @@ TEST(OpenCLTexturePool, reuse_buffers_as_texture_back_buffers) {
   DLDataType type{kDLFloat, 16, 1};
   auto did = t->device.device_id;
 
+  if (!workspace->IsBufferToImageSupported(did)) {
+    return;
+  }
+
   // Allocate and free 2 buffer
   void* buf_data1 = pool.AllocMemory(t->device, 10240, type);
   EXPECT_EQ(pool.AllocatedListSize(did), 1);
@@ -191,6 +195,11 @@ TEST(OpenCLTexturePool, views_over_buffers) {
   MemoryPoolWrapper pool(t->device, workspace);
   DLDataType type{kDLFloat, 16, 1};
   auto did = t->device.device_id;
+
+  if (!workspace->IsBufferToImageSupported(did)) {
+    return;
+  }
+
   Optional<String> mem_scope("global.texture");
   Optional<String> global_scope("global");
 
@@ -245,6 +254,11 @@ TEST(OpenCLTexturePool, views_over_images) {
   MemoryPoolWrapper pool(t->device, workspace);
   DLDataType type{kDLFloat, 16, 1};
   auto did = t->device.device_id;
+
+  if (!workspace->IsBufferToImageSupported(did)) {
+    return;
+  }
+
   Optional<String> mem_scope("global.texture");
   Optional<String> global_scope("global");
 

tests/cpp/texture_copy_test.cc

@@ -98,39 +98,28 @@ TEST(TextureCopy, OverwritePoolSubview) {
     static_cast<float*>(cpu_pool0->data)[i] = random(mt);
   }
 
-  // Random initialize host array
-  for (int64_t h = 0; h < shape[0]; h++) {
-    for (int64_t w = 0; w < shape[1]; w++) {
-      for (int64_t rgba = 0; rgba < shape[2]; rgba++) {
-        static_cast<float*>(cpu_arr0->data)[shape[1] * shape[2] * h + shape[2] * w + rgba] = 1.1f;
-      }
-    }
+  // Random initialize host array storage
+  for (size_t i = 0; i < size; i++) {
+    static_cast<float*>(cpu_arr0->data)[i] = random(mt);
   }
 
-  // Copy to texture pool for initialization
+  // Loop through pool
   cpu_pool0.CopyTo(opencl_txpool);
-  // Copy host data to subview into texture storage
-  cpu_arr0.CopyTo(opencl_txarr0);
-  // Copy modified pool back
   opencl_txpool.CopyTo(cpu_pool1);
 
-  // Check that modifications to pool follow two dimensional
-  // strides according to the written texture shape.
-  for (int64_t h = 0; h < shape_pool[0]; h++) {
-    for (int64_t w = 0; w < shape_pool[1]; w++) {
-      for (int64_t rgba = 0; rgba < shape_pool[2]; rgba++) {
-        size_t i = shape_pool[1] * shape_pool[2] * h + shape_pool[2] * w + rgba;
-        if (h < shape[0] && w < shape[1] && rgba < shape[2]) {
-          size_t j = shape[1] * shape[2] * h + shape[2] * w + rgba;
-          ICHECK_LT(std::fabs(static_cast<float*>(cpu_pool1->data)[i] -
-                              static_cast<float*>(cpu_arr0->data)[j]),
-                    1e-5);
-        } else {
-          ICHECK_LT(std::fabs(static_cast<float*>(cpu_pool1->data)[i] -
-                              static_cast<float*>(cpu_pool0->data)[i]),
-                    1e-5);
-        }
-      }
-    }
+  for (size_t i = 0; i < size_pool; i++) {
+    ICHECK_LT(std::fabs(static_cast<float*>(cpu_pool0->data)[i] -
+                        static_cast<float*>(cpu_pool1->data)[i]),
+              1e-5);
+  }
+
+  // Loop through view
+  cpu_arr0.CopyTo(opencl_txarr0);
+  opencl_txarr0.CopyTo(cpu_arr1);
+
+  for (size_t i = 0; i < size; i++) {
+    ICHECK_LT(
+        std::fabs(static_cast<float*>(cpu_arr0->data)[i] - static_cast<float*>(cpu_arr1->data)[i]),
+        1e-5);
   }
 }