pi_opencl.hpp

Go to the documentation of this file.

//==---------- pi_opencl.hpp - OpenCL Plugin -------------------------------==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
 
#ifndef PI_OPENCL_HPP
#define PI_OPENCL_HPP
 
#include <climits>
#include <regex>
#include <string>
 
// This version should be incremented for any change made to this file or its
// corresponding .cpp file.
#define _PI_OPENCL_PLUGIN_VERSION 1
 
#define _PI_OPENCL_PLUGIN_VERSION_STRING                                       \
  _PI_PLUGIN_VERSION_STRING(_PI_OPENCL_PLUGIN_VERSION)
 
namespace OCLV {
class OpenCLVersion {
protected:
  unsigned int ocl_major;
  unsigned int ocl_minor;
 
public:
  OpenCLVersion() : ocl_major(0), ocl_minor(0) {}
 
  OpenCLVersion(unsigned int ocl_major, unsigned int ocl_minor)
      : ocl_major(ocl_major), ocl_minor(ocl_minor) {
    if (!isValid())
      ocl_major = ocl_minor = 0;
  }
 
  OpenCLVersion(const char *version) : OpenCLVersion(std::string(version)) {}
 
  OpenCLVersion(const std::string &version) : ocl_major(0), ocl_minor(0) {
    /* The OpenCL specification defines the full version string as
     * 'OpenCL<space><ocl_major_version.ocl_minor_version><space><platform-specific
     * information>' for platforms and as
     * 'OpenCL<space><ocl_major_version.ocl_minor_version><space><vendor-specific
     * information>' for devices.
     */
    std::regex rx("OpenCL ([0-9]+)\\.([0-9]+)");
    std::smatch match;
 
    if (std::regex_search(version, match, rx) && (match.size() == 3)) {
      ocl_major = strtoul(match[1].str().c_str(), nullptr, 10);
      ocl_minor = strtoul(match[2].str().c_str(), nullptr, 10);
 
      if (!isValid())
        ocl_major = ocl_minor = 0;
    }
  }
 
  bool operator==(const OpenCLVersion &v) const {
    return ocl_major == v.ocl_major && ocl_minor == v.ocl_minor;
  }
 
  bool operator!=(const OpenCLVersion &v) const { return !(*this == v); }
 
  bool operator<(const OpenCLVersion &v) const {
    if (ocl_major == v.ocl_major)
      return ocl_minor < v.ocl_minor;
 
    return ocl_major < v.ocl_major;
  }
 
  bool operator>(const OpenCLVersion &v) const { return v < *this; }
 
  bool operator<=(const OpenCLVersion &v) const {
    return (*this < v) || (*this == v);
  }
 
  bool operator>=(const OpenCLVersion &v) const {
    return (*this > v) || (*this == v);
  }
 
  bool isValid() const {
    switch (ocl_major) {
    case 0:
      return false;
    case 1:
    case 2:
      return ocl_minor <= 2;
    case UINT_MAX:
      return false;
    default:
      return ocl_minor != UINT_MAX;
    }
  }
 
  int getMajor() const { return ocl_major; }
  int getMinor() const { return ocl_minor; }
};
 
inline const OpenCLVersion V1_0(1, 0);
inline const OpenCLVersion V1_1(1, 1);
inline const OpenCLVersion V1_2(1, 2);
inline const OpenCLVersion V2_0(2, 0);
inline const OpenCLVersion V2_1(2, 1);
inline const OpenCLVersion V2_2(2, 2);
inline const OpenCLVersion V3_0(3, 0);
 
} // namespace OCLV
 
#endif // PI_OPENCL_HPP