| // GENERATED FILE - DO NOT EDIT. | |
| // Generated by gen_packed_gl_enums.py using data from packed_cl_enums.json. | |
| // | |
| // Copyright 2017 The ANGLE Project Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // | |
| // PackedCLEnums_autogen.cpp: | |
| // Implements ANGLE-specific enums classes for CLenums and functions operating | |
| // on them. | |
| #include "common/PackedCLEnums_autogen.h" | |
| #include "common/debug.h" | |
| namespace cl | |
| { | |
| template <> | |
| AddressingMode FromCLenum<AddressingMode>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_ADDRESS_NONE: | |
| return AddressingMode::None; | |
| case CL_ADDRESS_CLAMP_TO_EDGE: | |
| return AddressingMode::ClampToEdge; | |
| case CL_ADDRESS_CLAMP: | |
| return AddressingMode::Clamp; | |
| case CL_ADDRESS_REPEAT: | |
| return AddressingMode::Repeat; | |
| case CL_ADDRESS_MIRRORED_REPEAT: | |
| return AddressingMode::MirroredRepeat; | |
| default: | |
| return AddressingMode::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(AddressingMode from) | |
| { | |
| switch (from) | |
| { | |
| case AddressingMode::None: | |
| return CL_ADDRESS_NONE; | |
| case AddressingMode::ClampToEdge: | |
| return CL_ADDRESS_CLAMP_TO_EDGE; | |
| case AddressingMode::Clamp: | |
| return CL_ADDRESS_CLAMP; | |
| case AddressingMode::Repeat: | |
| return CL_ADDRESS_REPEAT; | |
| case AddressingMode::MirroredRepeat: | |
| return CL_ADDRESS_MIRRORED_REPEAT; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, AddressingMode value) | |
| { | |
| switch (value) | |
| { | |
| case AddressingMode::None: | |
| os << "CL_ADDRESS_NONE"; | |
| break; | |
| case AddressingMode::ClampToEdge: | |
| os << "CL_ADDRESS_CLAMP_TO_EDGE"; | |
| break; | |
| case AddressingMode::Clamp: | |
| os << "CL_ADDRESS_CLAMP"; | |
| break; | |
| case AddressingMode::Repeat: | |
| os << "CL_ADDRESS_REPEAT"; | |
| break; | |
| case AddressingMode::MirroredRepeat: | |
| os << "CL_ADDRESS_MIRRORED_REPEAT"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| CommandQueueInfo FromCLenum<CommandQueueInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_QUEUE_CONTEXT: | |
| return CommandQueueInfo::Context; | |
| case CL_QUEUE_DEVICE: | |
| return CommandQueueInfo::Device; | |
| case CL_QUEUE_REFERENCE_COUNT: | |
| return CommandQueueInfo::ReferenceCount; | |
| case CL_QUEUE_PROPERTIES: | |
| return CommandQueueInfo::Properties; | |
| case CL_QUEUE_SIZE: | |
| return CommandQueueInfo::Size; | |
| case CL_QUEUE_DEVICE_DEFAULT: | |
| return CommandQueueInfo::DeviceDefault; | |
| case CL_QUEUE_PROPERTIES_ARRAY: | |
| return CommandQueueInfo::PropertiesArray; | |
| default: | |
| return CommandQueueInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(CommandQueueInfo from) | |
| { | |
| switch (from) | |
| { | |
| case CommandQueueInfo::Context: | |
| return CL_QUEUE_CONTEXT; | |
| case CommandQueueInfo::Device: | |
| return CL_QUEUE_DEVICE; | |
| case CommandQueueInfo::ReferenceCount: | |
| return CL_QUEUE_REFERENCE_COUNT; | |
| case CommandQueueInfo::Properties: | |
| return CL_QUEUE_PROPERTIES; | |
| case CommandQueueInfo::Size: | |
| return CL_QUEUE_SIZE; | |
| case CommandQueueInfo::DeviceDefault: | |
| return CL_QUEUE_DEVICE_DEFAULT; | |
| case CommandQueueInfo::PropertiesArray: | |
| return CL_QUEUE_PROPERTIES_ARRAY; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, CommandQueueInfo value) | |
| { | |
| switch (value) | |
| { | |
| case CommandQueueInfo::Context: | |
| os << "CL_QUEUE_CONTEXT"; | |
| break; | |
| case CommandQueueInfo::Device: | |
| os << "CL_QUEUE_DEVICE"; | |
| break; | |
| case CommandQueueInfo::ReferenceCount: | |
| os << "CL_QUEUE_REFERENCE_COUNT"; | |
| break; | |
| case CommandQueueInfo::Properties: | |
| os << "CL_QUEUE_PROPERTIES"; | |
| break; | |
| case CommandQueueInfo::Size: | |
| os << "CL_QUEUE_SIZE"; | |
| break; | |
| case CommandQueueInfo::DeviceDefault: | |
| os << "CL_QUEUE_DEVICE_DEFAULT"; | |
| break; | |
| case CommandQueueInfo::PropertiesArray: | |
| os << "CL_QUEUE_PROPERTIES_ARRAY"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| ContextInfo FromCLenum<ContextInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_CONTEXT_REFERENCE_COUNT: | |
| return ContextInfo::ReferenceCount; | |
| case CL_CONTEXT_DEVICES: | |
| return ContextInfo::Devices; | |
| case CL_CONTEXT_PROPERTIES: | |
| return ContextInfo::Properties; | |
| case CL_CONTEXT_NUM_DEVICES: | |
| return ContextInfo::NumDevices; | |
| default: | |
| return ContextInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(ContextInfo from) | |
| { | |
| switch (from) | |
| { | |
| case ContextInfo::ReferenceCount: | |
| return CL_CONTEXT_REFERENCE_COUNT; | |
| case ContextInfo::Devices: | |
| return CL_CONTEXT_DEVICES; | |
| case ContextInfo::Properties: | |
| return CL_CONTEXT_PROPERTIES; | |
| case ContextInfo::NumDevices: | |
| return CL_CONTEXT_NUM_DEVICES; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, ContextInfo value) | |
| { | |
| switch (value) | |
| { | |
| case ContextInfo::ReferenceCount: | |
| os << "CL_CONTEXT_REFERENCE_COUNT"; | |
| break; | |
| case ContextInfo::Devices: | |
| os << "CL_CONTEXT_DEVICES"; | |
| break; | |
| case ContextInfo::Properties: | |
| os << "CL_CONTEXT_PROPERTIES"; | |
| break; | |
| case ContextInfo::NumDevices: | |
| os << "CL_CONTEXT_NUM_DEVICES"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| DeviceInfo FromCLenum<DeviceInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_DEVICE_TYPE: | |
| return DeviceInfo::Type; | |
| case CL_DEVICE_VENDOR_ID: | |
| return DeviceInfo::VendorID; | |
| case CL_DEVICE_MAX_COMPUTE_UNITS: | |
| return DeviceInfo::MaxComputeUnits; | |
| case CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS: | |
| return DeviceInfo::MaxWorkItemDimensions; | |
| case CL_DEVICE_MAX_WORK_GROUP_SIZE: | |
| return DeviceInfo::MaxWorkGroupSize; | |
| case CL_DEVICE_MAX_WORK_ITEM_SIZES: | |
| return DeviceInfo::MaxWorkItemSizes; | |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR: | |
| return DeviceInfo::PreferredVectorWidthChar; | |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT: | |
| return DeviceInfo::PreferredVectorWidthShort; | |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: | |
| return DeviceInfo::PreferredVectorWidthInt; | |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: | |
| return DeviceInfo::PreferredVectorWidthLong; | |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: | |
| return DeviceInfo::PreferredVectorWidthFloat; | |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: | |
| return DeviceInfo::PreferredVectorWidthDouble; | |
| case CL_DEVICE_MAX_CLOCK_FREQUENCY: | |
| return DeviceInfo::MaxClockFrequency; | |
| case CL_DEVICE_ADDRESS_BITS: | |
| return DeviceInfo::AddressBits; | |
| case CL_DEVICE_MAX_READ_IMAGE_ARGS: | |
| return DeviceInfo::MaxReadImageArgs; | |
| case CL_DEVICE_MAX_WRITE_IMAGE_ARGS: | |
| return DeviceInfo::MaxWriteImageArgs; | |
| case CL_DEVICE_MAX_MEM_ALLOC_SIZE: | |
| return DeviceInfo::MaxMemAllocSize; | |
| case CL_DEVICE_IMAGE2D_MAX_WIDTH: | |
| return DeviceInfo::Image2D_MaxWidth; | |
| case CL_DEVICE_IMAGE2D_MAX_HEIGHT: | |
| return DeviceInfo::Image2D_MaxHeight; | |
| case CL_DEVICE_IMAGE3D_MAX_WIDTH: | |
| return DeviceInfo::Image3D_MaxWidth; | |
| case CL_DEVICE_IMAGE3D_MAX_HEIGHT: | |
| return DeviceInfo::Image3D_MaxHeight; | |
| case CL_DEVICE_IMAGE3D_MAX_DEPTH: | |
| return DeviceInfo::Image3D_MaxDepth; | |
| case CL_DEVICE_IMAGE_SUPPORT: | |
| return DeviceInfo::ImageSupport; | |
| case CL_DEVICE_MAX_PARAMETER_SIZE: | |
| return DeviceInfo::MaxParameterSize; | |
| case CL_DEVICE_MAX_SAMPLERS: | |
| return DeviceInfo::MaxSamplers; | |
| case CL_DEVICE_MEM_BASE_ADDR_ALIGN: | |
| return DeviceInfo::MemBaseAddrAlign; | |
| case CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE: | |
| return DeviceInfo::MinDataTypeAlignSize; | |
| case CL_DEVICE_SINGLE_FP_CONFIG: | |
| return DeviceInfo::SingleFpConfig; | |
| case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: | |
| return DeviceInfo::GlobalMemCacheType; | |
| case CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: | |
| return DeviceInfo::GlobalMemCachelineSize; | |
| case CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: | |
| return DeviceInfo::GlobalMemCacheSize; | |
| case CL_DEVICE_GLOBAL_MEM_SIZE: | |
| return DeviceInfo::GlobalMemSize; | |
| case CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: | |
| return DeviceInfo::MaxConstantBufferSize; | |
| case CL_DEVICE_MAX_CONSTANT_ARGS: | |
| return DeviceInfo::MaxConstantArgs; | |
| case CL_DEVICE_LOCAL_MEM_TYPE: | |
| return DeviceInfo::LocalMemType; | |
| case CL_DEVICE_LOCAL_MEM_SIZE: | |
| return DeviceInfo::LocalMemSize; | |
| case CL_DEVICE_ERROR_CORRECTION_SUPPORT: | |
| return DeviceInfo::ErrorCorrectionSupport; | |
| case CL_DEVICE_PROFILING_TIMER_RESOLUTION: | |
| return DeviceInfo::ProfilingTimerResolution; | |
| case CL_DEVICE_ENDIAN_LITTLE: | |
| return DeviceInfo::EndianLittle; | |
| case CL_DEVICE_AVAILABLE: | |
| return DeviceInfo::Available; | |
| case CL_DEVICE_COMPILER_AVAILABLE: | |
| return DeviceInfo::CompilerAvailable; | |
| case CL_DEVICE_EXECUTION_CAPABILITIES: | |
| return DeviceInfo::ExecutionCapabilities; | |
| case CL_DEVICE_QUEUE_ON_HOST_PROPERTIES: | |
| return DeviceInfo::QueueOnHostProperties; | |
| case CL_DEVICE_NAME: | |
| return DeviceInfo::Name; | |
| case CL_DEVICE_VENDOR: | |
| return DeviceInfo::Vendor; | |
| case CL_DRIVER_VERSION: | |
| return DeviceInfo::DriverVersion; | |
| case CL_DEVICE_PROFILE: | |
| return DeviceInfo::Profile; | |
| case CL_DEVICE_VERSION: | |
| return DeviceInfo::Version; | |
| case CL_DEVICE_EXTENSIONS: | |
| return DeviceInfo::Extensions; | |
| case CL_DEVICE_PLATFORM: | |
| return DeviceInfo::Platform; | |
| case CL_DEVICE_DOUBLE_FP_CONFIG: | |
| return DeviceInfo::DoubleFpConfig; | |
| case CL_DEVICE_HALF_FP_CONFIG: | |
| return DeviceInfo::HalfFpConfig; | |
| case CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF: | |
| return DeviceInfo::PreferredVectorWidthHalf; | |
| case CL_DEVICE_HOST_UNIFIED_MEMORY: | |
| return DeviceInfo::HostUnifiedMemory; | |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR: | |
| return DeviceInfo::NativeVectorWidthChar; | |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT: | |
| return DeviceInfo::NativeVectorWidthShort; | |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_INT: | |
| return DeviceInfo::NativeVectorWidthInt; | |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: | |
| return DeviceInfo::NativeVectorWidthLong; | |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT: | |
| return DeviceInfo::NativeVectorWidthFloat; | |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE: | |
| return DeviceInfo::NativeVectorWidthDouble; | |
| case CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF: | |
| return DeviceInfo::NativeVectorWidthHalf; | |
| case CL_DEVICE_OPENCL_C_VERSION: | |
| return DeviceInfo::OpenCL_C_Version; | |
| case CL_DEVICE_LINKER_AVAILABLE: | |
| return DeviceInfo::LinkerAvailable; | |
| case CL_DEVICE_BUILT_IN_KERNELS: | |
| return DeviceInfo::BuiltInKernels; | |
| case CL_DEVICE_IMAGE_MAX_BUFFER_SIZE: | |
| return DeviceInfo::ImageMaxBufferSize; | |
| case CL_DEVICE_IMAGE_MAX_ARRAY_SIZE: | |
| return DeviceInfo::ImageMaxArraySize; | |
| case CL_DEVICE_PARENT_DEVICE: | |
| return DeviceInfo::ParentDevice; | |
| case CL_DEVICE_PARTITION_MAX_SUB_DEVICES: | |
| return DeviceInfo::PartitionMaxSubDevices; | |
| case CL_DEVICE_PARTITION_PROPERTIES: | |
| return DeviceInfo::PartitionProperties; | |
| case CL_DEVICE_PARTITION_AFFINITY_DOMAIN: | |
| return DeviceInfo::PartitionAffinityDomain; | |
| case CL_DEVICE_PARTITION_TYPE: | |
| return DeviceInfo::PartitionType; | |
| case CL_DEVICE_REFERENCE_COUNT: | |
| return DeviceInfo::ReferenceCount; | |
| case CL_DEVICE_PREFERRED_INTEROP_USER_SYNC: | |
| return DeviceInfo::PreferredInteropUserSync; | |
| case CL_DEVICE_PRINTF_BUFFER_SIZE: | |
| return DeviceInfo::PrintfBufferSize; | |
| case CL_DEVICE_IMAGE_PITCH_ALIGNMENT: | |
| return DeviceInfo::ImagePitchAlignment; | |
| case CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT: | |
| return DeviceInfo::ImageBaseAddressAlignment; | |
| case CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS: | |
| return DeviceInfo::MaxReadWriteImageArgs; | |
| case CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE: | |
| return DeviceInfo::MaxGlobalVariableSize; | |
| case CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES: | |
| return DeviceInfo::QueueOnDeviceProperties; | |
| case CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE: | |
| return DeviceInfo::QueueOnDevicePreferredSize; | |
| case CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE: | |
| return DeviceInfo::QueueOnDeviceMaxSize; | |
| case CL_DEVICE_MAX_ON_DEVICE_QUEUES: | |
| return DeviceInfo::MaxOnDeviceQueues; | |
| case CL_DEVICE_MAX_ON_DEVICE_EVENTS: | |
| return DeviceInfo::MaxOnDeviceEvents; | |
| case CL_DEVICE_SVM_CAPABILITIES: | |
| return DeviceInfo::SVM_Capabilities; | |
| case CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE: | |
| return DeviceInfo::GlobalVariablePreferredTotalSize; | |
| case CL_DEVICE_MAX_PIPE_ARGS: | |
| return DeviceInfo::MaxPipeArgs; | |
| case CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS: | |
| return DeviceInfo::PipeMaxActiveReservations; | |
| case CL_DEVICE_PIPE_MAX_PACKET_SIZE: | |
| return DeviceInfo::PipeMaxPacketSize; | |
| case CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT: | |
| return DeviceInfo::PreferredPlatformAtomicAlignment; | |
| case CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT: | |
| return DeviceInfo::PreferredGlobalAtomicAlignment; | |
| case CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT: | |
| return DeviceInfo::PreferredLocalAtomicAlignment; | |
| case CL_DEVICE_IL_VERSION: | |
| return DeviceInfo::IL_Version; | |
| case CL_DEVICE_MAX_NUM_SUB_GROUPS: | |
| return DeviceInfo::MaxNumSubGroups; | |
| case CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS: | |
| return DeviceInfo::SubGroupIndependentForwardProgress; | |
| case CL_DEVICE_NUMERIC_VERSION: | |
| return DeviceInfo::NumericVersion; | |
| case CL_DEVICE_EXTENSIONS_WITH_VERSION: | |
| return DeviceInfo::ExtensionsWithVersion; | |
| case CL_DEVICE_ILS_WITH_VERSION: | |
| return DeviceInfo::ILsWithVersion; | |
| case CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION: | |
| return DeviceInfo::BuiltInKernelsWithVersion; | |
| case CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES: | |
| return DeviceInfo::AtomicMemoryCapabilities; | |
| case CL_DEVICE_ATOMIC_FENCE_CAPABILITIES: | |
| return DeviceInfo::AtomicFenceCapabilities; | |
| case CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT: | |
| return DeviceInfo::NonUniformWorkGroupSupport; | |
| case CL_DEVICE_OPENCL_C_ALL_VERSIONS: | |
| return DeviceInfo::OpenCL_C_AllVersions; | |
| case CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE: | |
| return DeviceInfo::PreferredWorkGroupSizeMultiple; | |
| case CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT: | |
| return DeviceInfo::WorkGroupCollectiveFunctionsSupport; | |
| case CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT: | |
| return DeviceInfo::GenericAddressSpaceSupport; | |
| case CL_DEVICE_OPENCL_C_FEATURES: | |
| return DeviceInfo::OpenCL_C_Features; | |
| case CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES: | |
| return DeviceInfo::DeviceEnqueueCapabilities; | |
| case CL_DEVICE_PIPE_SUPPORT: | |
| return DeviceInfo::PipeSupport; | |
| case CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED: | |
| return DeviceInfo::LatestConformanceVersionPassed; | |
| default: | |
| return DeviceInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(DeviceInfo from) | |
| { | |
| switch (from) | |
| { | |
| case DeviceInfo::Type: | |
| return CL_DEVICE_TYPE; | |
| case DeviceInfo::VendorID: | |
| return CL_DEVICE_VENDOR_ID; | |
| case DeviceInfo::MaxComputeUnits: | |
| return CL_DEVICE_MAX_COMPUTE_UNITS; | |
| case DeviceInfo::MaxWorkItemDimensions: | |
| return CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS; | |
| case DeviceInfo::MaxWorkGroupSize: | |
| return CL_DEVICE_MAX_WORK_GROUP_SIZE; | |
| case DeviceInfo::MaxWorkItemSizes: | |
| return CL_DEVICE_MAX_WORK_ITEM_SIZES; | |
| case DeviceInfo::PreferredVectorWidthChar: | |
| return CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR; | |
| case DeviceInfo::PreferredVectorWidthShort: | |
| return CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT; | |
| case DeviceInfo::PreferredVectorWidthInt: | |
| return CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT; | |
| case DeviceInfo::PreferredVectorWidthLong: | |
| return CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG; | |
| case DeviceInfo::PreferredVectorWidthFloat: | |
| return CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT; | |
| case DeviceInfo::PreferredVectorWidthDouble: | |
| return CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE; | |
| case DeviceInfo::MaxClockFrequency: | |
| return CL_DEVICE_MAX_CLOCK_FREQUENCY; | |
| case DeviceInfo::AddressBits: | |
| return CL_DEVICE_ADDRESS_BITS; | |
| case DeviceInfo::MaxReadImageArgs: | |
| return CL_DEVICE_MAX_READ_IMAGE_ARGS; | |
| case DeviceInfo::MaxWriteImageArgs: | |
| return CL_DEVICE_MAX_WRITE_IMAGE_ARGS; | |
| case DeviceInfo::MaxMemAllocSize: | |
| return CL_DEVICE_MAX_MEM_ALLOC_SIZE; | |
| case DeviceInfo::Image2D_MaxWidth: | |
| return CL_DEVICE_IMAGE2D_MAX_WIDTH; | |
| case DeviceInfo::Image2D_MaxHeight: | |
| return CL_DEVICE_IMAGE2D_MAX_HEIGHT; | |
| case DeviceInfo::Image3D_MaxWidth: | |
| return CL_DEVICE_IMAGE3D_MAX_WIDTH; | |
| case DeviceInfo::Image3D_MaxHeight: | |
| return CL_DEVICE_IMAGE3D_MAX_HEIGHT; | |
| case DeviceInfo::Image3D_MaxDepth: | |
| return CL_DEVICE_IMAGE3D_MAX_DEPTH; | |
| case DeviceInfo::ImageSupport: | |
| return CL_DEVICE_IMAGE_SUPPORT; | |
| case DeviceInfo::MaxParameterSize: | |
| return CL_DEVICE_MAX_PARAMETER_SIZE; | |
| case DeviceInfo::MaxSamplers: | |
| return CL_DEVICE_MAX_SAMPLERS; | |
| case DeviceInfo::MemBaseAddrAlign: | |
| return CL_DEVICE_MEM_BASE_ADDR_ALIGN; | |
| case DeviceInfo::MinDataTypeAlignSize: | |
| return CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE; | |
| case DeviceInfo::SingleFpConfig: | |
| return CL_DEVICE_SINGLE_FP_CONFIG; | |
| case DeviceInfo::GlobalMemCacheType: | |
| return CL_DEVICE_GLOBAL_MEM_CACHE_TYPE; | |
| case DeviceInfo::GlobalMemCachelineSize: | |
| return CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE; | |
| case DeviceInfo::GlobalMemCacheSize: | |
| return CL_DEVICE_GLOBAL_MEM_CACHE_SIZE; | |
| case DeviceInfo::GlobalMemSize: | |
| return CL_DEVICE_GLOBAL_MEM_SIZE; | |
| case DeviceInfo::MaxConstantBufferSize: | |
| return CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE; | |
| case DeviceInfo::MaxConstantArgs: | |
| return CL_DEVICE_MAX_CONSTANT_ARGS; | |
| case DeviceInfo::LocalMemType: | |
| return CL_DEVICE_LOCAL_MEM_TYPE; | |
| case DeviceInfo::LocalMemSize: | |
| return CL_DEVICE_LOCAL_MEM_SIZE; | |
| case DeviceInfo::ErrorCorrectionSupport: | |
| return CL_DEVICE_ERROR_CORRECTION_SUPPORT; | |
| case DeviceInfo::ProfilingTimerResolution: | |
| return CL_DEVICE_PROFILING_TIMER_RESOLUTION; | |
| case DeviceInfo::EndianLittle: | |
| return CL_DEVICE_ENDIAN_LITTLE; | |
| case DeviceInfo::Available: | |
| return CL_DEVICE_AVAILABLE; | |
| case DeviceInfo::CompilerAvailable: | |
| return CL_DEVICE_COMPILER_AVAILABLE; | |
| case DeviceInfo::ExecutionCapabilities: | |
| return CL_DEVICE_EXECUTION_CAPABILITIES; | |
| case DeviceInfo::QueueOnHostProperties: | |
| return CL_DEVICE_QUEUE_ON_HOST_PROPERTIES; | |
| case DeviceInfo::Name: | |
| return CL_DEVICE_NAME; | |
| case DeviceInfo::Vendor: | |
| return CL_DEVICE_VENDOR; | |
| case DeviceInfo::DriverVersion: | |
| return CL_DRIVER_VERSION; | |
| case DeviceInfo::Profile: | |
| return CL_DEVICE_PROFILE; | |
| case DeviceInfo::Version: | |
| return CL_DEVICE_VERSION; | |
| case DeviceInfo::Extensions: | |
| return CL_DEVICE_EXTENSIONS; | |
| case DeviceInfo::Platform: | |
| return CL_DEVICE_PLATFORM; | |
| case DeviceInfo::DoubleFpConfig: | |
| return CL_DEVICE_DOUBLE_FP_CONFIG; | |
| case DeviceInfo::HalfFpConfig: | |
| return CL_DEVICE_HALF_FP_CONFIG; | |
| case DeviceInfo::PreferredVectorWidthHalf: | |
| return CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF; | |
| case DeviceInfo::HostUnifiedMemory: | |
| return CL_DEVICE_HOST_UNIFIED_MEMORY; | |
| case DeviceInfo::NativeVectorWidthChar: | |
| return CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR; | |
| case DeviceInfo::NativeVectorWidthShort: | |
| return CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT; | |
| case DeviceInfo::NativeVectorWidthInt: | |
| return CL_DEVICE_NATIVE_VECTOR_WIDTH_INT; | |
| case DeviceInfo::NativeVectorWidthLong: | |
| return CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG; | |
| case DeviceInfo::NativeVectorWidthFloat: | |
| return CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT; | |
| case DeviceInfo::NativeVectorWidthDouble: | |
| return CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE; | |
| case DeviceInfo::NativeVectorWidthHalf: | |
| return CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF; | |
| case DeviceInfo::OpenCL_C_Version: | |
| return CL_DEVICE_OPENCL_C_VERSION; | |
| case DeviceInfo::LinkerAvailable: | |
| return CL_DEVICE_LINKER_AVAILABLE; | |
| case DeviceInfo::BuiltInKernels: | |
| return CL_DEVICE_BUILT_IN_KERNELS; | |
| case DeviceInfo::ImageMaxBufferSize: | |
| return CL_DEVICE_IMAGE_MAX_BUFFER_SIZE; | |
| case DeviceInfo::ImageMaxArraySize: | |
| return CL_DEVICE_IMAGE_MAX_ARRAY_SIZE; | |
| case DeviceInfo::ParentDevice: | |
| return CL_DEVICE_PARENT_DEVICE; | |
| case DeviceInfo::PartitionMaxSubDevices: | |
| return CL_DEVICE_PARTITION_MAX_SUB_DEVICES; | |
| case DeviceInfo::PartitionProperties: | |
| return CL_DEVICE_PARTITION_PROPERTIES; | |
| case DeviceInfo::PartitionAffinityDomain: | |
| return CL_DEVICE_PARTITION_AFFINITY_DOMAIN; | |
| case DeviceInfo::PartitionType: | |
| return CL_DEVICE_PARTITION_TYPE; | |
| case DeviceInfo::ReferenceCount: | |
| return CL_DEVICE_REFERENCE_COUNT; | |
| case DeviceInfo::PreferredInteropUserSync: | |
| return CL_DEVICE_PREFERRED_INTEROP_USER_SYNC; | |
| case DeviceInfo::PrintfBufferSize: | |
| return CL_DEVICE_PRINTF_BUFFER_SIZE; | |
| case DeviceInfo::ImagePitchAlignment: | |
| return CL_DEVICE_IMAGE_PITCH_ALIGNMENT; | |
| case DeviceInfo::ImageBaseAddressAlignment: | |
| return CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT; | |
| case DeviceInfo::MaxReadWriteImageArgs: | |
| return CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS; | |
| case DeviceInfo::MaxGlobalVariableSize: | |
| return CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE; | |
| case DeviceInfo::QueueOnDeviceProperties: | |
| return CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES; | |
| case DeviceInfo::QueueOnDevicePreferredSize: | |
| return CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE; | |
| case DeviceInfo::QueueOnDeviceMaxSize: | |
| return CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE; | |
| case DeviceInfo::MaxOnDeviceQueues: | |
| return CL_DEVICE_MAX_ON_DEVICE_QUEUES; | |
| case DeviceInfo::MaxOnDeviceEvents: | |
| return CL_DEVICE_MAX_ON_DEVICE_EVENTS; | |
| case DeviceInfo::SVM_Capabilities: | |
| return CL_DEVICE_SVM_CAPABILITIES; | |
| case DeviceInfo::GlobalVariablePreferredTotalSize: | |
| return CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE; | |
| case DeviceInfo::MaxPipeArgs: | |
| return CL_DEVICE_MAX_PIPE_ARGS; | |
| case DeviceInfo::PipeMaxActiveReservations: | |
| return CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS; | |
| case DeviceInfo::PipeMaxPacketSize: | |
| return CL_DEVICE_PIPE_MAX_PACKET_SIZE; | |
| case DeviceInfo::PreferredPlatformAtomicAlignment: | |
| return CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT; | |
| case DeviceInfo::PreferredGlobalAtomicAlignment: | |
| return CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT; | |
| case DeviceInfo::PreferredLocalAtomicAlignment: | |
| return CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT; | |
| case DeviceInfo::IL_Version: | |
| return CL_DEVICE_IL_VERSION; | |
| case DeviceInfo::MaxNumSubGroups: | |
| return CL_DEVICE_MAX_NUM_SUB_GROUPS; | |
| case DeviceInfo::SubGroupIndependentForwardProgress: | |
| return CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS; | |
| case DeviceInfo::NumericVersion: | |
| return CL_DEVICE_NUMERIC_VERSION; | |
| case DeviceInfo::ExtensionsWithVersion: | |
| return CL_DEVICE_EXTENSIONS_WITH_VERSION; | |
| case DeviceInfo::ILsWithVersion: | |
| return CL_DEVICE_ILS_WITH_VERSION; | |
| case DeviceInfo::BuiltInKernelsWithVersion: | |
| return CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION; | |
| case DeviceInfo::AtomicMemoryCapabilities: | |
| return CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES; | |
| case DeviceInfo::AtomicFenceCapabilities: | |
| return CL_DEVICE_ATOMIC_FENCE_CAPABILITIES; | |
| case DeviceInfo::NonUniformWorkGroupSupport: | |
| return CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT; | |
| case DeviceInfo::OpenCL_C_AllVersions: | |
| return CL_DEVICE_OPENCL_C_ALL_VERSIONS; | |
| case DeviceInfo::PreferredWorkGroupSizeMultiple: | |
| return CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE; | |
| case DeviceInfo::WorkGroupCollectiveFunctionsSupport: | |
| return CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT; | |
| case DeviceInfo::GenericAddressSpaceSupport: | |
| return CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT; | |
| case DeviceInfo::OpenCL_C_Features: | |
| return CL_DEVICE_OPENCL_C_FEATURES; | |
| case DeviceInfo::DeviceEnqueueCapabilities: | |
| return CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES; | |
| case DeviceInfo::PipeSupport: | |
| return CL_DEVICE_PIPE_SUPPORT; | |
| case DeviceInfo::LatestConformanceVersionPassed: | |
| return CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, DeviceInfo value) | |
| { | |
| switch (value) | |
| { | |
| case DeviceInfo::Type: | |
| os << "CL_DEVICE_TYPE"; | |
| break; | |
| case DeviceInfo::VendorID: | |
| os << "CL_DEVICE_VENDOR_ID"; | |
| break; | |
| case DeviceInfo::MaxComputeUnits: | |
| os << "CL_DEVICE_MAX_COMPUTE_UNITS"; | |
| break; | |
| case DeviceInfo::MaxWorkItemDimensions: | |
| os << "CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS"; | |
| break; | |
| case DeviceInfo::MaxWorkGroupSize: | |
| os << "CL_DEVICE_MAX_WORK_GROUP_SIZE"; | |
| break; | |
| case DeviceInfo::MaxWorkItemSizes: | |
| os << "CL_DEVICE_MAX_WORK_ITEM_SIZES"; | |
| break; | |
| case DeviceInfo::PreferredVectorWidthChar: | |
| os << "CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR"; | |
| break; | |
| case DeviceInfo::PreferredVectorWidthShort: | |
| os << "CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT"; | |
| break; | |
| case DeviceInfo::PreferredVectorWidthInt: | |
| os << "CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT"; | |
| break; | |
| case DeviceInfo::PreferredVectorWidthLong: | |
| os << "CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG"; | |
| break; | |
| case DeviceInfo::PreferredVectorWidthFloat: | |
| os << "CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT"; | |
| break; | |
| case DeviceInfo::PreferredVectorWidthDouble: | |
| os << "CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE"; | |
| break; | |
| case DeviceInfo::MaxClockFrequency: | |
| os << "CL_DEVICE_MAX_CLOCK_FREQUENCY"; | |
| break; | |
| case DeviceInfo::AddressBits: | |
| os << "CL_DEVICE_ADDRESS_BITS"; | |
| break; | |
| case DeviceInfo::MaxReadImageArgs: | |
| os << "CL_DEVICE_MAX_READ_IMAGE_ARGS"; | |
| break; | |
| case DeviceInfo::MaxWriteImageArgs: | |
| os << "CL_DEVICE_MAX_WRITE_IMAGE_ARGS"; | |
| break; | |
| case DeviceInfo::MaxMemAllocSize: | |
| os << "CL_DEVICE_MAX_MEM_ALLOC_SIZE"; | |
| break; | |
| case DeviceInfo::Image2D_MaxWidth: | |
| os << "CL_DEVICE_IMAGE2D_MAX_WIDTH"; | |
| break; | |
| case DeviceInfo::Image2D_MaxHeight: | |
| os << "CL_DEVICE_IMAGE2D_MAX_HEIGHT"; | |
| break; | |
| case DeviceInfo::Image3D_MaxWidth: | |
| os << "CL_DEVICE_IMAGE3D_MAX_WIDTH"; | |
| break; | |
| case DeviceInfo::Image3D_MaxHeight: | |
| os << "CL_DEVICE_IMAGE3D_MAX_HEIGHT"; | |
| break; | |
| case DeviceInfo::Image3D_MaxDepth: | |
| os << "CL_DEVICE_IMAGE3D_MAX_DEPTH"; | |
| break; | |
| case DeviceInfo::ImageSupport: | |
| os << "CL_DEVICE_IMAGE_SUPPORT"; | |
| break; | |
| case DeviceInfo::MaxParameterSize: | |
| os << "CL_DEVICE_MAX_PARAMETER_SIZE"; | |
| break; | |
| case DeviceInfo::MaxSamplers: | |
| os << "CL_DEVICE_MAX_SAMPLERS"; | |
| break; | |
| case DeviceInfo::MemBaseAddrAlign: | |
| os << "CL_DEVICE_MEM_BASE_ADDR_ALIGN"; | |
| break; | |
| case DeviceInfo::MinDataTypeAlignSize: | |
| os << "CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE"; | |
| break; | |
| case DeviceInfo::SingleFpConfig: | |
| os << "CL_DEVICE_SINGLE_FP_CONFIG"; | |
| break; | |
| case DeviceInfo::GlobalMemCacheType: | |
| os << "CL_DEVICE_GLOBAL_MEM_CACHE_TYPE"; | |
| break; | |
| case DeviceInfo::GlobalMemCachelineSize: | |
| os << "CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE"; | |
| break; | |
| case DeviceInfo::GlobalMemCacheSize: | |
| os << "CL_DEVICE_GLOBAL_MEM_CACHE_SIZE"; | |
| break; | |
| case DeviceInfo::GlobalMemSize: | |
| os << "CL_DEVICE_GLOBAL_MEM_SIZE"; | |
| break; | |
| case DeviceInfo::MaxConstantBufferSize: | |
| os << "CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE"; | |
| break; | |
| case DeviceInfo::MaxConstantArgs: | |
| os << "CL_DEVICE_MAX_CONSTANT_ARGS"; | |
| break; | |
| case DeviceInfo::LocalMemType: | |
| os << "CL_DEVICE_LOCAL_MEM_TYPE"; | |
| break; | |
| case DeviceInfo::LocalMemSize: | |
| os << "CL_DEVICE_LOCAL_MEM_SIZE"; | |
| break; | |
| case DeviceInfo::ErrorCorrectionSupport: | |
| os << "CL_DEVICE_ERROR_CORRECTION_SUPPORT"; | |
| break; | |
| case DeviceInfo::ProfilingTimerResolution: | |
| os << "CL_DEVICE_PROFILING_TIMER_RESOLUTION"; | |
| break; | |
| case DeviceInfo::EndianLittle: | |
| os << "CL_DEVICE_ENDIAN_LITTLE"; | |
| break; | |
| case DeviceInfo::Available: | |
| os << "CL_DEVICE_AVAILABLE"; | |
| break; | |
| case DeviceInfo::CompilerAvailable: | |
| os << "CL_DEVICE_COMPILER_AVAILABLE"; | |
| break; | |
| case DeviceInfo::ExecutionCapabilities: | |
| os << "CL_DEVICE_EXECUTION_CAPABILITIES"; | |
| break; | |
| case DeviceInfo::QueueOnHostProperties: | |
| os << "CL_DEVICE_QUEUE_ON_HOST_PROPERTIES"; | |
| break; | |
| case DeviceInfo::Name: | |
| os << "CL_DEVICE_NAME"; | |
| break; | |
| case DeviceInfo::Vendor: | |
| os << "CL_DEVICE_VENDOR"; | |
| break; | |
| case DeviceInfo::DriverVersion: | |
| os << "CL_DRIVER_VERSION"; | |
| break; | |
| case DeviceInfo::Profile: | |
| os << "CL_DEVICE_PROFILE"; | |
| break; | |
| case DeviceInfo::Version: | |
| os << "CL_DEVICE_VERSION"; | |
| break; | |
| case DeviceInfo::Extensions: | |
| os << "CL_DEVICE_EXTENSIONS"; | |
| break; | |
| case DeviceInfo::Platform: | |
| os << "CL_DEVICE_PLATFORM"; | |
| break; | |
| case DeviceInfo::DoubleFpConfig: | |
| os << "CL_DEVICE_DOUBLE_FP_CONFIG"; | |
| break; | |
| case DeviceInfo::HalfFpConfig: | |
| os << "CL_DEVICE_HALF_FP_CONFIG"; | |
| break; | |
| case DeviceInfo::PreferredVectorWidthHalf: | |
| os << "CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF"; | |
| break; | |
| case DeviceInfo::HostUnifiedMemory: | |
| os << "CL_DEVICE_HOST_UNIFIED_MEMORY"; | |
| break; | |
| case DeviceInfo::NativeVectorWidthChar: | |
| os << "CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR"; | |
| break; | |
| case DeviceInfo::NativeVectorWidthShort: | |
| os << "CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT"; | |
| break; | |
| case DeviceInfo::NativeVectorWidthInt: | |
| os << "CL_DEVICE_NATIVE_VECTOR_WIDTH_INT"; | |
| break; | |
| case DeviceInfo::NativeVectorWidthLong: | |
| os << "CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG"; | |
| break; | |
| case DeviceInfo::NativeVectorWidthFloat: | |
| os << "CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT"; | |
| break; | |
| case DeviceInfo::NativeVectorWidthDouble: | |
| os << "CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE"; | |
| break; | |
| case DeviceInfo::NativeVectorWidthHalf: | |
| os << "CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF"; | |
| break; | |
| case DeviceInfo::OpenCL_C_Version: | |
| os << "CL_DEVICE_OPENCL_C_VERSION"; | |
| break; | |
| case DeviceInfo::LinkerAvailable: | |
| os << "CL_DEVICE_LINKER_AVAILABLE"; | |
| break; | |
| case DeviceInfo::BuiltInKernels: | |
| os << "CL_DEVICE_BUILT_IN_KERNELS"; | |
| break; | |
| case DeviceInfo::ImageMaxBufferSize: | |
| os << "CL_DEVICE_IMAGE_MAX_BUFFER_SIZE"; | |
| break; | |
| case DeviceInfo::ImageMaxArraySize: | |
| os << "CL_DEVICE_IMAGE_MAX_ARRAY_SIZE"; | |
| break; | |
| case DeviceInfo::ParentDevice: | |
| os << "CL_DEVICE_PARENT_DEVICE"; | |
| break; | |
| case DeviceInfo::PartitionMaxSubDevices: | |
| os << "CL_DEVICE_PARTITION_MAX_SUB_DEVICES"; | |
| break; | |
| case DeviceInfo::PartitionProperties: | |
| os << "CL_DEVICE_PARTITION_PROPERTIES"; | |
| break; | |
| case DeviceInfo::PartitionAffinityDomain: | |
| os << "CL_DEVICE_PARTITION_AFFINITY_DOMAIN"; | |
| break; | |
| case DeviceInfo::PartitionType: | |
| os << "CL_DEVICE_PARTITION_TYPE"; | |
| break; | |
| case DeviceInfo::ReferenceCount: | |
| os << "CL_DEVICE_REFERENCE_COUNT"; | |
| break; | |
| case DeviceInfo::PreferredInteropUserSync: | |
| os << "CL_DEVICE_PREFERRED_INTEROP_USER_SYNC"; | |
| break; | |
| case DeviceInfo::PrintfBufferSize: | |
| os << "CL_DEVICE_PRINTF_BUFFER_SIZE"; | |
| break; | |
| case DeviceInfo::ImagePitchAlignment: | |
| os << "CL_DEVICE_IMAGE_PITCH_ALIGNMENT"; | |
| break; | |
| case DeviceInfo::ImageBaseAddressAlignment: | |
| os << "CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT"; | |
| break; | |
| case DeviceInfo::MaxReadWriteImageArgs: | |
| os << "CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS"; | |
| break; | |
| case DeviceInfo::MaxGlobalVariableSize: | |
| os << "CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE"; | |
| break; | |
| case DeviceInfo::QueueOnDeviceProperties: | |
| os << "CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES"; | |
| break; | |
| case DeviceInfo::QueueOnDevicePreferredSize: | |
| os << "CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE"; | |
| break; | |
| case DeviceInfo::QueueOnDeviceMaxSize: | |
| os << "CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE"; | |
| break; | |
| case DeviceInfo::MaxOnDeviceQueues: | |
| os << "CL_DEVICE_MAX_ON_DEVICE_QUEUES"; | |
| break; | |
| case DeviceInfo::MaxOnDeviceEvents: | |
| os << "CL_DEVICE_MAX_ON_DEVICE_EVENTS"; | |
| break; | |
| case DeviceInfo::SVM_Capabilities: | |
| os << "CL_DEVICE_SVM_CAPABILITIES"; | |
| break; | |
| case DeviceInfo::GlobalVariablePreferredTotalSize: | |
| os << "CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE"; | |
| break; | |
| case DeviceInfo::MaxPipeArgs: | |
| os << "CL_DEVICE_MAX_PIPE_ARGS"; | |
| break; | |
| case DeviceInfo::PipeMaxActiveReservations: | |
| os << "CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS"; | |
| break; | |
| case DeviceInfo::PipeMaxPacketSize: | |
| os << "CL_DEVICE_PIPE_MAX_PACKET_SIZE"; | |
| break; | |
| case DeviceInfo::PreferredPlatformAtomicAlignment: | |
| os << "CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT"; | |
| break; | |
| case DeviceInfo::PreferredGlobalAtomicAlignment: | |
| os << "CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT"; | |
| break; | |
| case DeviceInfo::PreferredLocalAtomicAlignment: | |
| os << "CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT"; | |
| break; | |
| case DeviceInfo::IL_Version: | |
| os << "CL_DEVICE_IL_VERSION"; | |
| break; | |
| case DeviceInfo::MaxNumSubGroups: | |
| os << "CL_DEVICE_MAX_NUM_SUB_GROUPS"; | |
| break; | |
| case DeviceInfo::SubGroupIndependentForwardProgress: | |
| os << "CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS"; | |
| break; | |
| case DeviceInfo::NumericVersion: | |
| os << "CL_DEVICE_NUMERIC_VERSION"; | |
| break; | |
| case DeviceInfo::ExtensionsWithVersion: | |
| os << "CL_DEVICE_EXTENSIONS_WITH_VERSION"; | |
| break; | |
| case DeviceInfo::ILsWithVersion: | |
| os << "CL_DEVICE_ILS_WITH_VERSION"; | |
| break; | |
| case DeviceInfo::BuiltInKernelsWithVersion: | |
| os << "CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION"; | |
| break; | |
| case DeviceInfo::AtomicMemoryCapabilities: | |
| os << "CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES"; | |
| break; | |
| case DeviceInfo::AtomicFenceCapabilities: | |
| os << "CL_DEVICE_ATOMIC_FENCE_CAPABILITIES"; | |
| break; | |
| case DeviceInfo::NonUniformWorkGroupSupport: | |
| os << "CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT"; | |
| break; | |
| case DeviceInfo::OpenCL_C_AllVersions: | |
| os << "CL_DEVICE_OPENCL_C_ALL_VERSIONS"; | |
| break; | |
| case DeviceInfo::PreferredWorkGroupSizeMultiple: | |
| os << "CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE"; | |
| break; | |
| case DeviceInfo::WorkGroupCollectiveFunctionsSupport: | |
| os << "CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT"; | |
| break; | |
| case DeviceInfo::GenericAddressSpaceSupport: | |
| os << "CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT"; | |
| break; | |
| case DeviceInfo::OpenCL_C_Features: | |
| os << "CL_DEVICE_OPENCL_C_FEATURES"; | |
| break; | |
| case DeviceInfo::DeviceEnqueueCapabilities: | |
| os << "CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES"; | |
| break; | |
| case DeviceInfo::PipeSupport: | |
| os << "CL_DEVICE_PIPE_SUPPORT"; | |
| break; | |
| case DeviceInfo::LatestConformanceVersionPassed: | |
| os << "CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| EventInfo FromCLenum<EventInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_EVENT_COMMAND_QUEUE: | |
| return EventInfo::CommandQueue; | |
| case CL_EVENT_COMMAND_TYPE: | |
| return EventInfo::CommandType; | |
| case CL_EVENT_REFERENCE_COUNT: | |
| return EventInfo::ReferenceCount; | |
| case CL_EVENT_COMMAND_EXECUTION_STATUS: | |
| return EventInfo::CommandExecutionStatus; | |
| case CL_EVENT_CONTEXT: | |
| return EventInfo::Context; | |
| default: | |
| return EventInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(EventInfo from) | |
| { | |
| switch (from) | |
| { | |
| case EventInfo::CommandQueue: | |
| return CL_EVENT_COMMAND_QUEUE; | |
| case EventInfo::CommandType: | |
| return CL_EVENT_COMMAND_TYPE; | |
| case EventInfo::ReferenceCount: | |
| return CL_EVENT_REFERENCE_COUNT; | |
| case EventInfo::CommandExecutionStatus: | |
| return CL_EVENT_COMMAND_EXECUTION_STATUS; | |
| case EventInfo::Context: | |
| return CL_EVENT_CONTEXT; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, EventInfo value) | |
| { | |
| switch (value) | |
| { | |
| case EventInfo::CommandQueue: | |
| os << "CL_EVENT_COMMAND_QUEUE"; | |
| break; | |
| case EventInfo::CommandType: | |
| os << "CL_EVENT_COMMAND_TYPE"; | |
| break; | |
| case EventInfo::ReferenceCount: | |
| os << "CL_EVENT_REFERENCE_COUNT"; | |
| break; | |
| case EventInfo::CommandExecutionStatus: | |
| os << "CL_EVENT_COMMAND_EXECUTION_STATUS"; | |
| break; | |
| case EventInfo::Context: | |
| os << "CL_EVENT_CONTEXT"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| FilterMode FromCLenum<FilterMode>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_FILTER_NEAREST: | |
| return FilterMode::Nearest; | |
| case CL_FILTER_LINEAR: | |
| return FilterMode::Linear; | |
| default: | |
| return FilterMode::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(FilterMode from) | |
| { | |
| switch (from) | |
| { | |
| case FilterMode::Nearest: | |
| return CL_FILTER_NEAREST; | |
| case FilterMode::Linear: | |
| return CL_FILTER_LINEAR; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, FilterMode value) | |
| { | |
| switch (value) | |
| { | |
| case FilterMode::Nearest: | |
| os << "CL_FILTER_NEAREST"; | |
| break; | |
| case FilterMode::Linear: | |
| os << "CL_FILTER_LINEAR"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| ImageInfo FromCLenum<ImageInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_IMAGE_FORMAT: | |
| return ImageInfo::Format; | |
| case CL_IMAGE_ELEMENT_SIZE: | |
| return ImageInfo::ElementSize; | |
| case CL_IMAGE_ROW_PITCH: | |
| return ImageInfo::RowPitch; | |
| case CL_IMAGE_SLICE_PITCH: | |
| return ImageInfo::SlicePitch; | |
| case CL_IMAGE_WIDTH: | |
| return ImageInfo::Width; | |
| case CL_IMAGE_HEIGHT: | |
| return ImageInfo::Height; | |
| case CL_IMAGE_DEPTH: | |
| return ImageInfo::Depth; | |
| case CL_IMAGE_ARRAY_SIZE: | |
| return ImageInfo::ArraySize; | |
| case CL_IMAGE_BUFFER: | |
| return ImageInfo::Buffer; | |
| case CL_IMAGE_NUM_MIP_LEVELS: | |
| return ImageInfo::NumMipLevels; | |
| case CL_IMAGE_NUM_SAMPLES: | |
| return ImageInfo::NumSamples; | |
| default: | |
| return ImageInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(ImageInfo from) | |
| { | |
| switch (from) | |
| { | |
| case ImageInfo::Format: | |
| return CL_IMAGE_FORMAT; | |
| case ImageInfo::ElementSize: | |
| return CL_IMAGE_ELEMENT_SIZE; | |
| case ImageInfo::RowPitch: | |
| return CL_IMAGE_ROW_PITCH; | |
| case ImageInfo::SlicePitch: | |
| return CL_IMAGE_SLICE_PITCH; | |
| case ImageInfo::Width: | |
| return CL_IMAGE_WIDTH; | |
| case ImageInfo::Height: | |
| return CL_IMAGE_HEIGHT; | |
| case ImageInfo::Depth: | |
| return CL_IMAGE_DEPTH; | |
| case ImageInfo::ArraySize: | |
| return CL_IMAGE_ARRAY_SIZE; | |
| case ImageInfo::Buffer: | |
| return CL_IMAGE_BUFFER; | |
| case ImageInfo::NumMipLevels: | |
| return CL_IMAGE_NUM_MIP_LEVELS; | |
| case ImageInfo::NumSamples: | |
| return CL_IMAGE_NUM_SAMPLES; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, ImageInfo value) | |
| { | |
| switch (value) | |
| { | |
| case ImageInfo::Format: | |
| os << "CL_IMAGE_FORMAT"; | |
| break; | |
| case ImageInfo::ElementSize: | |
| os << "CL_IMAGE_ELEMENT_SIZE"; | |
| break; | |
| case ImageInfo::RowPitch: | |
| os << "CL_IMAGE_ROW_PITCH"; | |
| break; | |
| case ImageInfo::SlicePitch: | |
| os << "CL_IMAGE_SLICE_PITCH"; | |
| break; | |
| case ImageInfo::Width: | |
| os << "CL_IMAGE_WIDTH"; | |
| break; | |
| case ImageInfo::Height: | |
| os << "CL_IMAGE_HEIGHT"; | |
| break; | |
| case ImageInfo::Depth: | |
| os << "CL_IMAGE_DEPTH"; | |
| break; | |
| case ImageInfo::ArraySize: | |
| os << "CL_IMAGE_ARRAY_SIZE"; | |
| break; | |
| case ImageInfo::Buffer: | |
| os << "CL_IMAGE_BUFFER"; | |
| break; | |
| case ImageInfo::NumMipLevels: | |
| os << "CL_IMAGE_NUM_MIP_LEVELS"; | |
| break; | |
| case ImageInfo::NumSamples: | |
| os << "CL_IMAGE_NUM_SAMPLES"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| KernelArgInfo FromCLenum<KernelArgInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_KERNEL_ARG_ADDRESS_QUALIFIER: | |
| return KernelArgInfo::AddressQualifier; | |
| case CL_KERNEL_ARG_ACCESS_QUALIFIER: | |
| return KernelArgInfo::AccessQualifier; | |
| case CL_KERNEL_ARG_TYPE_NAME: | |
| return KernelArgInfo::TypeName; | |
| case CL_KERNEL_ARG_TYPE_QUALIFIER: | |
| return KernelArgInfo::TypeQualifier; | |
| case CL_KERNEL_ARG_NAME: | |
| return KernelArgInfo::Name; | |
| default: | |
| return KernelArgInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(KernelArgInfo from) | |
| { | |
| switch (from) | |
| { | |
| case KernelArgInfo::AddressQualifier: | |
| return CL_KERNEL_ARG_ADDRESS_QUALIFIER; | |
| case KernelArgInfo::AccessQualifier: | |
| return CL_KERNEL_ARG_ACCESS_QUALIFIER; | |
| case KernelArgInfo::TypeName: | |
| return CL_KERNEL_ARG_TYPE_NAME; | |
| case KernelArgInfo::TypeQualifier: | |
| return CL_KERNEL_ARG_TYPE_QUALIFIER; | |
| case KernelArgInfo::Name: | |
| return CL_KERNEL_ARG_NAME; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, KernelArgInfo value) | |
| { | |
| switch (value) | |
| { | |
| case KernelArgInfo::AddressQualifier: | |
| os << "CL_KERNEL_ARG_ADDRESS_QUALIFIER"; | |
| break; | |
| case KernelArgInfo::AccessQualifier: | |
| os << "CL_KERNEL_ARG_ACCESS_QUALIFIER"; | |
| break; | |
| case KernelArgInfo::TypeName: | |
| os << "CL_KERNEL_ARG_TYPE_NAME"; | |
| break; | |
| case KernelArgInfo::TypeQualifier: | |
| os << "CL_KERNEL_ARG_TYPE_QUALIFIER"; | |
| break; | |
| case KernelArgInfo::Name: | |
| os << "CL_KERNEL_ARG_NAME"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| KernelExecInfo FromCLenum<KernelExecInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_KERNEL_EXEC_INFO_SVM_PTRS: | |
| return KernelExecInfo::SVM_Ptrs; | |
| case CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM: | |
| return KernelExecInfo::SVM_FineGrainSystem; | |
| default: | |
| return KernelExecInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(KernelExecInfo from) | |
| { | |
| switch (from) | |
| { | |
| case KernelExecInfo::SVM_Ptrs: | |
| return CL_KERNEL_EXEC_INFO_SVM_PTRS; | |
| case KernelExecInfo::SVM_FineGrainSystem: | |
| return CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, KernelExecInfo value) | |
| { | |
| switch (value) | |
| { | |
| case KernelExecInfo::SVM_Ptrs: | |
| os << "CL_KERNEL_EXEC_INFO_SVM_PTRS"; | |
| break; | |
| case KernelExecInfo::SVM_FineGrainSystem: | |
| os << "CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| KernelInfo FromCLenum<KernelInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_KERNEL_FUNCTION_NAME: | |
| return KernelInfo::FunctionName; | |
| case CL_KERNEL_NUM_ARGS: | |
| return KernelInfo::NumArgs; | |
| case CL_KERNEL_REFERENCE_COUNT: | |
| return KernelInfo::ReferenceCount; | |
| case CL_KERNEL_CONTEXT: | |
| return KernelInfo::Context; | |
| case CL_KERNEL_PROGRAM: | |
| return KernelInfo::Program; | |
| case CL_KERNEL_ATTRIBUTES: | |
| return KernelInfo::Attributes; | |
| default: | |
| return KernelInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(KernelInfo from) | |
| { | |
| switch (from) | |
| { | |
| case KernelInfo::FunctionName: | |
| return CL_KERNEL_FUNCTION_NAME; | |
| case KernelInfo::NumArgs: | |
| return CL_KERNEL_NUM_ARGS; | |
| case KernelInfo::ReferenceCount: | |
| return CL_KERNEL_REFERENCE_COUNT; | |
| case KernelInfo::Context: | |
| return CL_KERNEL_CONTEXT; | |
| case KernelInfo::Program: | |
| return CL_KERNEL_PROGRAM; | |
| case KernelInfo::Attributes: | |
| return CL_KERNEL_ATTRIBUTES; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, KernelInfo value) | |
| { | |
| switch (value) | |
| { | |
| case KernelInfo::FunctionName: | |
| os << "CL_KERNEL_FUNCTION_NAME"; | |
| break; | |
| case KernelInfo::NumArgs: | |
| os << "CL_KERNEL_NUM_ARGS"; | |
| break; | |
| case KernelInfo::ReferenceCount: | |
| os << "CL_KERNEL_REFERENCE_COUNT"; | |
| break; | |
| case KernelInfo::Context: | |
| os << "CL_KERNEL_CONTEXT"; | |
| break; | |
| case KernelInfo::Program: | |
| os << "CL_KERNEL_PROGRAM"; | |
| break; | |
| case KernelInfo::Attributes: | |
| os << "CL_KERNEL_ATTRIBUTES"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| KernelSubGroupInfo FromCLenum<KernelSubGroupInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE: | |
| return KernelSubGroupInfo::MaxSubGroupSizeForNdrange; | |
| case CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE: | |
| return KernelSubGroupInfo::SubGroupCountForNdrange; | |
| case CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT: | |
| return KernelSubGroupInfo::LocalSizeForSubGroupCount; | |
| case CL_KERNEL_MAX_NUM_SUB_GROUPS: | |
| return KernelSubGroupInfo::MaxNumSubGroups; | |
| case CL_KERNEL_COMPILE_NUM_SUB_GROUPS: | |
| return KernelSubGroupInfo::CompileNumSubGroups; | |
| default: | |
| return KernelSubGroupInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(KernelSubGroupInfo from) | |
| { | |
| switch (from) | |
| { | |
| case KernelSubGroupInfo::MaxSubGroupSizeForNdrange: | |
| return CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE; | |
| case KernelSubGroupInfo::SubGroupCountForNdrange: | |
| return CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE; | |
| case KernelSubGroupInfo::LocalSizeForSubGroupCount: | |
| return CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT; | |
| case KernelSubGroupInfo::MaxNumSubGroups: | |
| return CL_KERNEL_MAX_NUM_SUB_GROUPS; | |
| case KernelSubGroupInfo::CompileNumSubGroups: | |
| return CL_KERNEL_COMPILE_NUM_SUB_GROUPS; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, KernelSubGroupInfo value) | |
| { | |
| switch (value) | |
| { | |
| case KernelSubGroupInfo::MaxSubGroupSizeForNdrange: | |
| os << "CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE"; | |
| break; | |
| case KernelSubGroupInfo::SubGroupCountForNdrange: | |
| os << "CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE"; | |
| break; | |
| case KernelSubGroupInfo::LocalSizeForSubGroupCount: | |
| os << "CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT"; | |
| break; | |
| case KernelSubGroupInfo::MaxNumSubGroups: | |
| os << "CL_KERNEL_MAX_NUM_SUB_GROUPS"; | |
| break; | |
| case KernelSubGroupInfo::CompileNumSubGroups: | |
| os << "CL_KERNEL_COMPILE_NUM_SUB_GROUPS"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| KernelWorkGroupInfo FromCLenum<KernelWorkGroupInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_KERNEL_WORK_GROUP_SIZE: | |
| return KernelWorkGroupInfo::WorkGroupSize; | |
| case CL_KERNEL_COMPILE_WORK_GROUP_SIZE: | |
| return KernelWorkGroupInfo::CompileWorkGroupSize; | |
| case CL_KERNEL_LOCAL_MEM_SIZE: | |
| return KernelWorkGroupInfo::LocalMemSize; | |
| case CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE: | |
| return KernelWorkGroupInfo::PreferredWorkGroupSizeMultiple; | |
| case CL_KERNEL_PRIVATE_MEM_SIZE: | |
| return KernelWorkGroupInfo::PrivateMemSize; | |
| case CL_KERNEL_GLOBAL_WORK_SIZE: | |
| return KernelWorkGroupInfo::GlobalWorkSize; | |
| default: | |
| return KernelWorkGroupInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(KernelWorkGroupInfo from) | |
| { | |
| switch (from) | |
| { | |
| case KernelWorkGroupInfo::WorkGroupSize: | |
| return CL_KERNEL_WORK_GROUP_SIZE; | |
| case KernelWorkGroupInfo::CompileWorkGroupSize: | |
| return CL_KERNEL_COMPILE_WORK_GROUP_SIZE; | |
| case KernelWorkGroupInfo::LocalMemSize: | |
| return CL_KERNEL_LOCAL_MEM_SIZE; | |
| case KernelWorkGroupInfo::PreferredWorkGroupSizeMultiple: | |
| return CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE; | |
| case KernelWorkGroupInfo::PrivateMemSize: | |
| return CL_KERNEL_PRIVATE_MEM_SIZE; | |
| case KernelWorkGroupInfo::GlobalWorkSize: | |
| return CL_KERNEL_GLOBAL_WORK_SIZE; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, KernelWorkGroupInfo value) | |
| { | |
| switch (value) | |
| { | |
| case KernelWorkGroupInfo::WorkGroupSize: | |
| os << "CL_KERNEL_WORK_GROUP_SIZE"; | |
| break; | |
| case KernelWorkGroupInfo::CompileWorkGroupSize: | |
| os << "CL_KERNEL_COMPILE_WORK_GROUP_SIZE"; | |
| break; | |
| case KernelWorkGroupInfo::LocalMemSize: | |
| os << "CL_KERNEL_LOCAL_MEM_SIZE"; | |
| break; | |
| case KernelWorkGroupInfo::PreferredWorkGroupSizeMultiple: | |
| os << "CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE"; | |
| break; | |
| case KernelWorkGroupInfo::PrivateMemSize: | |
| os << "CL_KERNEL_PRIVATE_MEM_SIZE"; | |
| break; | |
| case KernelWorkGroupInfo::GlobalWorkSize: | |
| os << "CL_KERNEL_GLOBAL_WORK_SIZE"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| MemInfo FromCLenum<MemInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_MEM_TYPE: | |
| return MemInfo::Type; | |
| case CL_MEM_FLAGS: | |
| return MemInfo::Flags; | |
| case CL_MEM_SIZE: | |
| return MemInfo::Size; | |
| case CL_MEM_HOST_PTR: | |
| return MemInfo::HostPtr; | |
| case CL_MEM_MAP_COUNT: | |
| return MemInfo::MapCount; | |
| case CL_MEM_REFERENCE_COUNT: | |
| return MemInfo::ReferenceCount; | |
| case CL_MEM_CONTEXT: | |
| return MemInfo::Context; | |
| case CL_MEM_ASSOCIATED_MEMOBJECT: | |
| return MemInfo::AssociatedMemObject; | |
| case CL_MEM_OFFSET: | |
| return MemInfo::Offset; | |
| case CL_MEM_USES_SVM_POINTER: | |
| return MemInfo::UsesSVM_Pointer; | |
| case CL_MEM_PROPERTIES: | |
| return MemInfo::Properties; | |
| default: | |
| return MemInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(MemInfo from) | |
| { | |
| switch (from) | |
| { | |
| case MemInfo::Type: | |
| return CL_MEM_TYPE; | |
| case MemInfo::Flags: | |
| return CL_MEM_FLAGS; | |
| case MemInfo::Size: | |
| return CL_MEM_SIZE; | |
| case MemInfo::HostPtr: | |
| return CL_MEM_HOST_PTR; | |
| case MemInfo::MapCount: | |
| return CL_MEM_MAP_COUNT; | |
| case MemInfo::ReferenceCount: | |
| return CL_MEM_REFERENCE_COUNT; | |
| case MemInfo::Context: | |
| return CL_MEM_CONTEXT; | |
| case MemInfo::AssociatedMemObject: | |
| return CL_MEM_ASSOCIATED_MEMOBJECT; | |
| case MemInfo::Offset: | |
| return CL_MEM_OFFSET; | |
| case MemInfo::UsesSVM_Pointer: | |
| return CL_MEM_USES_SVM_POINTER; | |
| case MemInfo::Properties: | |
| return CL_MEM_PROPERTIES; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, MemInfo value) | |
| { | |
| switch (value) | |
| { | |
| case MemInfo::Type: | |
| os << "CL_MEM_TYPE"; | |
| break; | |
| case MemInfo::Flags: | |
| os << "CL_MEM_FLAGS"; | |
| break; | |
| case MemInfo::Size: | |
| os << "CL_MEM_SIZE"; | |
| break; | |
| case MemInfo::HostPtr: | |
| os << "CL_MEM_HOST_PTR"; | |
| break; | |
| case MemInfo::MapCount: | |
| os << "CL_MEM_MAP_COUNT"; | |
| break; | |
| case MemInfo::ReferenceCount: | |
| os << "CL_MEM_REFERENCE_COUNT"; | |
| break; | |
| case MemInfo::Context: | |
| os << "CL_MEM_CONTEXT"; | |
| break; | |
| case MemInfo::AssociatedMemObject: | |
| os << "CL_MEM_ASSOCIATED_MEMOBJECT"; | |
| break; | |
| case MemInfo::Offset: | |
| os << "CL_MEM_OFFSET"; | |
| break; | |
| case MemInfo::UsesSVM_Pointer: | |
| os << "CL_MEM_USES_SVM_POINTER"; | |
| break; | |
| case MemInfo::Properties: | |
| os << "CL_MEM_PROPERTIES"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| MemObjectType FromCLenum<MemObjectType>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_MEM_OBJECT_BUFFER: | |
| return MemObjectType::Buffer; | |
| case CL_MEM_OBJECT_IMAGE2D: | |
| return MemObjectType::Image2D; | |
| case CL_MEM_OBJECT_IMAGE3D: | |
| return MemObjectType::Image3D; | |
| case CL_MEM_OBJECT_IMAGE2D_ARRAY: | |
| return MemObjectType::Image2D_Array; | |
| case CL_MEM_OBJECT_IMAGE1D: | |
| return MemObjectType::Image1D; | |
| case CL_MEM_OBJECT_IMAGE1D_ARRAY: | |
| return MemObjectType::Image1D_Array; | |
| case CL_MEM_OBJECT_IMAGE1D_BUFFER: | |
| return MemObjectType::Image1D_Buffer; | |
| case CL_MEM_OBJECT_PIPE: | |
| return MemObjectType::Pipe; | |
| default: | |
| return MemObjectType::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(MemObjectType from) | |
| { | |
| switch (from) | |
| { | |
| case MemObjectType::Buffer: | |
| return CL_MEM_OBJECT_BUFFER; | |
| case MemObjectType::Image2D: | |
| return CL_MEM_OBJECT_IMAGE2D; | |
| case MemObjectType::Image3D: | |
| return CL_MEM_OBJECT_IMAGE3D; | |
| case MemObjectType::Image2D_Array: | |
| return CL_MEM_OBJECT_IMAGE2D_ARRAY; | |
| case MemObjectType::Image1D: | |
| return CL_MEM_OBJECT_IMAGE1D; | |
| case MemObjectType::Image1D_Array: | |
| return CL_MEM_OBJECT_IMAGE1D_ARRAY; | |
| case MemObjectType::Image1D_Buffer: | |
| return CL_MEM_OBJECT_IMAGE1D_BUFFER; | |
| case MemObjectType::Pipe: | |
| return CL_MEM_OBJECT_PIPE; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, MemObjectType value) | |
| { | |
| switch (value) | |
| { | |
| case MemObjectType::Buffer: | |
| os << "CL_MEM_OBJECT_BUFFER"; | |
| break; | |
| case MemObjectType::Image2D: | |
| os << "CL_MEM_OBJECT_IMAGE2D"; | |
| break; | |
| case MemObjectType::Image3D: | |
| os << "CL_MEM_OBJECT_IMAGE3D"; | |
| break; | |
| case MemObjectType::Image2D_Array: | |
| os << "CL_MEM_OBJECT_IMAGE2D_ARRAY"; | |
| break; | |
| case MemObjectType::Image1D: | |
| os << "CL_MEM_OBJECT_IMAGE1D"; | |
| break; | |
| case MemObjectType::Image1D_Array: | |
| os << "CL_MEM_OBJECT_IMAGE1D_ARRAY"; | |
| break; | |
| case MemObjectType::Image1D_Buffer: | |
| os << "CL_MEM_OBJECT_IMAGE1D_BUFFER"; | |
| break; | |
| case MemObjectType::Pipe: | |
| os << "CL_MEM_OBJECT_PIPE"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| PipeInfo FromCLenum<PipeInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_PIPE_PACKET_SIZE: | |
| return PipeInfo::PacketSize; | |
| case CL_PIPE_MAX_PACKETS: | |
| return PipeInfo::MaxPackets; | |
| case CL_PIPE_PROPERTIES: | |
| return PipeInfo::Properties; | |
| default: | |
| return PipeInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(PipeInfo from) | |
| { | |
| switch (from) | |
| { | |
| case PipeInfo::PacketSize: | |
| return CL_PIPE_PACKET_SIZE; | |
| case PipeInfo::MaxPackets: | |
| return CL_PIPE_MAX_PACKETS; | |
| case PipeInfo::Properties: | |
| return CL_PIPE_PROPERTIES; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, PipeInfo value) | |
| { | |
| switch (value) | |
| { | |
| case PipeInfo::PacketSize: | |
| os << "CL_PIPE_PACKET_SIZE"; | |
| break; | |
| case PipeInfo::MaxPackets: | |
| os << "CL_PIPE_MAX_PACKETS"; | |
| break; | |
| case PipeInfo::Properties: | |
| os << "CL_PIPE_PROPERTIES"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| PlatformInfo FromCLenum<PlatformInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_PLATFORM_PROFILE: | |
| return PlatformInfo::Profile; | |
| case CL_PLATFORM_VERSION: | |
| return PlatformInfo::Version; | |
| case CL_PLATFORM_NAME: | |
| return PlatformInfo::Name; | |
| case CL_PLATFORM_VENDOR: | |
| return PlatformInfo::Vendor; | |
| case CL_PLATFORM_EXTENSIONS: | |
| return PlatformInfo::Extensions; | |
| case CL_PLATFORM_HOST_TIMER_RESOLUTION: | |
| return PlatformInfo::HostTimerResolution; | |
| case CL_PLATFORM_NUMERIC_VERSION: | |
| return PlatformInfo::NumericVersion; | |
| case CL_PLATFORM_EXTENSIONS_WITH_VERSION: | |
| return PlatformInfo::ExtensionsWithVersion; | |
| case CL_PLATFORM_ICD_SUFFIX_KHR: | |
| return PlatformInfo::IcdSuffix; | |
| default: | |
| return PlatformInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(PlatformInfo from) | |
| { | |
| switch (from) | |
| { | |
| case PlatformInfo::Profile: | |
| return CL_PLATFORM_PROFILE; | |
| case PlatformInfo::Version: | |
| return CL_PLATFORM_VERSION; | |
| case PlatformInfo::Name: | |
| return CL_PLATFORM_NAME; | |
| case PlatformInfo::Vendor: | |
| return CL_PLATFORM_VENDOR; | |
| case PlatformInfo::Extensions: | |
| return CL_PLATFORM_EXTENSIONS; | |
| case PlatformInfo::HostTimerResolution: | |
| return CL_PLATFORM_HOST_TIMER_RESOLUTION; | |
| case PlatformInfo::NumericVersion: | |
| return CL_PLATFORM_NUMERIC_VERSION; | |
| case PlatformInfo::ExtensionsWithVersion: | |
| return CL_PLATFORM_EXTENSIONS_WITH_VERSION; | |
| case PlatformInfo::IcdSuffix: | |
| return CL_PLATFORM_ICD_SUFFIX_KHR; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, PlatformInfo value) | |
| { | |
| switch (value) | |
| { | |
| case PlatformInfo::Profile: | |
| os << "CL_PLATFORM_PROFILE"; | |
| break; | |
| case PlatformInfo::Version: | |
| os << "CL_PLATFORM_VERSION"; | |
| break; | |
| case PlatformInfo::Name: | |
| os << "CL_PLATFORM_NAME"; | |
| break; | |
| case PlatformInfo::Vendor: | |
| os << "CL_PLATFORM_VENDOR"; | |
| break; | |
| case PlatformInfo::Extensions: | |
| os << "CL_PLATFORM_EXTENSIONS"; | |
| break; | |
| case PlatformInfo::HostTimerResolution: | |
| os << "CL_PLATFORM_HOST_TIMER_RESOLUTION"; | |
| break; | |
| case PlatformInfo::NumericVersion: | |
| os << "CL_PLATFORM_NUMERIC_VERSION"; | |
| break; | |
| case PlatformInfo::ExtensionsWithVersion: | |
| os << "CL_PLATFORM_EXTENSIONS_WITH_VERSION"; | |
| break; | |
| case PlatformInfo::IcdSuffix: | |
| os << "CL_PLATFORM_ICD_SUFFIX_KHR"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| ProfilingInfo FromCLenum<ProfilingInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_PROFILING_COMMAND_QUEUED: | |
| return ProfilingInfo::CommandQueued; | |
| case CL_PROFILING_COMMAND_SUBMIT: | |
| return ProfilingInfo::CommandSubmit; | |
| case CL_PROFILING_COMMAND_START: | |
| return ProfilingInfo::CommandStart; | |
| case CL_PROFILING_COMMAND_END: | |
| return ProfilingInfo::CommandEnd; | |
| case CL_PROFILING_COMMAND_COMPLETE: | |
| return ProfilingInfo::CommandComplete; | |
| default: | |
| return ProfilingInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(ProfilingInfo from) | |
| { | |
| switch (from) | |
| { | |
| case ProfilingInfo::CommandQueued: | |
| return CL_PROFILING_COMMAND_QUEUED; | |
| case ProfilingInfo::CommandSubmit: | |
| return CL_PROFILING_COMMAND_SUBMIT; | |
| case ProfilingInfo::CommandStart: | |
| return CL_PROFILING_COMMAND_START; | |
| case ProfilingInfo::CommandEnd: | |
| return CL_PROFILING_COMMAND_END; | |
| case ProfilingInfo::CommandComplete: | |
| return CL_PROFILING_COMMAND_COMPLETE; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, ProfilingInfo value) | |
| { | |
| switch (value) | |
| { | |
| case ProfilingInfo::CommandQueued: | |
| os << "CL_PROFILING_COMMAND_QUEUED"; | |
| break; | |
| case ProfilingInfo::CommandSubmit: | |
| os << "CL_PROFILING_COMMAND_SUBMIT"; | |
| break; | |
| case ProfilingInfo::CommandStart: | |
| os << "CL_PROFILING_COMMAND_START"; | |
| break; | |
| case ProfilingInfo::CommandEnd: | |
| os << "CL_PROFILING_COMMAND_END"; | |
| break; | |
| case ProfilingInfo::CommandComplete: | |
| os << "CL_PROFILING_COMMAND_COMPLETE"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| ProgramBuildInfo FromCLenum<ProgramBuildInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_PROGRAM_BUILD_STATUS: | |
| return ProgramBuildInfo::Status; | |
| case CL_PROGRAM_BUILD_OPTIONS: | |
| return ProgramBuildInfo::Options; | |
| case CL_PROGRAM_BUILD_LOG: | |
| return ProgramBuildInfo::Log; | |
| case CL_PROGRAM_BINARY_TYPE: | |
| return ProgramBuildInfo::BinaryType; | |
| case CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE: | |
| return ProgramBuildInfo::GlobalVariableTotalSize; | |
| default: | |
| return ProgramBuildInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(ProgramBuildInfo from) | |
| { | |
| switch (from) | |
| { | |
| case ProgramBuildInfo::Status: | |
| return CL_PROGRAM_BUILD_STATUS; | |
| case ProgramBuildInfo::Options: | |
| return CL_PROGRAM_BUILD_OPTIONS; | |
| case ProgramBuildInfo::Log: | |
| return CL_PROGRAM_BUILD_LOG; | |
| case ProgramBuildInfo::BinaryType: | |
| return CL_PROGRAM_BINARY_TYPE; | |
| case ProgramBuildInfo::GlobalVariableTotalSize: | |
| return CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, ProgramBuildInfo value) | |
| { | |
| switch (value) | |
| { | |
| case ProgramBuildInfo::Status: | |
| os << "CL_PROGRAM_BUILD_STATUS"; | |
| break; | |
| case ProgramBuildInfo::Options: | |
| os << "CL_PROGRAM_BUILD_OPTIONS"; | |
| break; | |
| case ProgramBuildInfo::Log: | |
| os << "CL_PROGRAM_BUILD_LOG"; | |
| break; | |
| case ProgramBuildInfo::BinaryType: | |
| os << "CL_PROGRAM_BINARY_TYPE"; | |
| break; | |
| case ProgramBuildInfo::GlobalVariableTotalSize: | |
| os << "CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| ProgramInfo FromCLenum<ProgramInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_PROGRAM_REFERENCE_COUNT: | |
| return ProgramInfo::ReferenceCount; | |
| case CL_PROGRAM_CONTEXT: | |
| return ProgramInfo::Context; | |
| case CL_PROGRAM_NUM_DEVICES: | |
| return ProgramInfo::NumDevices; | |
| case CL_PROGRAM_DEVICES: | |
| return ProgramInfo::Devices; | |
| case CL_PROGRAM_SOURCE: | |
| return ProgramInfo::Source; | |
| case CL_PROGRAM_BINARY_SIZES: | |
| return ProgramInfo::BinarySizes; | |
| case CL_PROGRAM_BINARIES: | |
| return ProgramInfo::Binaries; | |
| case CL_PROGRAM_NUM_KERNELS: | |
| return ProgramInfo::NumKernels; | |
| case CL_PROGRAM_KERNEL_NAMES: | |
| return ProgramInfo::KernelNames; | |
| case CL_PROGRAM_IL: | |
| return ProgramInfo::IL; | |
| case CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT: | |
| return ProgramInfo::ScopeGlobalCtorsPresent; | |
| case CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT: | |
| return ProgramInfo::ScopeGlobalDtorsPresent; | |
| default: | |
| return ProgramInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(ProgramInfo from) | |
| { | |
| switch (from) | |
| { | |
| case ProgramInfo::ReferenceCount: | |
| return CL_PROGRAM_REFERENCE_COUNT; | |
| case ProgramInfo::Context: | |
| return CL_PROGRAM_CONTEXT; | |
| case ProgramInfo::NumDevices: | |
| return CL_PROGRAM_NUM_DEVICES; | |
| case ProgramInfo::Devices: | |
| return CL_PROGRAM_DEVICES; | |
| case ProgramInfo::Source: | |
| return CL_PROGRAM_SOURCE; | |
| case ProgramInfo::BinarySizes: | |
| return CL_PROGRAM_BINARY_SIZES; | |
| case ProgramInfo::Binaries: | |
| return CL_PROGRAM_BINARIES; | |
| case ProgramInfo::NumKernels: | |
| return CL_PROGRAM_NUM_KERNELS; | |
| case ProgramInfo::KernelNames: | |
| return CL_PROGRAM_KERNEL_NAMES; | |
| case ProgramInfo::IL: | |
| return CL_PROGRAM_IL; | |
| case ProgramInfo::ScopeGlobalCtorsPresent: | |
| return CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT; | |
| case ProgramInfo::ScopeGlobalDtorsPresent: | |
| return CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, ProgramInfo value) | |
| { | |
| switch (value) | |
| { | |
| case ProgramInfo::ReferenceCount: | |
| os << "CL_PROGRAM_REFERENCE_COUNT"; | |
| break; | |
| case ProgramInfo::Context: | |
| os << "CL_PROGRAM_CONTEXT"; | |
| break; | |
| case ProgramInfo::NumDevices: | |
| os << "CL_PROGRAM_NUM_DEVICES"; | |
| break; | |
| case ProgramInfo::Devices: | |
| os << "CL_PROGRAM_DEVICES"; | |
| break; | |
| case ProgramInfo::Source: | |
| os << "CL_PROGRAM_SOURCE"; | |
| break; | |
| case ProgramInfo::BinarySizes: | |
| os << "CL_PROGRAM_BINARY_SIZES"; | |
| break; | |
| case ProgramInfo::Binaries: | |
| os << "CL_PROGRAM_BINARIES"; | |
| break; | |
| case ProgramInfo::NumKernels: | |
| os << "CL_PROGRAM_NUM_KERNELS"; | |
| break; | |
| case ProgramInfo::KernelNames: | |
| os << "CL_PROGRAM_KERNEL_NAMES"; | |
| break; | |
| case ProgramInfo::IL: | |
| os << "CL_PROGRAM_IL"; | |
| break; | |
| case ProgramInfo::ScopeGlobalCtorsPresent: | |
| os << "CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT"; | |
| break; | |
| case ProgramInfo::ScopeGlobalDtorsPresent: | |
| os << "CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| template <> | |
| SamplerInfo FromCLenum<SamplerInfo>(CLenum from) | |
| { | |
| switch (from) | |
| { | |
| case CL_SAMPLER_REFERENCE_COUNT: | |
| return SamplerInfo::ReferenceCount; | |
| case CL_SAMPLER_CONTEXT: | |
| return SamplerInfo::Context; | |
| case CL_SAMPLER_NORMALIZED_COORDS: | |
| return SamplerInfo::NormalizedCoords; | |
| case CL_SAMPLER_ADDRESSING_MODE: | |
| return SamplerInfo::AddressingMode; | |
| case CL_SAMPLER_FILTER_MODE: | |
| return SamplerInfo::FilterMode; | |
| case CL_SAMPLER_PROPERTIES: | |
| return SamplerInfo::Properties; | |
| default: | |
| return SamplerInfo::InvalidEnum; | |
| } | |
| } | |
| CLenum ToCLenum(SamplerInfo from) | |
| { | |
| switch (from) | |
| { | |
| case SamplerInfo::ReferenceCount: | |
| return CL_SAMPLER_REFERENCE_COUNT; | |
| case SamplerInfo::Context: | |
| return CL_SAMPLER_CONTEXT; | |
| case SamplerInfo::NormalizedCoords: | |
| return CL_SAMPLER_NORMALIZED_COORDS; | |
| case SamplerInfo::AddressingMode: | |
| return CL_SAMPLER_ADDRESSING_MODE; | |
| case SamplerInfo::FilterMode: | |
| return CL_SAMPLER_FILTER_MODE; | |
| case SamplerInfo::Properties: | |
| return CL_SAMPLER_PROPERTIES; | |
| default: | |
| UNREACHABLE(); | |
| return 0; | |
| } | |
| } | |
| std::ostream &operator<<(std::ostream &os, SamplerInfo value) | |
| { | |
| switch (value) | |
| { | |
| case SamplerInfo::ReferenceCount: | |
| os << "CL_SAMPLER_REFERENCE_COUNT"; | |
| break; | |
| case SamplerInfo::Context: | |
| os << "CL_SAMPLER_CONTEXT"; | |
| break; | |
| case SamplerInfo::NormalizedCoords: | |
| os << "CL_SAMPLER_NORMALIZED_COORDS"; | |
| break; | |
| case SamplerInfo::AddressingMode: | |
| os << "CL_SAMPLER_ADDRESSING_MODE"; | |
| break; | |
| case SamplerInfo::FilterMode: | |
| os << "CL_SAMPLER_FILTER_MODE"; | |
| break; | |
| case SamplerInfo::Properties: | |
| os << "CL_SAMPLER_PROPERTIES"; | |
| break; | |
| default: | |
| os << "GL_INVALID_ENUM"; | |
| break; | |
| } | |
| return os; | |
| } | |
| } // namespace cl |