| // Copyright 2020 The clvk authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "log.hpp" |
| #include "config.hpp" |
| #include "queue.hpp" |
| |
| #include <cerrno> |
| #include <cstdarg> |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cstring> |
| #include <sstream> |
| #include <string> |
| #ifndef _MSC_VER |
| #include <unistd.h> |
| #endif |
| |
| #ifdef WIN32 |
| #include <io.h> |
| #endif |
| |
| #ifdef __ANDROID__ |
| #include <android/log.h> |
| #endif |
| |
| #define CASE(X) \ |
| case X: \ |
| return #X; |
| |
| static int gLoggingLevel; |
| static uint64_t gLoggingGroupMask; |
| static bool gLoggingColour; |
| static FILE* gLoggingFile; |
| |
| static uint64_t init_logging_groups() { |
| uint64_t mask = loggroup::all; |
| |
| static std::unordered_map<std::string, loggroup> groups{ |
| {"refcounting", loggroup::refcounting}, |
| {"api", loggroup::api}, |
| {"event", loggroup::event}, |
| {"validation", loggroup::validation}, |
| {"cfg", loggroup::cfg}, |
| {"none", loggroup::none}, |
| {"all", loggroup::all}, |
| }; |
| |
| if (config.log_groups.set) { |
| std::stringstream sstr(config.log_groups()); |
| bool first_group_enable_seen = false; |
| while (sstr.good()) { |
| std::string group_endis; |
| getline(sstr, group_endis, ','); |
| bool is_disable = false; |
| if (group_endis.rfind("-", 0) == 0) { |
| group_endis.erase(0, 1); |
| is_disable = true; |
| } |
| loggroup group; |
| if (groups.count(group_endis) != 0) { |
| group = groups.at(group_endis); |
| } else { |
| fprintf(stderr, "FATAL: Unknown log group '%s'.\n", |
| group_endis.c_str()); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (is_disable) { |
| mask &= ~group; |
| } else { |
| if (!first_group_enable_seen) { |
| mask = 0; |
| first_group_enable_seen = true; |
| } |
| mask |= group; |
| } |
| } |
| } |
| |
| return mask; |
| } |
| |
| void init_logging() { |
| loglevel setting = static_cast<loglevel>(config.log()); |
| if (config.log.set) { |
| if ((config.log < loglevel::fatal) || (config.log > loglevel::debug)) { |
| // FIXME handle all errors |
| fprintf(stderr, "FATAL: Unknown log level '%u'.\n", config.log()); |
| exit(EXIT_FAILURE); |
| } |
| setting = static_cast<loglevel>(config.log()); |
| } |
| gLoggingLevel = setting; |
| |
| gLoggingGroupMask = init_logging_groups(); |
| |
| if (config.log_dest.set) { |
| |
| std::string val(config.log_dest); |
| |
| if (val == "stdout") { |
| gLoggingFile = stdout; |
| } else if (val == "stderr") { |
| gLoggingFile = stderr; |
| } else if (val.rfind("file:", 0) == 0) { |
| |
| val.erase(0, strlen("file:")); |
| |
| gLoggingFile = fopen(val.c_str(), "w+"); |
| |
| if (gLoggingFile == nullptr) { |
| fprintf(stderr, "FATAL: Could not open log file '%s': %s.\n", |
| val.c_str(), strerror(errno)); |
| exit(EXIT_FAILURE); |
| } |
| } else { |
| fprintf(stderr, "FATAL: Unknown log destination '%s'.\n", |
| val.c_str()); |
| exit(EXIT_FAILURE); |
| } |
| } else { |
| gLoggingFile = stderr; |
| } |
| |
| bool isTTY = isatty(fileno(gLoggingFile)); |
| if (isTTY) { |
| gLoggingColour = true; |
| } else { |
| gLoggingColour = false; |
| } |
| |
| if (config.log_colour.set) { |
| gLoggingColour = config.log_colour; |
| } |
| } |
| |
| void term_logging() { |
| if ((gLoggingFile != stdout) && (gLoggingFile != stderr)) { |
| fclose(gLoggingFile); |
| } |
| } |
| |
| bool cvk_log_level_enabled(loglevel level) { return gLoggingLevel >= level; } |
| bool cvk_log_group_enabled(uint64_t group_mask) { |
| return gLoggingGroupMask & group_mask; |
| } |
| |
| #ifdef __ANDROID__ |
| |
| void cvk_log_android(loglevel level, const char* fmt, va_list& args) { |
| static int loglevel_to_android[] = { |
| [loglevel::fatal] = android_LogPriority::ANDROID_LOG_FATAL, |
| [loglevel::error] = android_LogPriority::ANDROID_LOG_ERROR, |
| [loglevel::warn] = android_LogPriority::ANDROID_LOG_WARN, |
| [loglevel::info] = android_LogPriority::ANDROID_LOG_INFO, |
| [loglevel::debug] = android_LogPriority::ANDROID_LOG_DEBUG, |
| }; |
| int prio; |
| if (level < 0 || level >= ARRAY_SIZE(loglevel_to_android)) { |
| prio = android_LogPriority::ANDROID_LOG_VERBOSE; |
| } else { |
| prio = loglevel_to_android[level]; |
| } |
| __android_log_vprint(prio, "CLVK", fmt, args); |
| } |
| |
| #endif |
| |
| static const char colourRed[] = "\e[0;31m"; |
| static const char colourYellow[] = "\e[0;33m"; |
| static const char colourReset[] = "\e[0m"; |
| |
| void cvk_log_default(loglevel level, const char* fmt, va_list& args) { |
| const char* colourCode = nullptr; |
| |
| if (gLoggingColour) { |
| |
| switch (level) { |
| case loglevel::fatal: |
| case loglevel::error: |
| colourCode = colourRed; |
| break; |
| case loglevel::warn: |
| colourCode = colourYellow; |
| break; |
| case loglevel::info: |
| case loglevel::debug: |
| break; |
| } |
| |
| if (colourCode != nullptr) { |
| fprintf(gLoggingFile, "%s", colourCode); |
| } |
| } |
| |
| fprintf(gLoggingFile, "[CLVK] "); |
| |
| vfprintf(gLoggingFile, fmt, args); |
| |
| if ((gLoggingColour) && (colourCode != nullptr)) { |
| fprintf(gLoggingFile, "%s", colourReset); |
| } |
| |
| // Force to flush error and fatal logs |
| if (level <= loglevel::error) { |
| fflush(gLoggingFile); |
| } |
| } |
| |
| void cvk_log(uint64_t group_mask, loglevel level, const char* fmt, ...) { |
| |
| if (!cvk_log_level_enabled(level)) { |
| return; |
| } |
| |
| if (!cvk_log_group_enabled(group_mask) && |
| (level > loglevel::warn || config.log_groups_only)) { |
| return; |
| } |
| |
| va_list args; |
| va_start(args, fmt); |
| #ifdef __ANDROID__ |
| if (gLoggingFile == stdout || gLoggingFile == stderr) { |
| cvk_log_android(level, fmt, args); |
| } else { |
| cvk_log_default(level, fmt, args); |
| } |
| #else |
| cvk_log_default(level, fmt, args); |
| #endif |
| va_end(args); |
| |
| if (level == loglevel::fatal) { |
| exit(EXIT_FAILURE); |
| } |
| } |
| |
| std::string pretty_size(uint64_t size) { |
| std::string ret; |
| |
| static const char* units[] = {" B", "kB", "MB", "GB", "TB"}; |
| int unit = 0; |
| float fsize = size; |
| while (fsize > 1024) { |
| unit++; |
| fsize /= 1024; |
| } |
| |
| ret = std::to_string(fsize) + " " + units[unit]; |
| |
| return ret; |
| } |
| |
| const char* vulkan_error_string(VkResult result) { |
| switch (result) { |
| CASE(VK_SUCCESS) |
| CASE(VK_NOT_READY) |
| CASE(VK_TIMEOUT) |
| CASE(VK_EVENT_SET) |
| CASE(VK_EVENT_RESET) |
| CASE(VK_INCOMPLETE) |
| CASE(VK_ERROR_OUT_OF_HOST_MEMORY) |
| CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY) |
| CASE(VK_ERROR_INITIALIZATION_FAILED) |
| CASE(VK_ERROR_DEVICE_LOST) |
| CASE(VK_ERROR_MEMORY_MAP_FAILED) |
| CASE(VK_ERROR_LAYER_NOT_PRESENT) |
| CASE(VK_ERROR_EXTENSION_NOT_PRESENT) |
| CASE(VK_ERROR_FEATURE_NOT_PRESENT) |
| CASE(VK_ERROR_INCOMPATIBLE_DRIVER) |
| CASE(VK_ERROR_TOO_MANY_OBJECTS) |
| CASE(VK_ERROR_FORMAT_NOT_SUPPORTED) |
| CASE(VK_ERROR_FRAGMENTED_POOL) |
| CASE(VK_ERROR_SURFACE_LOST_KHR) |
| CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR) |
| CASE(VK_SUBOPTIMAL_KHR) |
| CASE(VK_ERROR_OUT_OF_DATE_KHR) |
| CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR) |
| CASE(VK_ERROR_VALIDATION_FAILED_EXT) |
| CASE(VK_ERROR_INVALID_SHADER_NV) |
| CASE(VK_ERROR_INVALID_EXTERNAL_HANDLE) |
| CASE(VK_ERROR_FRAGMENTATION_EXT) |
| CASE(VK_ERROR_NOT_PERMITTED_EXT) |
| CASE(VK_ERROR_OUT_OF_POOL_MEMORY_KHR) |
| default: |
| return "Unknown vulkan error"; |
| } |
| } |
| |
| std::string vulkan_memory_property_flags_string(VkMemoryPropertyFlags flags) { |
| std::string str; |
| |
| if (flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) { |
| str += "HOST_VISIBLE "; |
| } |
| |
| if (flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) { |
| str += "HOST_COHERENT "; |
| } |
| |
| if (flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) { |
| str += "HOST_CACHED "; |
| } |
| |
| if (flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { |
| str += "DEVICE_LOCAL "; |
| } |
| |
| if (flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) { |
| str += "LAZILY_ALLOCATED "; |
| } |
| |
| return str; |
| } |
| |
| std::string vulkan_queue_flags_string(VkQueueFlags flags) { |
| std::string str; |
| |
| if (flags & VK_QUEUE_GRAPHICS_BIT) { |
| str += "GRAPHICS "; |
| } |
| |
| if (flags & VK_QUEUE_COMPUTE_BIT) { |
| str += "COMPUTE "; |
| } |
| |
| if (flags & VK_QUEUE_TRANSFER_BIT) { |
| str += "TRANSFER "; |
| } |
| |
| if (flags & VK_QUEUE_SPARSE_BINDING_BIT) { |
| str += "SPARSE_BINDING "; |
| } |
| |
| return str; |
| } |
| |
| std::string vulkan_physical_device_type_string(VkPhysicalDeviceType type) { |
| switch (type) { |
| case VK_PHYSICAL_DEVICE_TYPE_OTHER: |
| return "Other"; |
| case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: |
| return "Integrated GPU"; |
| case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: |
| return "Discrete GPU"; |
| case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: |
| return "Virtual GPU"; |
| case VK_PHYSICAL_DEVICE_TYPE_CPU: |
| return "CPU"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| std::string vulkan_calibrateable_time_domain_string(VkTimeDomainEXT td) { |
| switch (td) { |
| case VK_TIME_DOMAIN_DEVICE_EXT: |
| return "Device"; |
| case VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT: |
| return "Clock monotonic"; |
| case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT: |
| return "Clock monotonic raw"; |
| case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT: |
| return "Query performance counter"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| std::string vulkan_format_features_string(VkFormatFeatureFlags flags) { |
| std::string str; |
| |
| if (flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) { |
| str += "SAMPLED_IMAGE "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) { |
| str += "STORAGE_IMAGE "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT) { |
| str += "STORAGE_IMAGE_ATOMIC "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT) { |
| str += "UNIFORM_TEXEL_BUFFER "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT) { |
| str += "STORAGE_TEXEL_BUFFER "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT) { |
| str += "STORAGE_TEXEL_BUFFER_ATOMIC "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) { |
| str += "SAMPLED_IMAGE_FILTER_LINEAR "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) { |
| str += "TRANSFER_SRC "; |
| } |
| |
| if (flags & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) { |
| str += "TRANSFER_DST "; |
| } |
| |
| return str; |
| } |
| |
| std::string vulkan_vendor_id_string(VkVendorId vid) { |
| switch (vid) { |
| case VK_VENDOR_ID_VIV: |
| return "Vivante"; |
| case VK_VENDOR_ID_VSI: |
| return "VeriSilicon"; |
| case VK_VENDOR_ID_KAZAN: |
| return "Kazan Software Renderer"; |
| case VK_VENDOR_ID_CODEPLAY: |
| return "Codeplay Software Ltd."; |
| case VK_VENDOR_ID_MESA: |
| return "Mesa"; |
| #ifdef VK_VENDOR_ID_POCL |
| case VK_VENDOR_ID_POCL: |
| return "PoCL"; |
| #endif |
| #ifdef VK_VENDOR_ID_MOBILEYE |
| case VK_VENDOR_ID_MOBILEYE: |
| return "Mobileye"; |
| #endif |
| default: |
| return "Unknown Khronos Vendor ID"; |
| } |
| } |
| |
| std::string cl_channel_order_to_string(cl_channel_order order) { |
| switch (order) { |
| CASE(CL_R) |
| CASE(CL_A) |
| CASE(CL_DEPTH) |
| CASE(CL_LUMINANCE) |
| CASE(CL_INTENSITY) |
| CASE(CL_RG) |
| CASE(CL_RA) |
| CASE(CL_Rx) |
| CASE(CL_RGB) |
| CASE(CL_RGx) |
| CASE(CL_RGBA) |
| CASE(CL_ARGB) |
| CASE(CL_BGRA) |
| CASE(CL_ABGR) |
| CASE(CL_RGBx) |
| CASE(CL_sRGB) |
| CASE(CL_sRGBA) |
| CASE(CL_sBGRA) |
| CASE(CL_sRGBx) |
| } |
| return "Unknown channel order"; |
| } |
| |
| std::string cl_channel_type_to_string(cl_channel_type type) { |
| switch (type) { |
| CASE(CL_SNORM_INT8) |
| CASE(CL_SNORM_INT16) |
| CASE(CL_UNORM_INT8) |
| CASE(CL_UNORM_INT16) |
| CASE(CL_UNORM_SHORT_565) |
| CASE(CL_UNORM_SHORT_555) |
| CASE(CL_UNORM_INT_101010) |
| CASE(CL_UNORM_INT_101010_2) |
| CASE(CL_SIGNED_INT8) |
| CASE(CL_SIGNED_INT16) |
| CASE(CL_SIGNED_INT32) |
| CASE(CL_UNSIGNED_INT8) |
| CASE(CL_UNSIGNED_INT16) |
| CASE(CL_UNSIGNED_INT32) |
| CASE(CL_HALF_FLOAT) |
| CASE(CL_FLOAT) |
| } |
| return "Unknown channel type"; |
| } |
| |
| const char* cl_command_type_to_string(cl_command_type type) { |
| switch (type) { |
| CASE(CL_COMMAND_NDRANGE_KERNEL); |
| CASE(CL_COMMAND_TASK); |
| CASE(CL_COMMAND_NATIVE_KERNEL); |
| CASE(CL_COMMAND_READ_BUFFER); |
| CASE(CL_COMMAND_WRITE_BUFFER); |
| CASE(CL_COMMAND_COPY_BUFFER); |
| CASE(CL_COMMAND_READ_IMAGE); |
| CASE(CL_COMMAND_WRITE_IMAGE); |
| CASE(CL_COMMAND_COPY_IMAGE); |
| CASE(CL_COMMAND_COPY_BUFFER_TO_IMAGE); |
| CASE(CL_COMMAND_COPY_IMAGE_TO_BUFFER); |
| CASE(CL_COMMAND_MAP_BUFFER); |
| CASE(CL_COMMAND_MAP_IMAGE); |
| CASE(CL_COMMAND_UNMAP_MEM_OBJECT); |
| CASE(CL_COMMAND_MARKER); |
| CASE(CL_COMMAND_ACQUIRE_GL_OBJECTS); |
| CASE(CL_COMMAND_RELEASE_GL_OBJECTS); |
| CASE(CL_COMMAND_SEMAPHORE_WAIT_KHR); |
| CASE(CL_COMMAND_SEMAPHORE_SIGNAL_KHR); |
| CASE(CLVK_COMMAND_BATCH); |
| CASE(CLVK_COMMAND_IMAGE_INIT); |
| default: |
| return "CL_COMMAND_UNKNOWN"; |
| } |
| } |
| |
| const char* cl_device_type_to_string(cl_device_type type) { |
| switch (type) { |
| CASE(CL_DEVICE_TYPE_CPU); |
| CASE(CL_DEVICE_TYPE_GPU); |
| CASE(CL_DEVICE_TYPE_ACCELERATOR); |
| CASE(CL_DEVICE_TYPE_CUSTOM); |
| CASE(CL_DEVICE_TYPE_DEFAULT); |
| CASE(CL_DEVICE_TYPE_ALL); |
| default: |
| return "CL_DEVICE_TYPE_UNKNOWN"; |
| } |
| } |
| |
| const char* cl_command_execution_status_to_string(cl_int status) { |
| switch (status) { |
| CASE(CL_COMPLETE); |
| CASE(CL_RUNNING); |
| CASE(CL_SUBMITTED); |
| CASE(CL_QUEUED); |
| default: |
| return "CL_COMMAND_EXECUTION_STATUS_UNKNOWN"; |
| } |
| } |
| |
| const char* spirv_capability_to_string(spv::Capability capability) { |
| switch (capability) { |
| CASE(spv::CapabilityMatrix); |
| CASE(spv::CapabilityShader); |
| CASE(spv::CapabilityGeometry); |
| CASE(spv::CapabilityTessellation); |
| CASE(spv::CapabilityAddresses); |
| CASE(spv::CapabilityLinkage); |
| CASE(spv::CapabilityKernel); |
| CASE(spv::CapabilityVector16); |
| CASE(spv::CapabilityFloat16Buffer); |
| CASE(spv::CapabilityFloat16); |
| CASE(spv::CapabilityFloat64); |
| CASE(spv::CapabilityInt64); |
| CASE(spv::CapabilityInt64Atomics); |
| CASE(spv::CapabilityImageBasic); |
| CASE(spv::CapabilityImageReadWrite); |
| CASE(spv::CapabilityImageMipmap); |
| CASE(spv::CapabilityPipes); |
| CASE(spv::CapabilityGroups); |
| CASE(spv::CapabilityDeviceEnqueue); |
| CASE(spv::CapabilityLiteralSampler); |
| CASE(spv::CapabilityAtomicStorage); |
| CASE(spv::CapabilityInt16); |
| CASE(spv::CapabilityTessellationPointSize); |
| CASE(spv::CapabilityGeometryPointSize); |
| CASE(spv::CapabilityImageGatherExtended); |
| CASE(spv::CapabilityStorageImageMultisample); |
| CASE(spv::CapabilityUniformBufferArrayDynamicIndexing); |
| CASE(spv::CapabilitySampledImageArrayDynamicIndexing); |
| CASE(spv::CapabilityStorageBufferArrayDynamicIndexing); |
| CASE(spv::CapabilityStorageImageArrayDynamicIndexing); |
| CASE(spv::CapabilityClipDistance); |
| CASE(spv::CapabilityCullDistance); |
| CASE(spv::CapabilityImageCubeArray); |
| CASE(spv::CapabilitySampleRateShading); |
| CASE(spv::CapabilityImageRect); |
| CASE(spv::CapabilitySampledRect); |
| CASE(spv::CapabilityGenericPointer); |
| CASE(spv::CapabilityInt8); |
| CASE(spv::CapabilityInputAttachment); |
| CASE(spv::CapabilitySparseResidency); |
| CASE(spv::CapabilityMinLod); |
| CASE(spv::CapabilitySampled1D); |
| CASE(spv::CapabilityImage1D); |
| CASE(spv::CapabilitySampledCubeArray); |
| CASE(spv::CapabilitySampledBuffer); |
| CASE(spv::CapabilityImageBuffer); |
| CASE(spv::CapabilityImageMSArray); |
| CASE(spv::CapabilityStorageImageExtendedFormats); |
| CASE(spv::CapabilityImageQuery); |
| CASE(spv::CapabilityDerivativeControl); |
| CASE(spv::CapabilityInterpolationFunction); |
| CASE(spv::CapabilityTransformFeedback); |
| CASE(spv::CapabilityGeometryStreams); |
| CASE(spv::CapabilityStorageImageReadWithoutFormat); |
| CASE(spv::CapabilityStorageImageWriteWithoutFormat); |
| CASE(spv::CapabilityMultiViewport); |
| CASE(spv::CapabilitySubgroupDispatch); |
| CASE(spv::CapabilityNamedBarrier); |
| CASE(spv::CapabilityPipeStorage); |
| CASE(spv::CapabilityGroupNonUniform); |
| CASE(spv::CapabilityGroupNonUniformVote); |
| CASE(spv::CapabilityGroupNonUniformArithmetic); |
| CASE(spv::CapabilityGroupNonUniformBallot); |
| CASE(spv::CapabilityGroupNonUniformShuffle); |
| CASE(spv::CapabilityGroupNonUniformShuffleRelative); |
| CASE(spv::CapabilityGroupNonUniformClustered); |
| CASE(spv::CapabilityGroupNonUniformQuad); |
| CASE(spv::CapabilityShaderLayer); |
| CASE(spv::CapabilityShaderViewportIndex); |
| CASE(spv::CapabilityUniformDecoration); |
| CASE(spv::CapabilityCoreBuiltinsARM); |
| CASE(spv::CapabilityFragmentShadingRateKHR); |
| CASE(spv::CapabilitySubgroupBallotKHR); |
| CASE(spv::CapabilityDrawParameters); |
| CASE(spv::CapabilityWorkgroupMemoryExplicitLayoutKHR); |
| CASE(spv::CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR); |
| CASE(spv::CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR); |
| CASE(spv::CapabilitySubgroupVoteKHR); |
| CASE(spv::CapabilityStorageBuffer16BitAccess); |
| CASE(spv::CapabilityStorageUniform16); |
| CASE(spv::CapabilityStoragePushConstant16); |
| CASE(spv::CapabilityStorageInputOutput16); |
| CASE(spv::CapabilityDeviceGroup); |
| CASE(spv::CapabilityMultiView); |
| CASE(spv::CapabilityVariablePointersStorageBuffer); |
| CASE(spv::CapabilityVariablePointers); |
| CASE(spv::CapabilityAtomicStorageOps); |
| CASE(spv::CapabilitySampleMaskPostDepthCoverage); |
| CASE(spv::CapabilityStorageBuffer8BitAccess); |
| CASE(spv::CapabilityUniformAndStorageBuffer8BitAccess); |
| CASE(spv::CapabilityStoragePushConstant8); |
| CASE(spv::CapabilityDenormPreserve); |
| CASE(spv::CapabilityDenormFlushToZero); |
| CASE(spv::CapabilitySignedZeroInfNanPreserve); |
| CASE(spv::CapabilityRoundingModeRTE); |
| CASE(spv::CapabilityRoundingModeRTZ); |
| CASE(spv::CapabilityRayQueryProvisionalKHR); |
| CASE(spv::CapabilityRayQueryKHR); |
| CASE(spv::CapabilityRayTraversalPrimitiveCullingKHR); |
| CASE(spv::CapabilityRayTracingKHR); |
| CASE(spv::CapabilityTextureSampleWeightedQCOM); |
| CASE(spv::CapabilityTextureBoxFilterQCOM); |
| CASE(spv::CapabilityTextureBlockMatchQCOM); |
| CASE(spv::CapabilityFloat16ImageAMD); |
| CASE(spv::CapabilityImageGatherBiasLodAMD); |
| CASE(spv::CapabilityFragmentMaskAMD); |
| CASE(spv::CapabilityStencilExportEXT); |
| CASE(spv::CapabilityImageReadWriteLodAMD); |
| CASE(spv::CapabilityInt64ImageEXT); |
| CASE(spv::CapabilityShaderClockKHR); |
| CASE(spv::CapabilitySampleMaskOverrideCoverageNV); |
| CASE(spv::CapabilityGeometryShaderPassthroughNV); |
| CASE(spv::CapabilityShaderViewportIndexLayerEXT); |
| CASE(spv::CapabilityShaderViewportMaskNV); |
| CASE(spv::CapabilityShaderStereoViewNV); |
| CASE(spv::CapabilityPerViewAttributesNV); |
| CASE(spv::CapabilityFragmentFullyCoveredEXT); |
| CASE(spv::CapabilityMeshShadingNV); |
| CASE(spv::CapabilityImageFootprintNV); |
| CASE(spv::CapabilityMeshShadingEXT); |
| CASE(spv::CapabilityFragmentBarycentricKHR); |
| CASE(spv::CapabilityComputeDerivativeGroupQuadsNV); |
| CASE(spv::CapabilityFragmentDensityEXT); |
| CASE(spv::CapabilityGroupNonUniformPartitionedNV); |
| CASE(spv::CapabilityShaderNonUniform); |
| CASE(spv::CapabilityRuntimeDescriptorArray); |
| CASE(spv::CapabilityInputAttachmentArrayDynamicIndexing); |
| CASE(spv::CapabilityUniformTexelBufferArrayDynamicIndexing); |
| CASE(spv::CapabilityStorageTexelBufferArrayDynamicIndexing); |
| CASE(spv::CapabilityUniformBufferArrayNonUniformIndexing); |
| CASE(spv::CapabilitySampledImageArrayNonUniformIndexing); |
| CASE(spv::CapabilityStorageBufferArrayNonUniformIndexing); |
| CASE(spv::CapabilityStorageImageArrayNonUniformIndexing); |
| CASE(spv::CapabilityInputAttachmentArrayNonUniformIndexing); |
| CASE(spv::CapabilityUniformTexelBufferArrayNonUniformIndexing); |
| CASE(spv::CapabilityStorageTexelBufferArrayNonUniformIndexing); |
| CASE(spv::CapabilityRayTracingNV); |
| CASE(spv::CapabilityRayTracingMotionBlurNV); |
| CASE(spv::CapabilityVulkanMemoryModel); |
| CASE(spv::CapabilityVulkanMemoryModelDeviceScope); |
| CASE(spv::CapabilityPhysicalStorageBufferAddresses); |
| CASE(spv::CapabilityComputeDerivativeGroupLinearNV); |
| CASE(spv::CapabilityRayTracingProvisionalKHR); |
| CASE(spv::CapabilityCooperativeMatrixNV); |
| CASE(spv::CapabilityFragmentShaderSampleInterlockEXT); |
| CASE(spv::CapabilityFragmentShaderShadingRateInterlockEXT); |
| CASE(spv::CapabilityShaderSMBuiltinsNV); |
| CASE(spv::CapabilityFragmentShaderPixelInterlockEXT); |
| CASE(spv::CapabilityDemoteToHelperInvocation); |
| CASE(spv::CapabilityRayTracingOpacityMicromapEXT); |
| CASE(spv::CapabilityShaderInvocationReorderNV); |
| CASE(spv::CapabilityBindlessTextureNV); |
| CASE(spv::CapabilitySubgroupShuffleINTEL); |
| CASE(spv::CapabilitySubgroupBufferBlockIOINTEL); |
| CASE(spv::CapabilitySubgroupImageBlockIOINTEL); |
| CASE(spv::CapabilitySubgroupImageMediaBlockIOINTEL); |
| CASE(spv::CapabilityRoundToInfinityINTEL); |
| CASE(spv::CapabilityFloatingPointModeINTEL); |
| CASE(spv::CapabilityIntegerFunctions2INTEL); |
| CASE(spv::CapabilityFunctionPointersINTEL); |
| CASE(spv::CapabilityIndirectReferencesINTEL); |
| CASE(spv::CapabilityAsmINTEL); |
| CASE(spv::CapabilityAtomicFloat32MinMaxEXT); |
| CASE(spv::CapabilityAtomicFloat64MinMaxEXT); |
| CASE(spv::CapabilityAtomicFloat16MinMaxEXT); |
| CASE(spv::CapabilityVectorComputeINTEL); |
| CASE(spv::CapabilityVectorAnyINTEL); |
| CASE(spv::CapabilityExpectAssumeKHR); |
| CASE(spv::CapabilitySubgroupAvcMotionEstimationINTEL); |
| CASE(spv::CapabilitySubgroupAvcMotionEstimationIntraINTEL); |
| CASE(spv::CapabilitySubgroupAvcMotionEstimationChromaINTEL); |
| CASE(spv::CapabilityVariableLengthArrayINTEL); |
| CASE(spv::CapabilityFunctionFloatControlINTEL); |
| CASE(spv::CapabilityFPGAMemoryAttributesINTEL); |
| CASE(spv::CapabilityFPFastMathModeINTEL); |
| CASE(spv::CapabilityArbitraryPrecisionIntegersINTEL); |
| CASE(spv::CapabilityArbitraryPrecisionFloatingPointINTEL); |
| CASE(spv::CapabilityUnstructuredLoopControlsINTEL); |
| CASE(spv::CapabilityFPGALoopControlsINTEL); |
| CASE(spv::CapabilityKernelAttributesINTEL); |
| CASE(spv::CapabilityFPGAKernelAttributesINTEL); |
| CASE(spv::CapabilityFPGAMemoryAccessesINTEL); |
| CASE(spv::CapabilityFPGAClusterAttributesINTEL); |
| CASE(spv::CapabilityLoopFuseINTEL); |
| CASE(spv::CapabilityFPGADSPControlINTEL); |
| CASE(spv::CapabilityMemoryAccessAliasingINTEL); |
| CASE(spv::CapabilityFPGAInvocationPipeliningAttributesINTEL); |
| CASE(spv::CapabilityFPGABufferLocationINTEL); |
| CASE(spv::CapabilityArbitraryPrecisionFixedPointINTEL); |
| CASE(spv::CapabilityUSMStorageClassesINTEL); |
| CASE(spv::CapabilityRuntimeAlignedAttributeINTEL); |
| CASE(spv::CapabilityIOPipesINTEL); |
| CASE(spv::CapabilityBlockingPipesINTEL); |
| CASE(spv::CapabilityFPGARegINTEL); |
| CASE(spv::CapabilityDotProductInputAll); |
| CASE(spv::CapabilityDotProductInput4x8Bit); |
| CASE(spv::CapabilityDotProductInput4x8BitPacked); |
| CASE(spv::CapabilityDotProduct); |
| CASE(spv::CapabilityRayCullMaskKHR); |
| CASE(spv::CapabilityBitInstructions); |
| CASE(spv::CapabilityGroupNonUniformRotateKHR); |
| CASE(spv::CapabilityAtomicFloat32AddEXT); |
| CASE(spv::CapabilityAtomicFloat64AddEXT); |
| CASE(spv::CapabilityLongCompositesINTEL); |
| CASE(spv::CapabilityOptNoneINTEL); |
| CASE(spv::CapabilityAtomicFloat16AddEXT); |
| CASE(spv::CapabilityDebugInfoModuleINTEL); |
| CASE(spv::CapabilityBFloat16ConversionINTEL); |
| CASE(spv::CapabilitySplitBarrierINTEL); |
| CASE(spv::CapabilityFPGAKernelAttributesv2INTEL); |
| CASE(spv::CapabilityFPGALatencyControlINTEL); |
| CASE(spv::CapabilityFPGAArgumentInterfacesINTEL); |
| CASE(spv::CapabilityGroupUniformArithmeticKHR); |
| CASE(spv::CapabilityMax); |
| default: |
| return "unknown SPIRV Capability"; |
| } |
| } |
| |
| const char* queue_global_priority_to_string(VkQueueGlobalPriorityKHR priority) { |
| switch (priority) { |
| CASE(VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR); |
| CASE(VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR); |
| CASE(VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR); |
| CASE(VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR); |
| default: |
| return "VK_QUEUE_GLOBAL_PRIORITY_UNKNOWN"; |
| } |
| } |
