Add C++ variant for binaries sample (#65)

* Add C++ variant for binaries sample

* file utils were expanded to support reading and writing binaries

* Update samples/core/binaries/main.cpp

Include climits to enable Linux build.

Co-authored-by: Ben Ashbaugh <ben.ashbaugh@intel.com>

* Improved error handling for file utils.

* Improved error reporting for binary file reading.

---------

Co-authored-by: Ben Ashbaugh <ben.ashbaugh@intel.com>

Author: Dastin-Wilski

lib/include/CL/Utils/File.hpp

@@ -1,49 +1,30 @@
 #pragma once
 
 // OpenCL SDK includes
-#include <CL/Utils/Utils.hpp>
+#include "OpenCLUtilsCpp_Export.h"
+
+#include <CL/Utils/Error.hpp>
+
+// OpenCL includes
+#include <CL/opencl.hpp>
 
-// STL includes
-#include <fstream>
-#include <string>
 
 namespace cl {
 namespace util {
-    // Scott Meyers, Effective STL, Addison-Wesley Professional, 2001, Item 29
-    // with error handling
-    UTILSCPP_EXPORT
-    std::string read_text_file(const char* const filename, cl_int* const error)
-    {
-        std::ifstream in(filename);
-        if (in.good())
-        {
-            try
-            {
-                std::string red((std::istreambuf_iterator<char>(in)),
-                                std::istreambuf_iterator<char>());
-                if (in.good() && in.eof())
-                {
-                    if (error != nullptr) *error = CL_SUCCESS;
-                    return red;
-                }
-                else
-                {
-                    detail::errHandler(CL_UTIL_FILE_OPERATION_ERROR, error,
-                                       "File read error!");
-                    return std::string();
-                }
-            } catch (std::bad_alloc& ex)
-            {
-                detail::errHandler(CL_OUT_OF_RESOURCES, error,
-                                   "Bad allocation!");
-                return std::string();
-            }
-        }
-        else
-        {
-            detail::errHandler(CL_INVALID_VALUE, error, "No file!");
-            return std::string();
-        }
-    }
+
+    std::string UTILSCPP_EXPORT read_text_file(const char* const filename,
+                                               cl_int* const error);
+
+    std::vector<unsigned char> UTILSCPP_EXPORT
+    read_binary_file(const char* const filename, cl_int* const error);
+
+    Program::Binaries UTILSCPP_EXPORT
+    read_binary_files(const std::vector<cl::Device>& devices,
+                      const char* const program_file_name, cl_int* const error);
+
+    cl_int UTILSCPP_EXPORT
+    write_binaries(const cl::Program::Binaries& binaries,
+                   const std::vector<cl::Device>& devices,
+                   const char* const program_file_name);
 }
 }

lib/include/CL/Utils/Utils.hpp

@@ -9,6 +9,7 @@
 #include <CL/Utils/Device.hpp>
 #include <CL/Utils/Context.hpp>
 #include <CL/Utils/Event.hpp>
+#include <CL/Utils/File.hpp>
 
 // OpenCL includes
 #include <CL/opencl.hpp>

lib/src/Utils/File.cpp

@@ -0,0 +1,122 @@
+// OpenCL SDK includes
+#include <CL/Utils/File.hpp>
+
+// STL includes
+#include <fstream>
+#include <iterator>
+#include <algorithm>
+#include <iostream>
+
+std::string cl::util::read_text_file(const char* const filename,
+                                     cl_int* const error)
+{
+    std::ifstream in(filename);
+    if (in.good())
+    {
+        try
+        {
+            std::string red((std::istreambuf_iterator<char>(in)),
+                            std::istreambuf_iterator<char>());
+
+            if (error != nullptr) *error = CL_SUCCESS;
+            return red;
+
+        } catch (std::bad_alloc&)
+        {
+            detail::errHandler(CL_OUT_OF_RESOURCES, error, "Bad allocation!");
+            return std::string();
+        }
+    }
+    else
+    {
+        detail::errHandler(CL_UTIL_FILE_OPERATION_ERROR, error, "No file!");
+        return std::string();
+    }
+}
+
+std::vector<unsigned char>
+cl::util::read_binary_file(const char* const filename, cl_int* const error)
+{
+    std::ifstream in(filename, std::ios::binary);
+    if (in.good())
+    {
+        try
+        {
+            std::vector<unsigned char> buffer(
+                std::istreambuf_iterator<char>(in), {});
+            if (error != nullptr) *error = CL_SUCCESS;
+            return buffer;
+        } catch (std::bad_alloc&)
+        {
+            detail::errHandler(CL_OUT_OF_RESOURCES, error, "Bad allocation!");
+            return std::vector<unsigned char>();
+        }
+    }
+    else
+    {
+        detail::errHandler(CL_UTIL_FILE_OPERATION_ERROR, error, "No file!");
+        return std::vector<unsigned char>();
+    }
+}
+
+
+cl::Program::Binaries
+cl::util::read_binary_files(const std::vector<cl::Device>& devices,
+                            const char* const program_base_name,
+                            cl_int* const error)
+{
+    cl::Program::Binaries binaries(0);
+
+    for (const auto& device : devices)
+    {
+        string device_name = device.getInfo<CL_DEVICE_NAME>();
+        string binary_name =
+            string(program_base_name) + "-" + device_name + ".bin";
+
+        binaries.push_back(
+            cl::util::read_binary_file(binary_name.c_str(), error));
+        if (error != nullptr)
+        {
+            if (*error != CL_SUCCESS)
+            {
+                detail::errHandler(CL_UTIL_FILE_OPERATION_ERROR, error,
+                                   "Not all binaries found!");
+                return cl::Program::Binaries();
+            }
+        }
+    }
+    return binaries;
+}
+
+cl_int cl::util::write_binaries(const cl::Program::Binaries& binaries,
+                                const std::vector<cl::Device>& devices,
+                                const char* const program_file_name)
+{
+    cl_int error = CL_SUCCESS;
+    if (binaries.size() == devices.size())
+    {
+        try
+        {
+            for (auto i = 0; i < binaries.size(); ++i)
+            {
+                string binary_name = string(program_file_name) + "-"
+                    + devices.at(i).getInfo<CL_DEVICE_NAME>() + ".bin";
+
+                std::ofstream out(binary_name, std::ios::binary);
+                out.write((const char*)binaries[i].data(),
+                          binaries[i].size() * sizeof(char));
+            }
+            return error;
+        } catch (std::bad_alloc&)
+        {
+            detail::errHandler(CL_OUT_OF_RESOURCES, &error, "Bad allocation!");
+            return error;
+        }
+    }
+    else
+    {
+        detail::errHandler(CL_INVALID_VALUE, &error,
+                           "Binaries and devices don't match!");
+        return error;
+    }
+}

lib/src/Utils/Utils.cpp

@@ -5,3 +5,4 @@
 #include "Platform.cpp"
 #include "Device.cpp"
 #include "Context.cpp"
+#include "File.cpp"

samples/core/binaries/CMakeLists.txt

@@ -18,3 +18,11 @@ add_sample(
     VERSION 300
     SOURCES main.c
     KERNELS Collatz.cl)
+
+add_sample(
+    TEST
+    TARGET binariescpp
+    VERSION 300
+    SOURCES main.cpp
+    KERNELS Collatz.cl)
+