GGEMSOpenCLManager.hh

Go to the documentation of this file.

#ifndef GUARD_GGEMS_GLOBAL_GGEMSOPENCLMANAGER_HH
#define GUARD_GGEMS_GLOBAL_GGEMSOPENCLMANAGER_HH
 
// ************************************************************************
// * This file is part of GGEMS.                                          *
// *                                                                      *
// * GGEMS is free software: you can redistribute it and/or modify        *
// * it under the terms of the GNU General Public License as published by *
// * the Free Software Foundation, either version 3 of the License, or    *
// * (at your option) any later version.                                  *
// *                                                                      *
// * GGEMS is distributed in the hope that it will be useful,             *
// * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
// * GNU General Public License for more details.                         *
// *                                                                      *
// * You should have received a copy of the GNU General Public License    *
// * along with GGEMS.  If not, see <https://www.gnu.org/licenses/>.      *
// *                                                                      *
// ************************************************************************
 
#include <unordered_map>
#include "GGEMS/tools/GGEMSPrint.hh"
 
#ifdef _MSC_VER
#pragma warning(disable: 4251) // Deleting warning exporting STL members!!!
#endif
 
#if __GNUC__ >= 6 
#pragma GCC diagnostic ignored "-Wignored-attributes"
#endif
 
typedef std::unordered_map<std::string, std::string> VendorUMap; 
#define KERNEL_NOT_COMPILED 0x100000000 
class GGEMS_EXPORT GGEMSOpenCLManager
{
  private:
    GGEMSOpenCLManager(void);
 
    ~GGEMSOpenCLManager(void);
 
  public:
    static GGEMSOpenCLManager& GetInstance(void)
    {
      static GGEMSOpenCLManager instance;
      return instance;
    }
 
    GGEMSOpenCLManager(GGEMSOpenCLManager const& opencl_manager) = delete;
 
    GGEMSOpenCLManager& operator=(GGEMSOpenCLManager const& opencl_manager) = delete;
 
    GGEMSOpenCLManager(GGEMSOpenCLManager const&& opencl_manager) = delete;
 
    GGEMSOpenCLManager& operator=(GGEMSOpenCLManager const&& opencl_manager) = delete;
 
    void CheckOpenCLError(GGint const& error, std::string const& class_name, std::string const& method_name) const;
 
    void PrintPlatformInfos(void) const;
 
    void PrintDeviceInfos(void) const;
 
    void PrintBuildOptions(void) const;
 
    void PrintActivatedDevices(void) const;
 
    inline std::string GetDeviceName(GGsize const& device_index) const {return device_name_[device_index];}
 
    inline cl_device_type GetDeviceType(GGsize const& device_index) const {return device_type_[device_index];}
 
    inline GGsize GetNumberOfDetectedDevice(void) const {return devices_.size();}
 
    inline GGsize GetNumberOfActivatedDevice(void) const {return device_indices_.size();}
 
    inline GGsize GetIndexOfActivatedDevice(GGsize const& thread_index) const {return device_indices_[thread_index];}
 
    inline GGsize GetMaxBufferAllocationSize(GGsize const& device_index) const {return static_cast<GGsize>(device_max_mem_alloc_size_[device_index]);}
 
    inline GGsize GetRAMMemory(GGsize const& device_index) const {return static_cast<GGsize>(device_global_mem_size_[device_index]);}
 
    inline GGsize GetWorkGroupSize(void) const { return work_group_size_;}
 
    GGsize GetBestWorkItem(GGsize const& number_of_elements) const;
 
    inline cl::Context* GetContext(GGsize const& thread_index) const {return contexts_[thread_index];}
 
    inline cl::CommandQueue* GetCommandQueue(GGsize const& thread_index) const {return queues_[thread_index];}
 
    inline cl::Event* GetEvent(GGsize const& thread_index) const {return events_[thread_index];}
 
    void DeviceToActivate(GGsize const& device_id);
 
    void DeviceToActivate(std::string const& device_type, std::string const& device_vendor = "");
 
 
    void DeviceBalancing(std::string const& device_balancing);
 
    inline GGfloat GetDeviceBalancing(GGsize const& thread_index) const {return device_balancing_[thread_index];}
 
    inline GGsize GetNumberDeviceLoads(void) const {return device_balancing_.size();}
 
    inline bool IsReady(void) const {return !device_indices_.empty();}
 
    void Clean(void);
 
    void CompileKernel(std::string const& kernel_filename, std::string const& kernel_name, cl::Kernel** kernel_list, char* const custom_options = nullptr, char* const additional_options = nullptr);
 
    template <typename T>
    T* GetDeviceBuffer(cl::Buffer* device_ptr, GGsize const& size, GGsize const& thread_index);
 
    template <typename T>
    void ReleaseDeviceBuffer(cl::Buffer* const device_ptr, T* host_ptr, GGsize const& thread_index);
 
    cl::Buffer* Allocate(void* host_ptr, GGsize const& size, GGsize const& thread_index, cl_mem_flags flags, std::string const& class_name = "Undefined");
 
    void Deallocate(cl::Buffer* buffer, GGsize size, GGsize const& thread_index, std::string const& class_name = "Undefined");
 
    void CleanBuffer(cl::Buffer* buffer, GGsize const& size, GGsize const& thread_index);
 
    bool IsDoublePrecisionAtomicAddition(GGsize const& device_index) const;
 
  private:
    std::string ErrorType(GGint const& error) const;
 
    GGsize CheckKernel(std::string const& kernel_name, std::string const& compilation_options) const;
 
    bool IsDoublePrecision(GGsize const& device_index) const;
 
  private:
    // OpenCL platform
    std::vector<cl::Platform> platforms_; 
    std::vector<std::string> platform_profile_; 
    std::vector<std::string> platform_version_; 
    std::vector<std::string> platform_name_; 
    std::vector<std::string> platform_vendor_; 
    std::vector<std::string> platform_extensions_; 
    // OpenCL device
    std::vector<cl::Device*> devices_; 
    std::vector<GGsize> device_indices_; 
    GGsize work_group_size_; 
    VendorUMap vendors_; 
    std::vector<cl_device_type> device_type_; 
    std::vector<std::string> device_name_; 
    std::vector<std::string> device_vendor_; 
    std::vector<GGuint> device_vendor_id_; 
    std::vector<std::string> device_profile_; 
    std::vector<std::string> device_version_; 
    std::vector<std::string> device_driver_version_; 
    std::vector<std::string> device_opencl_c_version_; 
    std::vector<GGuint> device_native_vector_width_char_; 
    std::vector<GGuint> device_native_vector_width_short_; 
    std::vector<GGuint> device_native_vector_width_int_; 
    std::vector<GGuint> device_native_vector_width_long_; 
    std::vector<GGuint> device_native_vector_width_half_; 
    std::vector<GGuint> device_native_vector_width_float_; 
    std::vector<GGuint> device_native_vector_width_double_; 
    std::vector<GGuint> device_preferred_vector_width_char_; 
    std::vector<GGuint> device_preferred_vector_width_short_; 
    std::vector<GGuint> device_preferred_vector_width_int_; 
    std::vector<GGuint> device_preferred_vector_width_long_; 
    std::vector<GGuint> device_preferred_vector_width_half_; 
    std::vector<GGuint> device_preferred_vector_width_float_; 
    std::vector<GGuint> device_preferred_vector_width_double_; 
    std::vector<GGuint> device_address_bits_; 
    std::vector<GGbool> device_available_; 
    std::vector<GGbool> device_compiler_available_; 
    std::vector<cl_device_fp_config> device_half_fp_config_; 
    std::vector<cl_device_fp_config> device_single_fp_config_; 
    std::vector<cl_device_fp_config> device_double_fp_config_; 
    std::vector<GGbool> device_endian_little_; 
    std::vector<std::string> device_extensions_; 
    std::vector<GGbool> device_error_correction_support_; 
    std::vector<cl_device_exec_capabilities> device_execution_capabilities_; 
    std::vector<GGulong> device_global_mem_cache_size_; 
    std::vector<cl_device_mem_cache_type> device_global_mem_cache_type_; 
    std::vector<GGuint> device_global_mem_cacheline_size_; 
    std::vector<GGulong> device_global_mem_size_; 
    std::vector<GGulong> device_local_mem_size_; 
    std::vector<cl_device_local_mem_type> device_local_mem_type_; 
    std::vector<GGbool> device_host_unified_memory_; 
    std::vector<GGsize> device_image_max_array_size_; 
    std::vector<GGsize> device_image_max_buffer_size_; 
    std::vector<GGbool> device_image_support_; 
    std::vector<GGsize> device_image2D_max_width_; 
    std::vector<GGsize> device_image2D_max_height_; 
    std::vector<GGsize> device_image3D_max_width_; 
    std::vector<GGsize> device_image3D_max_height_; 
    std::vector<GGsize> device_image3D_max_depth_; 
    std::vector<GGuint> device_max_read_image_args_; 
    std::vector<GGuint> device_max_write_image_args_; 
    std::vector<GGuint> device_max_clock_frequency_; 
    std::vector<GGuint> device_max_compute_units_; 
    std::vector<GGuint> device_max_constant_args_; 
    std::vector<GGulong> device_max_constant_buffer_size_; 
    std::vector<GGulong> device_max_mem_alloc_size_; 
    std::vector<GGsize> device_max_parameter_size_; 
    std::vector<GGuint> device_max_samplers_; 
    std::vector<GGsize> device_max_work_group_size_; 
    std::vector<GGuint> device_max_work_item_dimensions_; 
    std::vector<GGsize> device_max_work_item_sizes_; 
    std::vector<GGuint> device_mem_base_addr_align_; 
    std::vector<GGsize> device_printf_buffer_size_; 
    std::vector<cl_device_affinity_domain> device_partition_affinity_domain_; 
    std::vector<GGuint> device_partition_max_sub_devices_; 
    std::vector<GGsize> device_profiling_timer_resolution_; 
    std::vector<GGfloat> device_balancing_; 
    // OpenCL compilation options
    std::string build_options_; 
    // OpenCL context + command queue + event
    std::vector<cl::Context*> contexts_; 
    std::vector<cl::CommandQueue*> queues_; 
    std::vector<cl::Event*> events_; 
    // OpenCL kernels
    std::vector<cl::Kernel*> kernels_; 
    std::vector<std::string> kernel_compilation_options_; 
};
 
 
template <typename T>
T* GGEMSOpenCLManager::GetDeviceBuffer(cl::Buffer* const device_ptr, GGsize const& size, GGsize const& thread_index)
{
  GGcout("GGEMSOpenCLManager", "GetDeviceBuffer", 4) << "Getting mapped memory buffer on OpenCL device..." << GGendl;
 
  GGint err = 0;
  T* ptr = static_cast<T*>(queues_[thread_index]->enqueueMapBuffer(*device_ptr, CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, size, nullptr, nullptr, &err));
  CheckOpenCLError(err, "GGEMSOpenCLManager", "GetDeviceBuffer");
  return ptr;
}
 
 
template <typename T>
void GGEMSOpenCLManager::ReleaseDeviceBuffer(cl::Buffer* const device_ptr, T* host_ptr, GGsize const& thread_index)
{
  GGcout("GGEMSOpenCLManager", "ReleaseDeviceBuffer", 4) << "Releasing mapped memory buffer on OpenCL device..." << GGendl;
 
  // Unmap the memory
  CheckOpenCLError(queues_[thread_index]->enqueueUnmapMemObject(*device_ptr, host_ptr), "GGEMSOpenCLManager", "ReleaseDeviceBuffer");
}
 
extern "C" GGEMS_EXPORT GGEMSOpenCLManager* get_instance_ggems_opencl_manager(void);
 
extern "C" GGEMS_EXPORT void print_infos_opencl_manager(GGEMSOpenCLManager* opencl_manager);
 
extern "C" GGEMS_EXPORT void set_device_index_ggems_opencl_manager(GGEMSOpenCLManager* opencl_manager, GGsize const device_id);
 
extern "C" GGEMS_EXPORT void set_device_to_activate_opencl_manager(GGEMSOpenCLManager* opencl_manager, char const* device_type, char const* device_vendor = "");
 
extern "C" GGEMS_EXPORT void clean_opencl_manager(GGEMSOpenCLManager* opencl_manager);
 
extern "C" GGEMS_EXPORT void set_device_balancing_opencl_manager(GGEMSOpenCLManager* opencl_manager, char const* device_balancing);
 
#endif // GUARD_GGEMS_GLOBAL_GGEMSOpenCLManager_HH