diff options
Diffstat (limited to 'clinfo.cpp')
| -rw-r--r-- | clinfo.cpp | 308 |
1 files changed, 308 insertions, 0 deletions
diff --git a/clinfo.cpp b/clinfo.cpp new file mode 100644 index 0000000..e6b831b --- /dev/null +++ b/clinfo.cpp @@ -0,0 +1,308 @@ +// +// Copyright (C) 2012 Francisco Jerez +// +// clinfo 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. +// +// clinfo 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 clinfo. If not, see <http://www.gnu.org/licenses/>. +// + +#include <sstream> +#include <iostream> + +#define __CL_ENABLE_EXCEPTIONS +#include <CL/cl.hpp> + +#include "enums.hpp" + +namespace { + template<typename T, std::ios::fmtflags fmt = std::ios::dec> + struct scalar_param { + typedef T type; + + static std::string + format(const type &x) { + std::ostringstream ss; + + ss.flags(fmt); + ss << x; + + return ss.str(); + } + }; + + template<typename T> + struct array_param { + typedef std::vector<typename T::type> type; + + static std::string + format(const type &xs) { + std::ostringstream ss; + + ss << "{ "; + + for (auto &x: xs) { + if (&x != &xs.front()) + ss << ", "; + ss << T::format(x); + } + + ss << " }"; + + return ss.str(); + } + }; + + template<typename T> + struct enum_param { + typedef typename T::value_type type; + + static std::string + format(type x) { + return T::map.find(x)->second; + } + }; + + template<typename T> + struct bitmask_param { + typedef typename T::value_type type; + + static std::string + format(type x) { + std::ostringstream ss; + + for (auto e: T::map) { + if (x & e.first) { + if (ss.tellp()) + ss << " | "; + ss << e.second; + } + } + + return ss.str(); + } + }; + + struct extension_param { + typedef std::string type; + + static std::string + format(type x) { + std::ostringstream ss; + + for (std::string::size_type i = 0, j = 0; + i != std::string::npos; + i = j, j = x.find(" ", i + 1)) { + if (j > i + 1) { + if (ss.tellp()) + ss << "\n\t\t\t"; + ss << x.substr(i, j - i); + } + } + + return ss.str(); + } + }; + + inline std::ostream & + obj_out(const cl::Platform &) { + return std::cout << "\t"; + } + + inline std::ostream & + obj_out(const cl::Device &) { + return std::cout << "\t\t"; + } + + template<typename T, typename S> + void + print_param(const S &obj, int name) { + obj_out(obj) << enums::param::map.find(name)->second << ": "; + + try { + typename T::type param; + obj.getInfo(name, ¶m); + std::cout << T::format(param) << "\n"; + } catch (...) { + std::cout << "--\n"; + } + } +} + +int +main(int argc, char *argv[]) { + std::vector<cl::Platform> ps; + cl::Platform::get(&ps); + + for (auto &p: ps) { + std::cout << " - platform\n"; + + print_param<scalar_param<std::string>>( + p, CL_PLATFORM_NAME); + print_param<scalar_param<std::string>>( + p, CL_PLATFORM_VENDOR); + print_param<scalar_param<std::string>>( + p, CL_PLATFORM_VERSION); + print_param<scalar_param<std::string>>( + p, CL_PLATFORM_PROFILE); + print_param<extension_param>( + p, CL_PLATFORM_EXTENSIONS); + + try { + std::vector<cl::Device> ds; + p.getDevices(CL_DEVICE_TYPE_ALL, &ds); + + for (auto &d: ds) { + obj_out(p) << " - device\n"; + + print_param<scalar_param<std::string>>( + d, CL_DEVICE_NAME); + print_param<scalar_param<std::string>>( + d, CL_DEVICE_VENDOR); + print_param<scalar_param<std::string>>( + d, CL_DRIVER_VERSION); + print_param<scalar_param<std::string>>( + d, CL_DEVICE_PROFILE); + + print_param<bitmask_param<enums::device_type>>( + d, CL_DEVICE_TYPE); + print_param<scalar_param<cl_uint, std::ios::hex | std::ios::showbase>>( + d, CL_DEVICE_VENDOR_ID); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MAX_COMPUTE_UNITS); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS); + print_param<array_param<scalar_param<size_t>>>( + d, CL_DEVICE_MAX_WORK_ITEM_SIZES); + print_param<scalar_param<size_t>>( + d, CL_DEVICE_MAX_WORK_GROUP_SIZE); + + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF); + + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF); + + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MAX_CLOCK_FREQUENCY); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_ADDRESS_BITS); + print_param<scalar_param<cl_ulong>>( + d, CL_DEVICE_MAX_MEM_ALLOC_SIZE); + + print_param<enum_param<enums::boolean>>( + d, CL_DEVICE_IMAGE_SUPPORT); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MAX_READ_IMAGE_ARGS); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MAX_WRITE_IMAGE_ARGS); + print_param<scalar_param<size_t>>( + d, CL_DEVICE_IMAGE2D_MAX_WIDTH); + print_param<scalar_param<size_t>>( + d, CL_DEVICE_IMAGE2D_MAX_HEIGHT); + print_param<scalar_param<size_t>>( + d, CL_DEVICE_IMAGE3D_MAX_WIDTH); + print_param<scalar_param<size_t>>( + d, CL_DEVICE_IMAGE3D_MAX_HEIGHT); + print_param<scalar_param<size_t>>( + d, CL_DEVICE_IMAGE3D_MAX_DEPTH); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MAX_SAMPLERS); + + print_param<scalar_param<size_t>>( + d, CL_DEVICE_MAX_PARAMETER_SIZE); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MEM_BASE_ADDR_ALIGN); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE); + + print_param<bitmask_param<enums::device_fp_config>>( + d, CL_DEVICE_SINGLE_FP_CONFIG); + print_param<bitmask_param<enums::device_fp_config>>( + d, CL_DEVICE_DOUBLE_FP_CONFIG); + print_param<bitmask_param<enums::device_fp_config>>( + d, CL_DEVICE_HALF_FP_CONFIG); + + print_param<enum_param<enums::device_mem_cache_type>>( + d, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE); + print_param<scalar_param<cl_ulong>>( + d, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE); + print_param<scalar_param<cl_ulong>>( + d, CL_DEVICE_GLOBAL_MEM_SIZE); + + print_param<scalar_param<cl_ulong>>( + d, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE); + print_param<scalar_param<cl_uint>>( + d, CL_DEVICE_MAX_CONSTANT_ARGS); + + print_param<enum_param<enums::device_local_mem_type>>( + d, CL_DEVICE_LOCAL_MEM_TYPE); + print_param<scalar_param<cl_ulong>>( + d, CL_DEVICE_LOCAL_MEM_SIZE); + + print_param<enum_param<enums::boolean>>( + d, CL_DEVICE_ERROR_CORRECTION_SUPPORT); + print_param<enum_param<enums::boolean>>( + d, CL_DEVICE_HOST_UNIFIED_MEMORY); + print_param<scalar_param<size_t>>( + d, CL_DEVICE_PROFILING_TIMER_RESOLUTION); + print_param<enum_param<enums::boolean>>( + d, CL_DEVICE_ENDIAN_LITTLE); + print_param<enum_param<enums::boolean>>( + d, CL_DEVICE_AVAILABLE); + print_param<enum_param<enums::boolean>>( + d, CL_DEVICE_COMPILER_AVAILABLE); + + print_param<bitmask_param<enums::device_exec_capabilities>>( + d, CL_DEVICE_EXECUTION_CAPABILITIES); + print_param<bitmask_param<enums::command_queue_properties>>( + d, CL_DEVICE_QUEUE_PROPERTIES); + + print_param<scalar_param<std::string>>( + d, CL_DEVICE_VERSION); + print_param<scalar_param<std::string>>( + d, CL_DEVICE_OPENCL_C_VERSION); + print_param<extension_param>( + d, CL_DEVICE_EXTENSIONS); + } + + } catch (...) { + } + } + + return 0; +} |