Fixes from review

Author: Beanavil

samples/core/multi-device/main.c

@@ -163,6 +163,13 @@ void host_convolution(const cl_float* in, cl_float* out, const cl_float* mask,
     }
 }
 
+cl_int opencl_version_contains(const char* dev_version,
+                               const char* version_fragment)
+{
+    char* found_version = strstr(dev_version, version_fragment);
+    return (found_version != NULL);
+}
+
 int main(int argc, char* argv[])
 {
     cl_int error = CL_SUCCESS;
@@ -199,7 +206,13 @@ int main(int argc, char* argv[])
     OCLERROR_PAR(dev = cl_util_get_device(dev_opts.triplet.plat_index,
                                           dev_opts.triplet.dev_index,
                                           dev_opts.triplet.dev_type, &error),
-                 error, dev);
+                 error, end);
+
+    // Query OpenCL version supported by device.
+    char dev_version[64];
+    OCLERROR_RET(clGetDeviceInfo(dev, CL_DEVICE_VERSION, sizeof(dev_version),
+                                 &dev_version, NULL),
+                 error, end);
 
     if (!diag_opts.quiet)
     {
@@ -212,48 +225,88 @@ int main(int argc, char* argv[])
         fflush(stdout);
     }
 
-#if CL_HPP_TARGET_OPENCL_VERSION < 120
-    fprintf(stderr,
-            "Error: OpenCL subdevices not supported before version 1.2 ");
-    exit(EXIT_FAILURE);
-#endif
+    if (opencl_version_contains(dev_version, "1.0")
+        || opencl_version_contains(dev_version, "1.1"))
+    {
+        fprintf(stdout,
+                "This sample requires device partitioning, which is an OpenCL "
+                "1.2 feature, but the device chosen only supports OpenCL %s. "
+                "Please try with a different OpenCL device instead.\n",
+                dev_version);
+        exit(EXIT_SUCCESS);
+    }
+
+    // Check if device supports fission.
+    cl_device_partition_property* dev_props = NULL;
+    size_t props_size = 0;
+    OCLERROR_RET(clGetDeviceInfo(dev, CL_DEVICE_PARTITION_PROPERTIES, 0, NULL,
+                                 &props_size),
+                 error, end);
+    if (props_size == 0)
+    {
+        fprintf(stdout,
+                "This sample requires device fission, which is a "
+                "feature available from OpenCL 1.2 on, but the "
+                "device chosen does not seem to support it. Please "
+                "try with a different OpenCL device instead.\n");
+        exit(EXIT_SUCCESS);
+    }
+
+    // Check if the "partition equally" type is supported.
+    MEM_CHECK(dev_props = (cl_device_partition_property*)malloc(props_size),
+              error, end);
+    OCLERROR_RET(clGetDeviceInfo(dev, CL_DEVICE_PARTITION_PROPERTIES,
+                                 props_size, dev_props, NULL),
+                 error, props);
+    size_t prop = 0,
+           props_length = props_size / sizeof(cl_device_partition_property);
+    for (; prop < props_length; ++prop)
+    {
+        if (dev_props[prop] == CL_DEVICE_PARTITION_EQUALLY)
+        {
+            break;
+        }
+    }
+    if (prop == props_length)
+    {
+        fprintf(stdout,
+                "This sample requires partition equally, which is a "
+                "partition scheme available from OpenCL 1.2 on, but "
+                "the device chosen does not seem to support it. "
+                "Please try with a different OpenCL device instead.\n");
+        exit(EXIT_SUCCESS);
+    }
 
-    // Create subdevices, each with half of the compute units available.
+    // Create sub-devices, each with half of the compute units available.
     cl_uint max_compute_units = 0;
+    cl_uint subdev_created = 0;
+    const cl_uint subdev_count = 2;
     OCLERROR_RET(clGetDeviceInfo(dev, CL_DEVICE_MAX_COMPUTE_UNITS,
                                  sizeof(cl_uint), &max_compute_units, NULL),
-                 error, dev);
+                 error, props);
     cl_device_partition_property subdevices_properties[] = {
         (cl_device_partition_property)CL_DEVICE_PARTITION_EQUALLY,
-        (cl_device_partition_property)(max_compute_units / 2), 0
+        (cl_device_partition_property)(max_compute_units / subdev_count), 0
     };
 
-    // Initialize subdevices array with one device and then reallocate for
-    // MacOS and Windows not to complain about NULL subdevices array.
-    cl_uint subdev_count = 1;
     cl_device_id* subdevices =
         (cl_device_id*)malloc(subdev_count * sizeof(cl_device_id));
 
-    OCLERROR_RET(clCreateSubDevices(dev, subdevices_properties,
-                                    max_compute_units, subdevices,
-                                    &subdev_count),
-                 error, dev);
+    OCLERROR_RET(clCreateSubDevices(dev, subdevices_properties, subdev_count,
+                                    subdevices, &subdev_created),
+                 error, props);
 
-    if (subdev_count < 2)
+    if (subdev_created < subdev_count)
     {
-        fprintf(stderr, "Error: OpenCL cannot create subdevices");
+        fprintf(stderr,
+                "Error: OpenCL cannot create the number of sub-devices "
+                "requested\n");
         exit(EXIT_FAILURE);
     }
 
-    subdevices =
-        (cl_device_id*)realloc(subdevices, subdev_count * sizeof(cl_device_id));
-    OCLERROR_RET(clCreateSubDevices(dev, subdevices_properties, subdev_count,
-                                    subdevices, NULL),
-                 error, subdevs);
-
     OCLERROR_PAR(context = clCreateContext(NULL, subdev_count, subdevices, NULL,
                                            NULL, &error),
-                 error, subdevs);
+                 error, subdev1);
 
     // Read kernel file.
     const char* kernel_location = "./convolution.cl";
@@ -280,11 +333,14 @@ int main(int argc, char* argv[])
     // it's only necessary to add the -cl-std option for 2.0 and 3.0 OpenCL
     // versions.
     char compiler_options[1023] = "";
-#if CL_HPP_TARGET_OPENCL_VERSION >= 300
-    strcat(compiler_options, "-cl-std=CL3.0 ");
-#elif CL_HPP_TARGET_OPENCL_VERSION >= 200
-    strcat(compiler_options, "-cl-std=CL2.0 ");
-#endif
+    if (opencl_version_contains(dev_version, "3."))
+    {
+        strcat(compiler_options, "-cl-std=CL3.0 ");
+    }
+    else if (opencl_version_contains(dev_version, "2."))
+    {
+        strcat(compiler_options, "-cl-std=CL2.0 ");
+    }
 
     OCLERROR_RET(
         clBuildProgram(program, 2, subdevices, compiler_options, NULL, NULL),
@@ -356,7 +412,7 @@ int main(int argc, char* argv[])
                                        mask_dim * mask_dim, -1000, 1000);
 
     // Create device buffers, from which we will create the subbuffers for the
-    // subdevices.
+    // sub-devices.
     const size_t grid_midpoint = y_dim / 2;
     const size_t pad_grid_midpoint = pad_y_dim / 2;
 
@@ -391,7 +447,7 @@ int main(int argc, char* argv[])
         fflush(stdout);
     }
 
-    // Set up subdevices for kernel execution.
+    // Set up sub-devices for kernel execution.
     const size_t half_input_bytes =
         sizeof(cl_float) * pad_x_dim * (pad_grid_midpoint + 1);
     const size_t input_offset =
@@ -414,7 +470,7 @@ int main(int argc, char* argv[])
                      error, bufmask);
 
         // Initialize queues for command execution on each device.
-#if CL_HPP_TARGET_OPENCL_VERSION >= 200
+#if defined(CL_VERSION_2_0) || defined(CL_VERSION_3_0)
         cl_command_queue_properties props[] = { CL_QUEUE_PROPERTIES,
                                                 CL_QUEUE_PROFILING_ENABLE, 0 };
         OCLERROR_PAR(sub_queues[subdevice] = clCreateCommandQueueWithProperties(
@@ -507,7 +563,8 @@ int main(int argc, char* argv[])
     }
 
     GET_CURRENT_TIMER(host_start)
-    host_convolution(h_input_grid, h_output_grid, h_mask, (cl_uint)x_dim, (cl_uint)y_dim);
+    host_convolution(h_input_grid, h_output_grid, h_mask, (cl_uint)x_dim,
+                     (cl_uint)y_dim);
     GET_CURRENT_TIMER(host_end)
     size_t host_time;
     TIMER_DIFFERENCE(host_time, host_start, host_end)
@@ -588,31 +645,31 @@ int main(int argc, char* argv[])
 event1:
     OCLERROR_RET(clReleaseEvent(events[0]), end_error, subbufout);
 subbufout:
-    if (subdevice == 1)
+    if (subdevice >= 1)
     {
         OCLERROR_RET(clReleaseMemObject(sub_output_grids[1]), end_error,
                      subbufout0);
     }
 subbufout0:
     OCLERROR_PAR(clReleaseMemObject(sub_output_grids[0]), end_error, subbufin);
 subbufin:
-    if (subdevice == 1)
+    if (subdevice >= 1)
     {
         OCLERROR_RET(clReleaseMemObject(sub_input_grids[1]), end_error,
                      subbufin0);
     }
 subbufin0:
     OCLERROR_RET(clReleaseMemObject(sub_input_grids[0]), end_error, subqueue);
 subqueue:
-    if (subdevice == 1)
+    if (subdevice >= 1)
     {
         OCLERROR_RET(clReleaseCommandQueue(sub_queues[1]), end_error,
                      subqueue0);
     }
 subqueue0:
-    OCLERROR_RET(clReleaseCommandQueue(sub_queues[1]), end_error, conv);
+    OCLERROR_RET(clReleaseCommandQueue(sub_queues[0]), end_error, conv);
 conv:
-    if (subdevice == 1)
+    if (subdevice >= 1)
     {
         OCLERROR_RET(clReleaseKernel(convolutions[1]), end_error, conv0);
     }
@@ -631,15 +688,19 @@ int main(int argc, char* argv[])
 hinput:
     free(h_input_grid);
 prg:
-    OCLERROR_RET(clReleaseProgram(program), end_error, subdevs);
+    OCLERROR_RET(clReleaseProgram(program), end_error, ker);
 ker:
     free(kernel);
 contx:
-    OCLERROR_RET(clReleaseContext(context), end_error, end);
+    OCLERROR_RET(clReleaseContext(context), end_error, subdev1);
+subdev1:
+    OCLERROR_RET(clReleaseDevice(subdevices[1]), end_error, subdev0);
+subdev0:
+    OCLERROR_RET(clReleaseDevice(subdevices[0]), end_error, subdevs);
 subdevs:
     free(subdevices);
-dev:
-    OCLERROR_RET(clReleaseDevice(dev), end_error, end);
+props:
+    free(dev_props);
 end:
     if (error) cl_util_print_error(error);
     return error;

samples/core/multi-device/main.cpp

@@ -97,6 +97,12 @@ void host_convolution(const std::vector<cl_float> in,
     }
 }
 
+bool opencl_version_contains(const cl::string& dev_version,
+                             const cl::string& version_fragment)
+{
+    return dev_version.find(version_fragment) != cl::string::npos;
+}
+
 int main(int argc, char* argv[])
 {
     try
@@ -118,6 +124,9 @@ int main(int argc, char* argv[])
             dev.getInfo<CL_DEVICE_PLATFORM>()
         }; // https://github.com/KhronosGroup/OpenCL-CLHPP/issues/150
 
+        // Query OpenCL version supported by device.
+        const std::string dev_version = dev.getInfo<CL_DEVICE_VERSION>();
+
         if (!diag_opts.quiet)
         {
             std::cout << "Selected device: " << dev.getInfo<CL_DEVICE_NAME>()
@@ -133,12 +142,44 @@ int main(int argc, char* argv[])
             std::cout.flush();
         }
 
-#if CL_HPP_TARGET_OPENCL_VERSION < 120
-        std::cerr
-            << "Error: OpenCL subdevices not supported before version 1.2 "
-            << std::endl;
-        exit(EXIT_FAILURE);
-#endif
+        if (opencl_version_contains(dev_version, "1.0")
+            || opencl_version_contains(dev_version, "1.1"))
+        {
+            std::cout
+                << "This sample requires device partitioning, which is an "
+                   "OpenCL 1.2 feature, but the device chosen only "
+                   "supports OpenCL "
+                << dev_version
+                << ". Please try with a different OpenCL device instead."
+                << std::endl;
+            exit(EXIT_SUCCESS);
+        }
+
+        // Check if device supports fission.
+        std::vector<cl_device_partition_property> dev_props =
+            dev.getInfo<CL_DEVICE_PARTITION_PROPERTIES>();
+        if (dev_props.size() == 0)
+        {
+            std::cout << "This sample requires device fission, which is a "
+                         "feature available from OpenCL 1.2 on, but the "
+                         "device chosen does not seem to support it. Please "
+                         "try with a different OpenCL device instead."
+                      << std::endl;
+            exit(EXIT_SUCCESS);
+        }
+
+        // Check if the "partition equally" type is supported.
+        if (std::find(dev_props.begin(), dev_props.end(),
+                      CL_DEVICE_PARTITION_EQUALLY)
+            == dev_props.end())
+        {
+            std::cout << "This sample requires partition equally, which is a "
+                         "partition scheme available from OpenCL 1.2 on, but "
+                         "the device chosen does not seem to support it. "
+                         "Please try with a different OpenCL device instead."
+                      << std::endl;
+            exit(EXIT_SUCCESS);
+        }
 
         // Create subdevices, each with half of the compute units available.
         cl_uint max_compute_units = dev.getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>();
@@ -189,10 +230,10 @@ int main(int argc, char* argv[])
             std::string compiler_opt_str =
                 "-cl-std=CL" + std::to_string(i) + ".0 "; // -cl-std=CLi.0
 
-            compiler_options += cl::string{ cl::util::opencl_c_version_contains(
-                                                dev, version_str)
-                                                ? compiler_opt_str
-                                                : "" };
+            compiler_options +=
+                cl::string{ opencl_version_contains(dev_version, version_str)
+                                ? compiler_opt_str
+                                : "" };
         }
         program.build(subdevices, compiler_options.c_str());
 
@@ -316,10 +357,7 @@ int main(int argc, char* argv[])
                 std::cout.flush();
             }
 
-            auto convolution =
-                cl::KernelFunctor<cl::Buffer, cl::Buffer, cl::Buffer, cl_uint2>(
-                    program, "convolution_3x3")
-                    .getKernel();
+            auto convolution = cl::Kernel(program, "convolution_3x3");
 
             cl::CommandQueue queue(context, subdevice,
                                    cl::QueueProperties::Profiling);
@@ -362,7 +400,7 @@ int main(int argc, char* argv[])
                 std::cout.flush();
             }
 
-            convolutions.push_back(convolution.clone());
+            convolutions.push_back(convolution);
             sub_queues.push_back(queue);
             sub_input_grids.push_back(sub_input_grid);
             sub_output_grids.push_back(sub_output_grid);