Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package clinfo for openSUSE:Factory checked in at 2026-09-29 17:48:49 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/clinfo (Old) and /work/SRC/openSUSE:Factory/.clinfo.new.383539 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "clinfo" Tue Sep 29 17:48:49 2026 rev:14 rq:1381152 version:3.1.26.09.26 Changes: -------- --- /work/SRC/openSUSE:Factory/clinfo/clinfo.changes 2025-05-03 21:02:08.041588434 +0200 +++ /work/SRC/openSUSE:Factory/.clinfo.new.383539/clinfo.changes 2026-09-29 17:49:45.754161052 +0200 @@ -1,0 +2,7 @@ +Sun Sep 27 08:44:18 UTC 2026 - Martin Hauke <[email protected]> + +- Update to version 3.1.26.09.26: + * No upstream release notes. +- Run spec-cleaner. + +------------------------------------------------------------------- Old: ---- clinfo-3.0.25.02.14.tar.gz New: ---- clinfo-3.1.26.09.26.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ clinfo.spec ++++++ --- /var/tmp/diff_new_pack.bfBCUW/_old 2026-09-29 17:49:46.465190782 +0200 +++ /var/tmp/diff_new_pack.bfBCUW/_new 2026-09-29 17:49:46.466190823 +0200 @@ -1,8 +1,8 @@ # # spec file for package clinfo # -# Copyright (c) 2025 SUSE LLC -# Copyright (c) 2015-2023, Martin Hauke <[email protected]> +# Copyright (c) 2026 SUSE LLC and contributors +# Copyright (c) 2015-2026, Martin Hauke <[email protected]> # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -18,10 +18,10 @@ Name: clinfo -Version: 3.0.25.02.14 +Version: 3.1.26.09.26 Release: 0 Summary: Utility that reports status information for all installed OpenCL ICDs -License: SUSE-Public-Domain +License: LicenseRef-SUSE-Public-Domain Group: Productivity/Other URL: https://github.com/Oblomov/clinfo/ Source: https://github.com/Oblomov/%{name}/archive/%{version}.tar.gz#/%{name}-%{version}.tar.gz @@ -38,7 +38,7 @@ platforms). %prep -%setup -q +%autosetup %build export CFLAGS="%{optflags}" @@ -48,8 +48,8 @@ %make_install DESTDIR=%{buildroot} BINDIR=%{_bindir} MAN1DIR=%{_mandir}/man1 %files -%doc README.md %license LICENSE +%doc README.md %{_bindir}/clinfo %{_mandir}/man1/clinfo.1%{?ext_man} ++++++ clinfo-3.0.25.02.14.tar.gz -> clinfo-3.1.26.09.26.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/Makefile new/clinfo-3.1.26.09.26/Makefile --- old/clinfo-3.0.25.02.14/Makefile 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/Makefile 2026-09-26 11:29:37.000000000 +0200 @@ -22,6 +22,7 @@ HDR = src/error.h \ src/ext.h \ + src/spv-capabilities.h \ src/ctx_prop.h \ src/fmtmacros.h \ src/memory.h \ @@ -67,6 +68,7 @@ # OS-specific library includes LDLIBS_Darwin = -framework OpenCL LDLIBS_Darwin_exclude = -lOpenCL +LDLIBS_Windows_NT_exclude = -ldl LDLIBS += $(LDLIBS_${OS}) $(LDLIBS__common:$(LDLIBS_${OS}_exclude)=) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/Makefile.win new/clinfo-3.1.26.09.26/Makefile.win --- old/clinfo-3.0.25.02.14/Makefile.win 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/Makefile.win 2026-09-26 11:29:37.000000000 +0200 @@ -33,6 +33,8 @@ # switching !IF "$(PROCESSOR_ARCHITECTURE)" == "AMD64" ARCH=64 +!ELSE IF "$(PROCESSOR_ARCHITECTURE)" == "ARM64" +ARCH=ARM64 !ELSE ARCH=32 !ENDIF @@ -42,16 +44,21 @@ ARCH=64 !ELSE IF "$(PLATFORM)" == "x86" || "$(PLATFORM)" == "X86" ARCH=32 +!ELSE IF "$(PLATFORM)" == "arm64" || "$(PLATFORM)" == "ARM64" +ARCH=ARM64 !ENDIF -!MESSAGE Building for $(ARCH)-bit (processor architecture: $(PROCESSOR_ARCHITECTURE), platform: $(PLATFORM)) +!MESSAGE Building for $(ARCH) (processor architecture: $(PROCESSOR_ARCHITECTURE), platform: $(PLATFORM)) LIBPATH32 = /LIBPATH:"$(OPENCLDIR)\lib" /LIBPATH:"$(OPENCLDIR)\lib\x86" LIBPATH64 = /LIBPATH:"$(OPENCLDIR)\lib\x64" /LIBPATH:"$(OPENCLDIR)\lib\x86_64" /LIBPATH:"$(OPENCLDIR)\lib\x86_amd64" +LIBPATHARM64 = /LIBPATH:"$(OPENCLDIR)\lib\arm64" /LIBPATH:"$(OPENCLDIR)\lib\aarch64" # And since we can't do $(LIBPATH$(ARCH)) with nmake ... !IF "$(ARCH)" == "64" LINKOPTS = /LTCG $(LIBPATH64) /nologo +!ELSE IF "$(ARCH)" == "ARM64" +LINKOPTS = /LTCG $(LIBPATHARM64) /nologo !ELSE LINKOPTS = /LTCG $(LIBPATH32) /nologo !ENDIF diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/README.md new/clinfo-3.1.26.09.26/README.md --- old/clinfo-3.0.25.02.14/README.md 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/README.md 2026-09-26 11:29:37.000000000 +0200 @@ -152,3 +152,17 @@ <td><a href='https://ci.appveyor.com/api/projects/oblomov/clinfo/artifacts/clinfo.exe?job=platform%3a+x64'>64-bit</a></td> </tr> </table> + +`clinfo` is also packaged and distributed on [MSYS2](https://www.msys2.org/). + +Install for Windows x64 using: + +```sh +pacman -Sy mingw-w64-ucrt-x86_64-clinfo +``` + +Or install for Windows ARM64 using: + +```sh +pacman -Sy mingw-w64-clang-aarch64-clinfo +``` diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/man1/clinfo.1 new/clinfo-3.1.26.09.26/man1/clinfo.1 --- old/clinfo-3.0.25.02.14/man1/clinfo.1 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/man1/clinfo.1 2026-09-26 11:29:37.000000000 +0200 @@ -1,4 +1,4 @@ -.TH CLINFO 1 "2025-02-14" "clinfo 3.0.25.02.14" +.TH CLINFO 1 "2026-09-26" "clinfo 3.1.26.09.26" .SH NAME @@ -83,12 +83,15 @@ .SH CONFORMING TO -OpenCL 1.1, OpenCL 1.2, OpenCL 2.0, OpenCL 2.1, OpenCL 2.2, OpenCL 3.0. +OpenCL 1.1, OpenCL 1.2, OpenCL 2.0, OpenCL 2.1, OpenCL 2.2, OpenCL 3.0, OpenCL 3.1. .SH EXTENSIONS Supported OpenCL extensions: .TP 2 +.B cl_khr_command_buffer +for the supported and required command buffer capabilities; +.TP .B cl_khr_device_uuid for the UUID, LUID and node mask of the device; .TP @@ -107,10 +110,17 @@ .B cl_khr_il_program for information about the supported IL (Intermediate Language) representations; .TP +.B cl_khr_integer_dot_product +for information about the supported 8-bit dot products and their acceleration; +.TP .B cl_khr_spir for information about the supported SPIR (Standard Portable Intermediate Representation) versions; .TP +.B cl_khr_spirv_queries +for information about the supported SPIR-V (Standard Portable Intermediate +Representation) instruction sets, extensions and capabilities; +.TP .B cl_khr_icd for the suffix of vendor extensions functions; .TP @@ -243,7 +253,21 @@ .SH EXPERIMENTAL FEATURES .P -Support for OpenCL 2.x properties is not fully tested. +Support for OpenCL 3.1 is deemed experimental. +From the device information point of view, +OpenCL 3.1 is essentially equal to OpenCL 3.0 except for +the promotion of a few extensions to core, +and the rename and deprecation of +.B CL_DEVICE_MAX_WORK_IEM_SIZES +to +.B CL_DEVICE_MAX_WORK_GROUP_SIZES +with no change in meaning or value. +To the best of the author knowledge, +all promoted extensions are supported, +although the software does not (yet) differentiate between the features being available from core +versus from the extension (this limitation also affects some 2.1 features), +and the old keyword is still in use +(this may change in the future, or be adapted to the device version). .P Support for diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/src/clinfo.c new/clinfo-3.1.26.09.26/src/clinfo.c --- old/clinfo-3.0.25.02.14/src/clinfo.c 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/src/clinfo.c 2026-09-26 11:29:37.000000000 +0200 @@ -9,7 +9,7 @@ * On Windows, we must get the module handle for it, on Unix-like * systems we can just use RTLD_DEFAULT */ -#ifdef _MSC_VER +#if defined(_WIN32) || defined(_WIN64) # include <windows.h> # define dlsym GetProcAddress # define DL_MODULE GetModuleHandle("OpenCL") @@ -256,6 +256,7 @@ static const char *command_buffer_str[] = { "kernel printf", "device side enqueue", "simultaneous use", "out of order", + "multiple queue", }; static const char *command_buffer_raw_str[] = { @@ -263,6 +264,7 @@ "CL_COMMAND_BUFFER_CAPABILITY_DEVICE_SIDE_ENQUEUE_KHR", "CL_COMMAND_BUFFER_CAPABILITY_SIMULTANEOUS_USE_KHR", "CL_COMMAND_BUFFER_CAPABILITY_OUT_OF_ORDER_KHR", + "CL_COMMAND_BUFFER_CAPABILITY_MULTIPLE_QUEUE_KHR", }; const size_t command_buffer_count = ARRAY_SIZE(command_buffer_str); @@ -367,19 +369,19 @@ "Global Load/Store", "Global Add", "Global Min/Max", - "Unknown bit 3" - "Unknown bit 4" - "Unknown bit 5" - "Unknown bit 6" - "Unknown bit 7" - "Unknown bit 8" - "Unknown bit 9" - "Unknown bit 10" - "Unknown bit 11" - "Unknown bit 12" - "Unknown bit 13" - "Unknown bit 14" - "Unknown bit 15" + "Unknown bit 3", + "Unknown bit 4", + "Unknown bit 5", + "Unknown bit 6", + "Unknown bit 7", + "Unknown bit 8", + "Unknown bit 9", + "Unknown bit 10", + "Unknown bit 11", + "Unknown bit 12", + "Unknown bit 13", + "Unknown bit 14", + "Unknown bit 15", "Local Load/Store", "Local Add", "Local Min/Max" @@ -388,20 +390,20 @@ static const char* fp_atomic_caps_raw_str[] = { "CL_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT", "CL_GLOBAL_FP_ATOMIC_ADD_EXT", - "CL_GLOBAL_FP_ATOMIC_MIN_MAX_EXT" - "CL_UNKNOWN_FP_ATOMIC_BIT_3" - "CL_UNKNOWN_FP_ATOMIC_BIT_4" - "CL_UNKNOWN_FP_ATOMIC_BIT_5" - "CL_UNKNOWN_FP_ATOMIC_BIT_6" - "CL_UNKNOWN_FP_ATOMIC_BIT_7" - "CL_UNKNOWN_FP_ATOMIC_BIT_8" - "CL_UNKNOWN_FP_ATOMIC_BIT_9" - "CL_UNKNOWN_FP_ATOMIC_BIT_10" - "CL_UNKNOWN_FP_ATOMIC_BIT_11" - "CL_UNKNOWN_FP_ATOMIC_BIT_12" - "CL_UNKNOWN_FP_ATOMIC_BIT_13" - "CL_UNKNOWN_FP_ATOMIC_BIT_14" - "CL_UNKNOWN_FP_ATOMIC_BIT_15" + "CL_GLOBAL_FP_ATOMIC_MIN_MAX_EXT", + "CL_UNKNOWN_FP_ATOMIC_BIT_3", + "CL_UNKNOWN_FP_ATOMIC_BIT_4", + "CL_UNKNOWN_FP_ATOMIC_BIT_5", + "CL_UNKNOWN_FP_ATOMIC_BIT_6", + "CL_UNKNOWN_FP_ATOMIC_BIT_7", + "CL_UNKNOWN_FP_ATOMIC_BIT_8", + "CL_UNKNOWN_FP_ATOMIC_BIT_9", + "CL_UNKNOWN_FP_ATOMIC_BIT_10", + "CL_UNKNOWN_FP_ATOMIC_BIT_11", + "CL_UNKNOWN_FP_ATOMIC_BIT_12", + "CL_UNKNOWN_FP_ATOMIC_BIT_13", + "CL_UNKNOWN_FP_ATOMIC_BIT_14", + "CL_UNKNOWN_FP_ATOMIC_BIT_15", "CL_LOCAL_FP_ATOMIC_LOAD_STORE_EXT", "CL_LOCAL_FP_ATOMIC_ADD_EXT", "CL_LOCAL_FP_ATOMIC_MIN_MAX_EXT", @@ -410,6 +412,17 @@ /* There are three global and three local flags. This will be handled in device_info_fp_atomic_caps */ const size_t fp_atomic_caps_count = 3; +static const char* int_dot_product_str[] = { + "4x8bit packed", + "4x8bit", +}; + +static const char* int_dot_product_raw_str[] = { + "CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_PACKED", + "CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT", +}; + +const size_t int_dot_product_count = ARRAY_SIZE(int_dot_product_str); static const char* svm_cap_str[] = { "Coarse-grained buffer sharing", @@ -751,6 +764,7 @@ const size_t num_known_interops = ARRAY_SIZE(cl_interop_names); +#include "spv-capabilities.h" #define INDENT " " #define I0_STR "%-48s " @@ -1323,6 +1337,7 @@ cl_device_type devtype; cl_device_mem_cache_type cachetype; cl_device_local_mem_type lmemtype; + cl_device_integer_dot_product_capabilities_khr int_dot_product_caps; cl_bool image_support; cl_bool compiler_available; cl_bool arm_register_alloc_support; @@ -1343,6 +1358,7 @@ char has_arm_scheduling_controls[27]; char has_fission[22]; char has_atomic_counters[26]; + char has_int_dot_product[27]; char has_image2d_buffer[27]; char has_il_program[18]; char has_intel_queue_families[32]; @@ -1355,6 +1371,7 @@ char has_p2p[23]; char has_pci_bus_info[20]; char has_spir[12]; + char has_spirv_queries[21]; char has_qcom_ext_host_ptr[21]; char has_simultaneous_sharing[30]; char has_subgroup_named_barrier[30]; @@ -1390,6 +1407,7 @@ DEFINE_EXT_CHECK(arm_scheduling_controls) DEFINE_EXT_CHECK(fission) DEFINE_EXT_CHECK(atomic_counters) +DEFINE_EXT_CHECK(int_dot_product) DEFINE_EXT_CHECK(il_program) DEFINE_EXT_CHECK(intel) DEFINE_EXT_CHECK(intel_queue_families) @@ -1402,6 +1420,7 @@ DEFINE_EXT_CHECK(p2p) DEFINE_EXT_CHECK(pci_bus_info) DEFINE_EXT_CHECK(spir) +DEFINE_EXT_CHECK(spirv_queries) DEFINE_EXT_CHECK(qcom_ext_host_ptr) DEFINE_EXT_CHECK(simultaneous_sharing) DEFINE_EXT_CHECK(subgroup_named_barrier) @@ -1583,6 +1602,15 @@ return dev_has_float_atomics(chk) && dev_has_double(chk); } +cl_bool dev_has_int_dot_product_packed(const struct device_info_checks *chk) +{ + return !!(chk->int_dot_product_caps & CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_PACKED_KHR); +} + +cl_bool dev_has_int_dot_product_unpacked(const struct device_info_checks *chk) +{ + return !!(chk->int_dot_product_caps & CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR); +} void identify_device_extensions(const char *extensions, struct device_info_checks *chk) { @@ -1599,6 +1627,7 @@ char *has; CHECK_EXT(half, cl_khr_fp16); CHECK_EXT(spir, cl_khr_spir); + CHECK_EXT(spirv_queries, cl_khr_spirv_queries); CHECK_EXT(double, cl_khr_fp64); if (!dev_has_double(chk)) CHECK_EXT(double, cl_amd_fp64); @@ -1620,6 +1649,7 @@ CHECK_EXT(atomic_counters, cl_ext_atomic_counters_64); if (dev_has_atomic_counters(chk)) CHECK_EXT(atomic_counters, cl_ext_atomic_counters_32); + CHECK_EXT(int_dot_product, cl_khr_integer_dot_product); CHECK_EXT(image2d_buffer, cl_khr_image2d_from_buffer); CHECK_EXT(il_program, cl_khr_il_program); CHECK_EXT(intel_queue_families, cl_intel_command_queue_families); @@ -1729,6 +1759,18 @@ DEFINE_DEVINFO_SHOW(long, cl_ulong, u64, "%" PRIu64) DEFINE_DEVINFO_SHOW(sz, size_t, s, "%" PRIuS) +/* Show the actual device ID */ +void +device_info_dev_id(struct device_info_ret *ret, + const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), + const struct opt_out* UNUSED(output)) +{ + ret->value.ptr = (uintptr_t)(loc->dev); + ret->err = CL_SUCCESS; + strbuf_append(loc->pname, &ret->str, "%p", (void*)(ret->value.ptr)); + ret->needs_escaping = CL_TRUE; +} + void device_info_str(struct device_info_ret *ret, const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), @@ -1955,6 +1997,115 @@ free(val); } + +/* Like intptr, but print in hex */ +void +device_info_hexptr(struct device_info_ret *ret, + const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), + const struct opt_out *output) +{ + cl_uint *val = NULL; + size_t szval = 0, numval = 0; + GET_VAL_ARRAY(ret, loc); + if (!ret->err) { + size_t counter = 0; + set_separator(output->mode == CLINFO_HUMAN ? comma_str : output->json ? comma_str : spc_str); + const char * hexfmt = output->json ? "%" PRIu32 : "%#" PRIx32; + if (output->json) + strbuf_append_str_len(loc->pname, &ret->str, " [", 2); + for (counter = 0; counter < numval; ++counter) { + if (counter > 0) strbuf_append_str(loc->pname, &ret->str, sep); + strbuf_append(loc->pname, &ret->str, hexfmt, val[counter]); + } + if (output->json) + strbuf_append_str_len(loc->pname, &ret->str, " ]", 2); + // TODO: ret->value.??? = val; + } + free(val); +} + +/* Like intptr, but print in hex */ +void +device_info_spirv_caps(struct device_info_ret *ret, + const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), + const struct opt_out *output) +{ + cl_uint *val = NULL; + size_t szval = 0, numval = 0; + GET_VAL_ARRAY(ret, loc); + if (!ret->err) { + size_t counter = 0; + set_separator(output->mode == CLINFO_HUMAN ? full_padding : output->json ? comma_str : spc_str); + const char * fmt = output->json ? "\"%s\", %" PRIu32 : "%s (%" PRIu32 ")"; + if (output->json) + strbuf_append_str_len(loc->pname, &ret->str, " [", 2); + for (counter = 0; counter < numval; ++counter) { + /* find the SPIRV cap name */ + const cl_uint cap_idx = val[counter]; + const char *cap_name = "<unknown>"; + cl_uint cap_name_idx = 0; + cl_uint cap_range_counter = 0; + for (cap_range_counter = 0; cap_range_counter < num_spirv_caps_ranges; ++cap_range_counter) { + const cl_uint2 range = spirv_capability_ranges[cap_range_counter]; + if (cap_idx < range.s[0]) { + break; /* in a hole */ + } + if (cap_idx > range.s[1]) { /* next range */ + cap_name_idx += range.s[1] - range.s[0] + 1; + } else { /* in range */ + size_t actual_index = cap_name_idx + (cap_idx - range.s[0]); + cap_name = spirv_capabilities[actual_index]; + break; + } + } + + if (counter > 0) strbuf_append_str(loc->pname, &ret->str, sep); + strbuf_append(loc->pname, &ret->str, fmt, cap_name, cap_idx); + } + if (output->json) + strbuf_append_str_len(loc->pname, &ret->str, " ]", 2); + // TODO: ret->value.??? = val; + } + free(val); +} + + +/* Array of strings */ +void +device_info_strptr_sep(struct device_info_ret *ret, const char *human_sep, + const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), + const struct opt_out *output) +{ + const char **val = NULL; + size_t szval = 0, numval = 0; + GET_VAL_ARRAY(ret, loc); + if (!ret->err) { + size_t counter = 0; + set_separator(output->mode == CLINFO_HUMAN ? human_sep : output->json ? comma_str : spc_str); + /* TODO proper JSONing */ + const char *strfmt = output->json ? "\"%s\"" : "%s"; + if (output->json) + strbuf_append_str_len(loc->pname, &ret->str, " [", 2); + for (counter = 0; counter < numval; ++counter) { + if (counter > 0) strbuf_append_str(loc->pname, &ret->str, sep); + strbuf_append(loc->pname, &ret->str, strfmt, val[counter]); + } + if (output->json) + strbuf_append_str_len(loc->pname, &ret->str, " ]", 2); + // TODO: ret->value.??? = val; + } + free(val); +} + +void +device_info_strptr_newline(struct device_info_ret *ret, + const struct info_loc *loc, const struct device_info_checks* chk, + const struct opt_out *output) +{ + device_info_strptr_sep(ret, full_padding, loc, chk, output); +} + + void device_info_szptr_sep(struct device_info_ret *ret, const char *human_sep, const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), @@ -2298,6 +2449,51 @@ } void +device_info_int_dot_product(struct device_info_ret *ret, + const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), + const struct opt_out *output) +{ + GET_VAL(ret, loc, bits); + if (!ret->err) { + device_info_bitfield(ret, loc, chk, output, ret->value.bits, + int_dot_product_count, (output->mode == CLINFO_HUMAN ? + int_dot_product_str : int_dot_product_raw_str), + "capabilities"); + } +} + +void +device_info_int_dot_product_accel(struct device_info_ret *ret, + const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), + const struct opt_out *output) +{ + GET_VAL(ret, loc, int_dot_product_accel); + if (!ret->err) { + set_common_separator(output); + const char *fmt = output->json ? "%s\"%s\"" : "%s%s"; + if (output->json) { + strbuf_append(loc->pname, &ret->str, + "{ \"raw\": %" PRIu64 ", \"fields\" : [ ", + ret->value.bits); + } +#define CHECK_BIT(sep, raw, human) do { \ + if (ret->value.int_dot_product_accel.raw) { \ + strbuf_append(loc->pname, &ret->str, fmt, sep, (output->mode == CLINFO_HUMAN ? human : #raw)); \ + } } while (0) + CHECK_BIT("", signed_accelerated, "signed"); + CHECK_BIT(sep, unsigned_accelerated, "unsigned"); + CHECK_BIT(sep, mixed_signedness_accelerated, "mixed signedness"); + CHECK_BIT(sep, accumulating_saturating_signed_accelerated, "accumulating saturating signed"); + CHECK_BIT(sep, accumulating_saturating_unsigned_accelerated, "accumulating saturating unsigned");; + CHECK_BIT(sep, accumulating_saturating_mixed_signedness_accelerated, "accumulating saturating mixed signedness"); +#undef CHECK_BIT + if (output->json) + strbuf_append_str(loc->pname, &ret->str, " ] }"); + } +} + + +void device_info_device_enqueue_caps(struct device_info_ret *ret, const struct info_loc *loc, const struct device_info_checks* UNUSED(chk), const struct opt_out *output) @@ -2886,14 +3082,14 @@ for (offset = 0; offset < 32; offset += 16) { for (i = 0; i < num_flags; ++i) { - cl_device_fp_atomic_capabilities_ext cur = (cl_device_fp_atomic_capabilities_ext)(1) << i; - cl_bool present = !!(ret->value.fpconfig & cur); + cl_device_fp_atomic_capabilities_ext cur = (cl_device_fp_atomic_capabilities_ext)(1) << (offset + i); + cl_bool present = !!(ret->value.fp_atomic_caps & cur); if (output->mode == CLINFO_HUMAN) { strbuf_append(loc->pname, &ret->str, "\n%s" I2_STR "%s", - line_pfx, fpstr[i], bool_str[present]); + line_pfx, fpstr[offset + i], bool_str[present]); } else if (present) { strbuf_append(loc->pname, &ret->str, "%s%s%s%s", - (count > 0 ? sep : ""), quote, fpstr[i], quote); + (count > 0 ? sep : ""), quote, fpstr[offset + i], quote); ++count; } } @@ -3180,9 +3376,12 @@ size_t cursor = 0; strbuf_append_str_len(loc->pname, &ret->str, "[ ", 2); set_common_separator(output); + /* we show then as hex, so we need to quote them for JSON */ + const char* json_quote = output->json ? "\"" : ""; for (cursor = 0; cursor < numval; ++cursor) { - strbuf_append(loc->pname, &ret->str, "%s%p", - (cursor > 0 ? sep : ""), (void*)val[cursor]); + strbuf_append(loc->pname, &ret->str, "%s%s%p%s", + (cursor > 0 ? sep : ""), + json_quote, (void*)(val[cursor]), json_quote); } strbuf_append_str_len(loc->pname, &ret->str, " ]", 2); // TODO: ret->value.??? = val; @@ -3307,6 +3506,9 @@ #define DINFO(symbol, name, typ) symbol, #symbol, name, NULL, device_info_##typ struct device_info_traits dinfo_traits[] = { + /* Not an actual device property, but can be useful for CL_DEVICE_P2P_DEVICES_AMD */ + { CLINFO_BOTH, CL_TRUE, "device_id", "Device ID (this run)", NULL, device_info_dev_id, NULL }, + { CLINFO_BOTH, DINFO(CL_DEVICE_NAME, "Device Name", str), NULL }, { CLINFO_BOTH, DINFO(CL_DEVICE_VENDOR, "Device Vendor", str), NULL }, { CLINFO_BOTH, DINFO(CL_DEVICE_VENDOR_ID, "Device Vendor ID", hex), NULL }, @@ -3317,6 +3519,7 @@ { CLINFO_BOTH, DINFO(CL_DEVICE_EXTENSIONS, "Device Extensions", str), NULL }, { CLINFO_BOTH, DINFO(CL_DEVICE_EXTENSIONS_WITH_VERSION, "Device Extensions with Version", ext_version), dev_has_ext_ver }, + /* TODO: this should tell if it's being done due to the device being 3.1 or due to it having the cl_khr_device_uuid */ { CLINFO_BOTH, DINFO(CL_DEVICE_UUID_KHR, "Device UUID", uuid), dev_has_device_uuid }, { CLINFO_BOTH, DINFO(CL_DRIVER_UUID_KHR, "Driver UUID", uuid), dev_has_device_uuid }, { CLINFO_BOTH, DINFO(CL_DEVICE_LUID_VALID_KHR, "Valid Device LUID", bool), dev_has_device_uuid }, @@ -3397,6 +3600,9 @@ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, "Max work item dimensions", int), NULL }, { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_WORK_ITEM_SIZES, "Max work item sizes", szptr_times), NULL }, + /* TODO this or the previous depending on whether device is 3.1 or earlier? + { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_WORK_GROUP_SIZES, "Max work group sizes", szptr_times), NULL }, + */ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_WORK_GROUP_SIZE, "Max work group size", sz), NULL }, /* cl_amd_device_attribute_query v4 */ @@ -3427,6 +3633,11 @@ DINFO_VECWIDTH(FLOAT, float), DINFO_VECWIDTH(DOUBLE, double), + /* TODO: this should tell if it's being done due to the device being 3.1 or due to it having the cl_khr_integer_dot_product extension */ + { CLINFO_BOTH, DINFO(CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR, "Integer dot product capabilities", int_dot_product), dev_has_int_dot_product }, + { CLINFO_BOTH, DINFO(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR, INDENT "4x8bit dot product acceleration", int_dot_product_accel), dev_has_int_dot_product_unpacked }, + { CLINFO_BOTH, DINFO(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR, INDENT "4x8bit packed dot product acceleration", int_dot_product_accel), dev_has_int_dot_product_packed }, + /* Floating point configurations */ #define DINFO_FPCONF(Type, type, cond) \ { CLINFO_HUMAN, DINFO(CL_DEVICE_##Type##_FP_CONFIG, #type "-precision Floating-point support", fpconf), NULL }, \ @@ -3571,6 +3782,8 @@ /* Command buffers */ { CLINFO_BOTH, DINFO(CL_DEVICE_COMMAND_BUFFER_CAPABILITIES_KHR, "Command buffer capabilities", command_buffer_caps), dev_has_command_buffer }, + /* These two should have their qprop shown with extra indent */ + { CLINFO_BOTH, DINFO(CL_DEVICE_COMMAND_BUFFER_SUPPORTED_QUEUE_PROPERTIES_KHR, INDENT "Supported queue properties for command buffer", qprop), dev_has_command_buffer }, { CLINFO_BOTH, DINFO(CL_DEVICE_COMMAND_BUFFER_REQUIRED_QUEUE_PROPERTIES_KHR, INDENT "Required queue properties for command buffer", qprop), dev_has_command_buffer }, { CLINFO_BOTH, DINFO(CL_DEVICE_MUTABLE_DISPATCH_CAPABILITIES_KHR, "Mutable dispatch capabilities", mutable_dispatch_caps), dev_has_mutable_dispatch }, @@ -3616,6 +3829,12 @@ { CLINFO_BOTH, DINFO(CL_DEVICE_IL_VERSION, INDENT "IL version", str), dev_has_il }, { CLINFO_BOTH, DINFO(CL_DEVICE_ILS_WITH_VERSION, INDENT "ILs with version", ext_version), dev_has_ext_ver }, { CLINFO_BOTH, DINFO(CL_DEVICE_SPIR_VERSIONS, INDENT "SPIR versions", str), dev_has_spir }, + + /* TODO: this should tell if it's being done due to the device being 3.1 or due to it having the cl_khr_spirv_queries */ + { CLINFO_BOTH, DINFO(CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR, INDENT "SPIR-V extended instruction sets", strptr_newline), dev_has_spirv_queries }, + { CLINFO_BOTH, DINFO(CL_DEVICE_SPIRV_EXTENSIONS_KHR, INDENT "SPIR-V extensions", strptr_newline), dev_has_spirv_queries }, + { CLINFO_BOTH, DINFO(CL_DEVICE_SPIRV_CAPABILITIES_KHR, INDENT "SPIR-V capabilities", spirv_caps), dev_has_spirv_queries }, + { CLINFO_BOTH, DINFO(CL_DEVICE_PRINTF_BUFFER_SIZE, "printf() buffer size", mem_sz), dev_is_12 }, { CLINFO_BOTH, DINFO(CL_DEVICE_BUILT_IN_KERNELS, "Built-in kernels", str), dev_is_12 }, { CLINFO_BOTH, DINFO(CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION, "Built-in kernels with version", ext_version), dev_has_ext_ver }, @@ -3801,6 +4020,9 @@ // TODO warp count support should check for extension version >= 0.4 chk.arm_warp_count_support = !!(ret.value.sched_controls); break; + case CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR: + chk.int_dot_product_caps = ret.value.bits; + break; default: /* do nothing */ break; @@ -3994,7 +4216,7 @@ if (output->json) { if (!output->brief) printf(" }"); - } else if (output->detailed && d < pdata[p].ndevs - 1) + } else if (output->detailed && d < ndevs - 1) puts(""); @@ -4266,8 +4488,8 @@ pinfo_traits[0].sname); const char *devname_prop = (output->mode == CLINFO_HUMAN ? - dinfo_traits[0].pname : - dinfo_traits[0].sname); + dinfo_traits[1].pname : + dinfo_traits[1].sname); reset_loc(&loc, __func__); INIT_RET(ret, "null ctx from type"); @@ -4628,7 +4850,7 @@ void version(void) { - puts("clinfo version 3.0.25.02.14"); + puts("clinfo version 3.1.26.09.26"); } void add_selected_device(struct opt_out *output, cl_uint p, cl_uint d) @@ -4721,6 +4943,12 @@ puts("Defaults to raw mode if invoked with a name that contains the string \"raw\""); } +void missing_option(const char * what, const char *flagname) +{ + fprintf(stderr, "missing %s after %s\n", what, flagname); + exit(1); +} + int main(int argc, char *argv[]) { cl_uint p; @@ -4766,11 +4994,13 @@ output.brief = CL_TRUE; else if (!strcmp(argv[a], "-d") || !strcmp(argv[a], "--device")) { ++a; + if (a >= argc) missing_option("device number", argv[a-1]); parse_device_spec(argv[a], &output); } else if (!strncmp(argv[a], "-d", 2)) { parse_device_spec(argv[a] + 2, &output); } else if (!strcmp(argv[a], "--prop")) { ++a; + if (a >= argc) missing_option("property name", argv[a-1]); parse_prop(argv[a], &output); } else if (!strcmp(argv[a], "-?") || !strcmp(argv[a], "-h") || !strcmp(argv[a], "--help")) { usage(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/src/ext.h new/clinfo-3.1.26.09.26/src/ext.h --- old/clinfo-3.0.25.02.14/src/ext.h 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/src/ext.h 2026-09-26 11:29:37.000000000 +0200 @@ -9,10 +9,16 @@ * (otherwise, the maximum version will simply be used, but a message * will be printed). * - * TODO: until 3.0 gets finalized, we only target 2.2 because the 3.0 - * defines etc are still changing, so users may have an older version - * of the 3.0 headers lying around, which may prevent clinfo from being - * compilable. + * This poses an interesting challenge now that 3.0 has been finalized. + * If we target 3.0 and the user has an older version of the header, + * it will complain about an unsupported target. + * If we target 2.2 and the user has a recent enough version of the header, + * then the cl_version typedef will be defined in the headers, + * and conflict with ours. + * Our solution is to target 2.2 still, but only typedef cl_version + * if other version-related macros have not been defined: + * this helps us avoiding the typedef redefinition without tripping + * on “intermediate age” headers. */ #define CL_TARGET_OPENCL_VERSION 220 @@ -157,7 +163,13 @@ typedef cl_bitfield cl_device_atomic_capabilities; typedef cl_bitfield cl_device_device_enqueue_capabilities; + +/* See the comment about our choice for CL_TARGET_OPENCL_VERSION above + * for the motivation behind this check. + */ +#ifndef CL_MAKE_VERSION typedef cl_uint cl_version; +#endif #define CL_NAME_VERSION_MAX_NAME_SIZE 64 @@ -176,9 +188,19 @@ #define CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES (1 << 6) /* cl_device_device_enqueue_capabilities */ -#define CL_DEVICE_QUEUE_SUPPORTED (1 << 0) -#define CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT (1 << 1) +#define CL_DEVICE_QUEUE_SUPPORTED (1 << 0) +#define CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT (1 << 1) + +#endif +#ifndef CL_VERSION_3_1 +/* This is exactly the same as the pre-3.1 + * CL_DEVICE_MAX_WORK_ITEM_SIZES, but renamed + */ +#define CL_DEVICE_MAX_WORK_GROUP_SIZES 0x1005 +/* TODO: enums promoted from cl_khr_device_uuid */ +/* TODO: enums promoted from cl_khr_integer_dot_product */ +/* TODO: enums promoted from cl_khr_spirv_queries */ #endif /* @@ -187,19 +209,18 @@ /* cl_khr_extended_versioning */ // the _KHR fields are the same as the unsuffixed from OpenCL 3 -#define CL_PLATFORM_NUMERIC_VERSION_KHR CL_PLATFORM_NUMERIC_VERSION -#define CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR CL_PLATFORM_EXTENSIONS_WITH_VERSION -#define CL_DEVICE_NUMERIC_VERSION_KHR CL_DEVICE_NUMERIC_VERSION +#define CL_PLATFORM_NUMERIC_VERSION_KHR 0x0906 +#define CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR 0x0907 +#define CL_DEVICE_NUMERIC_VERSION_KHR 0x105E #define CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR 0x105F -#define CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR CL_DEVICE_EXTENSIONS_WITH_VERSION -#define CL_DEVICE_ILS_WITH_VERSION_KHR CL_DEVICE_ILS_WITH_VERSION -#define CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION +#define CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR 0x1060 +#define CL_DEVICE_ILS_WITH_VERSION_KHR 0x1061 +#define CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR 0x1062 /* cl_khr_image2d_from_buffer */ // the _KHR fields are the same as the unsuffixed from OpenCL 2 -#define CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR CL_DEVICE_IMAGE_PITCH_ALIGNMENT -#define CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT - +#define CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR 0x104A +#define CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR 0x104B /* cl_khr_icd */ #define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920 @@ -215,6 +236,26 @@ /* cl_amd_object_metadata */ #define CL_PLATFORM_MAX_KEYS_AMD 0x403C +/* cl_khr_integer_dot_product */ +#ifndef CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR +typedef cl_bitfield cl_device_integer_dot_product_capabilities_khr; +typedef struct _cl_device_integer_dot_product_acceleration_properties_khr { + cl_bool signed_accelerated; + cl_bool unsigned_accelerated; + cl_bool mixed_signedness_accelerated; + cl_bool accumulating_saturating_signed_accelerated; + cl_bool accumulating_saturating_unsigned_accelerated; + cl_bool accumulating_saturating_mixed_signedness_accelerated; +} cl_device_integer_dot_product_acceleration_properties_khr; + +#define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_PACKED_KHR (1 << 0) +#define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR (1 << 1) + +#define CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR 0x1073 +#define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR 0x1074 +#define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR 0x1075 +#endif + /* cl_khr_device_uuid extension */ #define CL_UUID_SIZE_KHR 16 @@ -237,6 +278,7 @@ /* cl_khr_command_buffer */ #define CL_DEVICE_COMMAND_BUFFER_CAPABILITIES_KHR 0x12A9 +#define CL_DEVICE_COMMAND_BUFFER_SUPPORTED_QUEUE_PROPERTIES_KHR 0x129A #define CL_DEVICE_COMMAND_BUFFER_REQUIRED_QUEUE_PROPERTIES_KHR 0x12AA typedef cl_bitfield cl_device_command_buffer_capabilities_khr; @@ -262,7 +304,7 @@ * so I'm currently extrapolating them from the specification */ typedef cl_bitfield cl_device_terminate_capability_khr; -#define CL_DEVICE_TERMINATE_CAPABILITY_CONTEXT_KHR (1<<0) +#define CL_DEVICE_TERMINATE_CAPABILITY_CONTEXT_KHR (1 << 0) /* cl_khr_subgroup_named_barrier */ #define CL_DEVICE_MAX_NAMED_BARRIER_COUNT_KHR 0x2035 @@ -288,6 +330,7 @@ /* cl_khr_pci_bus_info */ +#ifndef CL_DEVICE_PCI_BUS_INFO_KHR typedef struct _cl_device_pci_bus_info_khr { cl_uint pci_domain; cl_uint pci_bus; @@ -296,6 +339,7 @@ } cl_device_pci_bus_info_khr; #define CL_DEVICE_PCI_BUS_INFO_KHR 0x410F +#endif /* cl_nv_device_attribute_query */ #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000 @@ -427,10 +471,10 @@ /* cl_arm_shared_virtual_memory */ #define CL_DEVICE_SVM_CAPABILITIES_ARM 0x40B6 -#define CL_DEVICE_SVM_COARSE_GRAIN_BUFFER_ARM CL_DEVICE_SVM_COARSE_GRAIN_BUFFER -#define CL_DEVICE_SVM_FINE_GRAIN_BUFFER_ARM CL_DEVICE_SVM_FINE_GRAIN_BUFFER -#define CL_DEVICE_SVM_FINE_GRAIN_SYSTEM_ARM CL_DEVICE_SVM_FINE_GRAIN_SYSTEM -#define CL_DEVICE_SVM_ATOMICS_ARM CL_DEVICE_SVM_ATOMICS +#define CL_DEVICE_SVM_COARSE_GRAIN_BUFFER_ARM (1 << 0) +#define CL_DEVICE_SVM_FINE_GRAIN_BUFFER_ARM (1 << 1) +#define CL_DEVICE_SVM_FINE_GRAIN_SYSTEM_ARM (1 << 2) +#define CL_DEVICE_SVM_ATOMICS_ARM (1 << 3) /* cl_arm_core_id */ #define CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM 0x40BF @@ -446,6 +490,11 @@ /* cl_khr_spir */ #define CL_DEVICE_SPIR_VERSIONS 0x40E0 +/* cl_khr_spirv_queries */ +#define CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR 0x12B9 +#define CL_DEVICE_SPIRV_EXTENSIONS_KHR 0x12BA +#define CL_DEVICE_SPIRV_CAPABILITIES_KHR 0x12BB + /* cl_altera_device_temperature */ #define CL_DEVICE_CORE_TEMPERATURE_ALTERA 0x40F3 @@ -461,6 +510,7 @@ typedef cl_bitfield cl_command_queue_capabilities_intel; +#ifndef CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL #define CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL 64 typedef struct _cl_queue_family_properties_intel { cl_command_queue_properties properties; @@ -468,6 +518,7 @@ cl_uint count; char name[CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL]; } cl_queue_family_properties_intel; +#endif /* cl_arm_job_slot_selection */ #define CL_DEVICE_JOB_SLOTS_ARM 0x41E0 @@ -505,6 +556,7 @@ #define CL_DEVICE_NUM_THREADS_PER_EU_INTEL 0x4255 #define CL_DEVICE_FEATURE_CAPABILITIES_INTEL 0x4256 +#if 0 // before standardization /* clGeICDLoaderInfoOCLICD */ typedef enum { CL_ICDL_OCL_VERSION=1, @@ -512,5 +564,15 @@ CL_ICDL_NAME=3, CL_ICDL_VENDOR=4, } cl_icdl_info; +#else +typedef cl_uint cl_icdl_info; + +/* cl_icdl_info */ +#define CL_ICDL_OCL_VERSION 1 +#define CL_ICDL_VERSION 2 +#define CL_ICDL_NAME 3 +#define CL_ICDL_VENDOR 4 + +#endif #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/src/fmtmacros.h new/clinfo-3.1.26.09.26/src/fmtmacros.h --- old/clinfo-3.0.25.02.14/src/fmtmacros.h 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/src/fmtmacros.h 2026-09-26 11:29:37.000000000 +0200 @@ -8,7 +8,7 @@ #ifndef FMT_MACROS_H #define FMT_MACROS_H -#ifdef _WIN32 +#if defined(_WIN32) && !defined(__MINGW32__) /* TODO FIXME WIN64 support */ # include <stdint.h> # include <stddef.h> // size_t diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/src/info_ret.h new/clinfo-3.1.26.09.26/src/info_ret.h --- old/clinfo-3.0.25.02.14/src/info_ret.h 2025-02-14 17:39:10.000000000 +0100 +++ new/clinfo-3.1.26.09.26/src/info_ret.h 2026-09-26 11:29:37.000000000 +0200 @@ -31,6 +31,7 @@ struct _strbuf err_str; /* actual value, when not a string */ union { + uintptr_t ptr; size_t s; cl_long i64; cl_ulong u64; @@ -48,6 +49,7 @@ cl_device_pci_bus_info_khr devtopo_khr; cl_device_scheduling_controls_capabilities_arm sched_controls; cl_device_affinity_domain affinity_domain; + cl_device_integer_dot_product_acceleration_properties_khr int_dot_product_accel; cl_device_fp_config fpconfig; cl_device_fp_atomic_capabilities_ext fp_atomic_caps; cl_command_queue_properties qprop; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/clinfo-3.0.25.02.14/src/spv-capabilities.h new/clinfo-3.1.26.09.26/src/spv-capabilities.h --- old/clinfo-3.0.25.02.14/src/spv-capabilities.h 1970-01-01 01:00:00.000000000 +0100 +++ new/clinfo-3.1.26.09.26/src/spv-capabilities.h 2026-09-26 11:29:37.000000000 +0200 @@ -0,0 +1,554 @@ +static const cl_uint2 spirv_capability_ranges[] = { + {{ 0, 71 }}, + {{ 4165, 4168 }}, + {{ 4174, 4176 }}, + {{ 4191, 4191 }}, + {{ 4201, 4201 }}, + {{ 4212, 4213 }}, + {{ 4228, 4232 }}, + {{ 4422, 4423 }}, + {{ 4427, 4450 }}, + {{ 4464, 4473 }}, + {{ 4478, 4479 }}, + {{ 4484, 4486 }}, + {{ 4495, 4498 }}, + {{ 4504, 4506 }}, + {{ 4539, 4539 }}, + {{ 4543, 4544 }}, + {{ 5008, 5016 }}, + {{ 5055, 5055 }}, + {{ 5067, 5067 }}, + {{ 5087, 5087 }}, + {{ 5112, 5120 }}, + {{ 5128, 5128 }}, + {{ 5146, 5146 }}, + {{ 5156, 5156 }}, + {{ 5181, 5181 }}, + {{ 5249, 5255 }}, + {{ 5259, 5260 }}, + {{ 5265, 5266 }}, + {{ 5282, 5284 }}, + {{ 5288, 5288 }}, + {{ 5291, 5291 }}, + {{ 5297, 5297 }}, + {{ 5301, 5312 }}, + {{ 5336, 5336 }}, + {{ 5340, 5341 }}, + {{ 5345, 5347 }}, + {{ 5350, 5350 }}, + {{ 5353, 5353 }}, + {{ 5357, 5357 }}, + {{ 5363, 5363 }}, + {{ 5372, 5373 }}, + {{ 5378, 5383 }}, + {{ 5388, 5394 }}, + {{ 5404, 5404 }}, + {{ 5409, 5409 }}, + {{ 5414, 5414 }}, + {{ 5418, 5419 }}, + {{ 5423, 5439 }}, + {{ 5447, 5447 }}, + {{ 5568, 5570 }}, + {{ 5579, 5584 }}, + {{ 5603, 5606 }}, + {{ 5612, 5619 }}, + {{ 5629, 5629 }}, + {{ 5696, 5698 }}, + {{ 5817, 5817 }}, + {{ 5821, 5824 }}, + {{ 5837, 5837 }}, + {{ 5844, 5845 }}, + {{ 5886, 5888 }}, + {{ 5892, 5892 }}, + {{ 5897, 5898 }}, + {{ 5904, 5910 }}, + {{ 5916, 5916 }}, + {{ 5920, 5922 }}, + {{ 5935, 5935 }}, + {{ 5939, 5939 }}, + {{ 5943, 5948 }}, + {{ 6016, 6034 }}, + {{ 6089, 6089 }}, + {{ 6094, 6095 }}, + {{ 6114, 6115 }}, + {{ 6141, 6141 }}, + {{ 6144, 6144 }}, + {{ 6150, 6150 }}, + {{ 6161, 6162 }}, + {{ 6169, 6174 }}, + {{ 6185, 6189 }}, + {{ 6207, 6207 }}, + {{ 6220, 6220 }}, + {{ 6228, 6230 }}, + {{ 6236, 6236 }}, + {{ 6241, 6246 }}, + {{ 6257, 6257 }}, + {{ 6265, 6265 }}, + {{ 6400, 6400 }}, + {{ 6425, 6427 }}, + {{ 6441, 6441 }}, + {{ 6460, 6460 }}, + {{ 6528, 6528 }}, + {{ 6912, 6915 }}, + {{ 7041, 7041 }}, +}; + +const size_t num_spirv_caps_ranges = ARRAY_SIZE(spirv_capability_ranges); + +static const char* spirv_capabilities[] = { + "Matrix", /* (0), */ + "Shader", /* (1), */ + "Geometry", /* (2), */ + "Tessellation", /* (3), */ + "Addresses", /* (4), */ + "Linkage", /* (5), */ + "Kernel", /* (6), */ + "Vector16", /* (7), */ + "Float16Buffer", /* (8), */ + "Float16", /* (9), */ + "Float64", /* (10), */ + "Int64", /* (11), */ + "Int64Atomics", /* (12), */ + "ImageBasic", /* (13), */ + "ImageReadWrite", /* (14), */ + "ImageMipmap", /* (15), */ + "<unknown>", /* (16), */ + "Pipes", /* (17), */ + "Groups", /* (18), */ + "DeviceEnqueue", /* (19), */ + "LiteralSampler", /* (20), */ + "AtomicStorage", /* (21), */ + "Int16", /* (22), */ + "TessellationPointSize", /* (23), */ + "GeometryPointSize", /* (24), */ + "ImageGatherExtended", /* (25), */ + "<unknown>", /* (26), */ + "StorageImageMultisample", /* (27), */ + "UniformBufferArrayDynamicIndexing", /* (28), */ + "SampledImageArrayDynamicIndexing", /* (29), */ + "StorageBufferArrayDynamicIndexing", /* (30), */ + "StorageImageArrayDynamicIndexing", /* (31), */ + "ClipDistance", /* (32), */ + "CullDistance", /* (33), */ + "ImageCubeArray", /* (34), */ + "SampleRateShading", /* (35), */ + "ImageRect", /* (36), */ + "SampledRect", /* (37), */ + "GenericPointer", /* (38), */ + "Int8", /* (39), */ + "InputAttachment", /* (40), */ + "SparseResidency", /* (41), */ + "MinLod", /* (42), */ + "Sampled1D", /* (43), */ + "Image1D", /* (44), */ + "SampledCubeArray", /* (45), */ + "SampledBuffer", /* (46), */ + "ImageBuffer", /* (47), */ + "ImageMSArray", /* (48), */ + "StorageImageExtendedFormats", /* (49), */ + "ImageQuery", /* (50), */ + "DerivativeControl", /* (51), */ + "InterpolationFunction", /* (52), */ + "TransformFeedback", /* (53), */ + "GeometryStreams", /* (54), */ + "StorageImageReadWithoutFormat", /* (55), */ + "StorageImageWriteWithoutFormat", /* (56), */ + "MultiViewport", /* (57), */ + "SubgroupDispatch", /* (58), */ + "NamedBarrier", /* (59), */ + "PipeStorage", /* (60), */ + "GroupNonUniform", /* (61), */ + "GroupNonUniformVote", /* (62), */ + "GroupNonUniformArithmetic", /* (63), */ + "GroupNonUniformBallot", /* (64), */ + "GroupNonUniformShuffle", /* (65), */ + "GroupNonUniformShuffleRelative", /* (66), */ + "GroupNonUniformClustered", /* (67), */ + "GroupNonUniformQuad", /* (68), */ + "ShaderLayer", /* (69), */ + "ShaderViewportIndex", /* (70), */ + "UniformDecoration", /* (71), */ + /* HOLE */ + "CoreBuiltinsARM", /* (4165), */ + "TileImageColorReadAccessEXT", /* (4166), */ + "TileImageDepthReadAccessEXT", /* (4167), */ + "TileImageStencilReadAccessEXT", /* (4168), */ + /* HOLE */ + "TensorsARM", /* (4174), */ + "StorageTensorArrayDynamicIndexingARM", /* (4175), */ + "StorageTensorArrayNonUniformIndexingARM", /* (4176), */ + /* HOLE */ + "GraphARM", /* (4191), */ + /* HOLE */ + "CooperativeMatrixLayoutsARM", /* (4201), */ + /* HOLE */ + "Float8EXT", /* (4212), */ + "Float8CooperativeMatrixEXT", /* (4213), */ + /* HOLE */ + "Float6EXT", /* (4228), */ + "Float4EXT", /* (4229), */ + "Float8UnsignedE8M0EXT", /* (4230), */ + "MXInt8EXT", /* (4231), */ + "BitcastExtractEXT", /* (4232), */ + /* HOLE */ + "FragmentShadingRateKHR", /* (4422), */ + "SubgroupBallotKHR", /* (4423), */ + /* HOLE */ + "DrawParameters", /* (4427), */ + "WorkgroupMemoryExplicitLayoutKHR", /* (4428), */ + "WorkgroupMemoryExplicitLayout8BitAccessKHR", /* (4429), */ + "WorkgroupMemoryExplicitLayout16BitAccessKHR", /* (4430), */ + "SubgroupVoteKHR", /* (4431), */ + "<unknown>", /* (4432), */ + "StorageBuffer16BitAccess / StorageUniformBufferBlock16", /* (4433), */ + "StorageUniform16 / UniformAndStorageBuffer16BitAccess", /* (4434), */ + "StoragePushConstant16", /* (4435), */ + "StorageInputOutput16", /* (4436), */ + "DeviceGroup", /* (4437), */ + "<unknown>", /* (4438), */ + "MultiView", /* (4439), */ + "<unknown>", /* (4440), */ + "VariablePointersStorageBuffer", /* (4441), */ + "VariablePointers", /* (4442), */ + "<unknown>", /* (4443), */ + "<unknown>", /* (4444), */ + "AtomicStorageOps", /* (4445), */ + "<unknown>", /* (4446), */ + "SampleMaskPostDepthCoverage", /* (4447), */ + "StorageBuffer8BitAccess", /* (4448), */ + "UniformAndStorageBuffer8BitAccess", /* (4449), */ + "StoragePushConstant8", /* (4450), */ + /* HOLE */ + "DenormPreserve", /* (4464), */ + "DenormFlushToZero", /* (4465), */ + "SignedZeroInfNanPreserve", /* (4466), */ + "RoundingModeRTE", /* (4467), */ + "RoundingModeRTZ", /* (4468), */ + "<unknown>", /* (4469), */ + "<unknown>", /* (4470), */ + "RayQueryProvisionalKHR", /* (4471), */ + "RayQueryKHR", /* (4472), */ + "UntypedPointersKHR", /* (4473), */ + /* HOLE */ + "RayTraversalPrimitiveCullingKHR", /* (4478), */ + "RayTracingKHR", /* (4479), */ + /* HOLE */ + "TextureSampleWeightedQCOM", /* (4484), */ + "TextureBoxFilterQCOM", /* (4485), */ + "TextureBlockMatchQCOM", /* (4486), */ + /* HOLE */ + "TileShadingQCOM", /* (4495), */ + "CooperativeMatrixConversionQCOM", /* (4496), */ + "<unknown>", /* (4497), */ + "TextureBlockMatch2QCOM", /* (4498), */ + /* HOLE */ + "BFloat16MulAddQCOM", /* (4504), */ + "<unknown>", /* (4505), */ + "SubgroupSizeQCOM", /* (4506), */ + /* HOLE */ + "MultipleWaitQueuesQCOM", /* (4539), */ + /* HOLE */ + "ImageGatherLinearQCOM", /* (4543), */ + "ImageGatherExtendedModesQCOM", /* (4544), */ + /* HOLE */ + "Float16ImageAMD", /* (5008), */ + "ImageGatherBiasLodAMD", /* (5009), */ + "FragmentMaskAMD", /* (5010), */ + "<unknown>", /* (5011), */ + "<unknown>", /* (5012), */ + "StencilExportEXT", /* (5013), */ + "<unknown>", /* (5014), */ + "ImageReadWriteLodAMD", /* (5015), */ + "Int64ImageEXT", /* (5016), */ + /* HOLE */ + "ShaderClockKHR", /* (5055), */ + /* HOLE */ + "ShaderEnqueueAMDX", /* (5067), */ + /* HOLE */ + "QuadControlKHR", /* (5087), */ + /* HOLE */ + "Int4TypeINTEL", /* (5112), */ + "<unknown>", /* (5113), */ + "Int4CooperativeMatrixINTEL", /* (5114), */ + "<unknown>", /* (5115), */ + "BFloat16TypeKHR", /* (5116), */ + "BFloat16DotProductKHR", /* (5117), */ + "BFloat16CooperativeMatrixKHR", /* (5118), */ + "<unknown>", /* (5119), */ + "AbortKHR", /* (5120), */ + /* HOLE */ + "DescriptorHeapEXT", /* (5128), */ + /* HOLE */ + "ConstantDataKHR", /* (5146), */ + /* HOLE */ + "PoisonFreezeKHR", /* (5156), */ + /* HOLE */ + "WeakLinkageAMD", /* (5181), */ + /* HOLE */ + "SampleMaskOverrideCoverageNV", /* (5249), */ + "<unknown>", /* (5250), */ + "GeometryShaderPassthroughNV", /* (5251), */ + "<unknown>", /* (5252), */ + "<unknown>", /* (5253), */ + "ShaderViewportIndexLayerEXT / ShaderViewportIndexLayerNV", /* (5254), */ + "ShaderViewportMaskNV", /* (5255), */ + /* HOLE */ + "ShaderStereoViewNV", /* (5259), */ + "PerViewAttributesNV", /* (5260), */ + /* HOLE */ + "FragmentFullyCoveredEXT", /* (5265), */ + "MeshShadingNV", /* (5266), */ + /* HOLE */ + "ImageFootprintNV", /* (5282), */ + "MeshShadingEXT", /* (5283), */ + "FragmentBarycentricKHR / FragmentBarycentricNV ", /* (5284), */ + /* HOLE */ + "ComputeDerivativeGroupQuadsKHR / ComputeDerivativeGroupQuadsNV", /* (5288), */ + /* HOLE */ + "FragmentDensityEXT / ShadingRateNV", /* (5291), */ + /* HOLE */ + "GroupNonUniformPartitionedEXT / GroupNonUniformPartitionedNV", /* (5297), */ + /* HOLE */ + "ShaderNonUniform / ShaderNonUniformEXT", /* (5301), */ + "RuntimeDescriptorArray / RuntimeDescriptorArrayEXT", /* (5302), */ + "InputAttachmentArrayDynamicIndexing / InputAttachmentArrayDynamicIndexingEXT", /* (5303), */ + "UniformTexelBufferArrayDynamicIndexing / UniformTexelBufferArrayDynamicIndexingEXT", /* (5304), */ + "StorageTexelBufferArrayDynamicIndexing / StorageTexelBufferArrayDynamicIndexingEXT", /* (5305), */ + "UniformBufferArrayNonUniformIndexing / UniformBufferArrayNonUniformIndexingEXT", /* (5306), */ + "SampledImageArrayNonUniformIndexing / SampledImageArrayNonUniformIndexingEXT", /* (5307), */ + "StorageBufferArrayNonUniformIndexing / StorageBufferArrayNonUniformIndexingEXT", /* (5308), */ + "StorageImageArrayNonUniformIndexing / StorageImageArrayNonUniformIndexingEXT", /* (5309), */ + "InputAttachmentArrayNonUniformIndexing / InputAttachmentArrayNonUniformIndexingEXT", /* (5310), */ + "UniformTexelBufferArrayNonUniformIndexing / UniformTexelBufferArrayNonUniformIndexingEXT", /* (5311), */ + "StorageTexelBufferArrayNonUniformIndexing / StorageTexelBufferArrayNonUniformIndexingEXT", /* (5312), */ + /* HOLE */ + "RayTracingPositionFetchKHR", /* (5336), */ + /* HOLE */ + "RayTracingNV", /* (5340), */ + "RayTracingMotionBlurNV", /* (5341), */ + /* HOLE */ + "VulkanMemoryModel / VulkanMemoryModelKHR", /* (5345), */ + "VulkanMemoryModelDeviceScope / VulkanMemoryModelDeviceScopeKHR", /* (5346), */ + "PhysicalStorageBufferAddresses / PhysicalStorageBufferAddressesEXT", /* (5347), */ + /* HOLE */ + "ComputeDerivativeGroupLinearKHR / ComputeDerivativeGroupLinearNV", /* (5350), */ + /* HOLE */ + "RayTracingProvisionalKHR", /* (5353), */ + /* HOLE */ + "CooperativeMatrixNV", /* (5357), */ + /* HOLE */ + "FragmentShaderSampleInterlockEXT", /* (5363), */ + /* HOLE */ + "FragmentShaderShadingRateInterlockEXT", /* (5372), */ + "ShaderSMBuiltinsNV", /* (5373), */ + /* HOLE */ + "FragmentShaderPixelInterlockEXT", /* (5378), */ + "DemoteToHelperInvocation / DemoteToHelperInvocationEXT", /* (5379), */ + "DisplacementMicromapNV", /* (5380), */ + "RayTracingOpacityMicromapEXT / RayTracingOpacityMicromapKHR", /* (5381), */ + "<unknown>", /* (5382), */ + "ShaderInvocationReorderNV", /* (5383), */ + /* HOLE */ + "ShaderInvocationReorderEXT", /* (5388), */ + "<unknown>", /* (5389), */ + "BindlessTextureNV", /* (5390), */ + "RayQueryPositionFetchKHR", /* (5391), */ + "<unknown>", /* (5392), */ + "<unknown>", /* (5393), */ + "CooperativeVectorNV", /* (5394), */ + /* HOLE */ + "AtomicFloat16VectorNV", /* (5404), */ + /* HOLE */ + "RayTracingDisplacementMicromapNV", /* (5409), */ + /* HOLE */ + "RawAccessChainsNV", /* (5414), */ + /* HOLE */ + "RayTracingSpheresGeometryNV", /* (5418), */ + "RayTracingLinearSweptSpheresGeometryNV", /* (5419), */ + /* HOLE */ + "PushConstantBanksNV", /* (5423), */ + "<unknown>", /* (5424), */ + "LongVectorEXT", /* (5425), */ + "Shader64BitIndexingEXT", /* (5426), */ + "<unknown>", /* (5427), */ + "<unknown>", /* (5428), */ + "CooperativeMatrixConversionsEXT", /* (5429), */ + "CooperativeMatrixReductionsEXT / CooperativeMatrixReductionsNV", /* (5430), */ + "CooperativeMatrixConversionsNV", /* (5431), */ + "CooperativeMatrixPerElementOperationsEXT / CooperativeMatrixPerElementOperationsNV", /* (5432), */ + "CooperativeMatrixTensorAddressingNV", /* (5433), */ + "CooperativeMatrixBlockLoadsNV", /* (5434), */ + "CooperativeVectorTrainingNV", /* (5435), */ + "<unknown>", /* (5436), */ + "RayTracingClusterAccelerationStructureNV", /* (5437), */ + "CooperativeMatrixGetCoordinateEXT", /* (5438), */ + "TensorAddressingNV", /* (5439), */ + /* HOLE */ + "CooperativeMatrixDecodeVectorNV", /* (5447), */ + /* HOLE */ + "SubgroupShuffleINTEL", /* (5568), */ + "SubgroupBufferBlockIOINTEL", /* (5569), */ + "SubgroupImageBlockIOINTEL", /* (5570), */ + /* HOLE */ + "SubgroupImageMediaBlockIOINTEL", /* (5579), */ + "<unknown>", /* (5580), */ + "<unknown>", /* (5581), */ + "RoundToInfinityINTEL", /* (5582), */ + "FloatingPointModeINTEL", /* (5583), */ + "IntegerFunctions2INTEL", /* (5584), */ + /* HOLE */ + "FunctionPointersINTEL", /* (5603), */ + "IndirectReferencesINTEL", /* (5604), */ + "<unknown>", /* (5605), */ + "AsmINTEL", /* (5606), */ + /* HOLE */ + "AtomicFloat32MinMaxEXT", /* (5612), */ + "AtomicFloat64MinMaxEXT", /* (5613), */ + "<unknown>", /* (5614), */ + "<unknown>", /* (5615), */ + "AtomicFloat16MinMaxEXT", /* (5616), */ + "VectorComputeINTEL", /* (5617), */ + "<unknown>", /* (5618), */ + "VectorAnyINTEL", /* (5619), */ + /* HOLE */ + "ExpectAssumeKHR", /* (5629), */ + /* HOLE */ + "SubgroupAvcMotionEstimationINTEL", /* (5696), */ + "SubgroupAvcMotionEstimationIntraINTEL", /* (5697), */ + "SubgroupAvcMotionEstimationChromaINTEL", /* (5698), */ + /* HOLE */ + "VariableLengthArrayINTEL", /* (5817), */ + /* HOLE */ + "FunctionFloatControlINTEL", /* (5821), */ + "<unknown>", /* (5822), */ + "<unknown>", /* (5823), */ + "FPGAMemoryAttributesALTERA / FPGAMemoryAttributesINTEL", /* (5824), */ + /* HOLE */ + "FPFastMathModeINTEL", /* (5837), */ + /* HOLE */ + "ArbitraryPrecisionIntegersALTERA / ArbitraryPrecisionIntegersINTEL", /* (5844), */ + "ArbitraryPrecisionFloatingPointALTERA / ArbitraryPrecisionFloatingPointINTEL", /* (5845), */ + /* HOLE */ + "UnstructuredLoopControlsINTEL", /* (5886), */ + "<unknown>", /* (5887), */ + "FPGALoopControlsALTERA / FPGALoopControlsINTEL", /* (5888), */ + /* HOLE */ + "KernelAttributesINTEL", /* (5892), */ + /* HOLE */ + "FPGAKernelAttributesINTEL", /* (5897), */ + "FPGAMemoryAccessesALTERA / FPGAMemoryAccessesINTEL", /* (5898), */ + /* HOLE */ + "FPGAClusterAttributesALTERA / FPGAClusterAttributesINTEL", /* (5904), */ + "<unknown>", /* (5905), */ + "LoopFuseALTERA / LoopFuseINTEL", /* (5906), */ + "<unknown>", /* (5907), */ + "FPGADSPControlALTERA / FPGADSPControlINTEL", /* (5908), */ + "<unknown>", /* (5909), */ + "MemoryAccessAliasingINTEL", /* (5910), */ + /* HOLE */ + "FPGAInvocationPipeliningAttributesALTERA / FPGAInvocationPipeliningAttributesINTEL", /* (5916), */ + "FPGABufferLocationALTERA / FPGABufferLocationINTEL", /* (5920), */ + "<unknown>", /* (5921), */ + "ArbitraryPrecisionFixedPointALTERA / ArbitraryPrecisionFixedPointINTEL", /* (5922), */ + /* HOLE */ + "USMStorageClassesALTERA / USMStorageClassesINTEL", /* (5935), */ + /* HOLE */ + "RuntimeAlignedAttributeALTERA / RuntimeAlignedAttributeINTEL", /* (5939), */ + /* HOLE */ + "IOPipesALTERA / IOPipesINTEL", /* (5943), */ + "<unknown>", /* (5944), */ + "BlockingPipesALTERA / BlockingPipesINTEL", /* (5945), */ + "<unknown>", /* (5946), */ + "<unknown>", /* (5947), */ + "FPGARegALTERA / FPGARegINTEL", /* (5948), */ + /* HOLE */ + "DotProductInputAll / DotProductInputAllKHR", /* (6016), */ + "DotProductInput4x8Bit / DotProductInput4x8BitKHR", /* (6017), */ + "DotProductInput4x8BitPacked / DotProductInput4x8BitPackedKHR", /* (6018), */ + "DotProduct / DotProductKHR", /* (6019), */ + "RayCullMaskKHR", /* (6020), */ + "<unknown>", /* (6021), */ + "CooperativeMatrixKHR", /* (6022), */ + "<unknown>", /* (6023), */ + "ReplicatedCompositesEXT", /* (6024), */ + "BitInstructions", /* (6025), */ + "GroupNonUniformRotateKHR", /* (6026), */ + "<unknown>", /* (6027), */ + "<unknown>", /* (6028), */ + "FloatControls2", /* (6029), */ + "FMAKHR", /* (6030), */ + "<unknown>", /* (6031), */ + "RayTracingOpacityMicromapExecutionModeKHR", /* (6032), */ + "AtomicFloat32AddEXT", /* (6033), */ + "AtomicFloat64AddEXT", /* (6034), */ + /* HOLE */ + "LongCompositesINTEL", /* (6089), */ + /* HOLE */ + "OptNoneEXT / OptNoneINTEL", /* (6094), */ + "AtomicFloat16AddEXT", /* (6095), */ + /* HOLE */ + "DebugInfoModuleINTEL", /* (6114), */ + "BFloat16ConversionINTEL", /* (6115), */ + /* HOLE */ + "SplitBarrierEXT / SplitBarrierINTEL", /* (6141), */ + /* HOLE */ + "ArithmeticFenceEXT", /* (6144), */ + /* HOLE */ + "FPGAClusterAttributesV2ALTERA / FPGAClusterAttributesV2INTEL", /* (6150), */ + /* HOLE */ + "FPGAKernelAttributesv2INTEL", /* (6161), */ + "TaskSequenceALTERA / TaskSequenceINTEL", /* (6162), */ + /* HOLE */ + "FPMaxErrorINTEL", /* (6169), */ + "<unknown>", /* (6170), */ + "FPGALatencyControlALTERA / FPGALatencyControlINTEL", /* (6171), */ + "<unknown>", /* (6172), */ + "<unknown>", /* (6173), */ + "FPGAArgumentInterfacesALTERA / FPGAArgumentInterfacesINTEL", /* (6174), */ + /* HOLE */ + "DeviceBarrierINTEL", /* (6185), */ + "<unknown>", /* (6186), */ + "GlobalVariableHostAccessINTEL", /* (6187), */ + "<unknown>", /* (6188), */ + "GlobalVariableFPGADecorationsALTERA / GlobalVariableFPGADecorationsINTEL", /* (6189), */ + /* HOLE */ + "SubgroupBitcastShuffleINTEL", /* (6207), */ + /* HOLE */ + "SubgroupBufferPrefetchINTEL", /* (6220), */ + /* HOLE */ + "Subgroup2DBlockIOINTEL", /* (6228), */ + "Subgroup2DBlockTransformINTEL", /* (6229), */ + "Subgroup2DBlockTransposeINTEL", /* (6230), */ + /* HOLE */ + "SubgroupMatrixMultiplyAccumulateINTEL", /* (6236), */ + /* HOLE */ + "TernaryBitwiseFunctionINTEL", /* (6241), */ + "<unknown>", /* (6242), */ + "UntypedVariableLengthArrayINTEL", /* (6243), */ + "<unknown>", /* (6244), */ + "SpecConditionalINTEL", /* (6245), */ + "FunctionVariantsINTEL", /* (6246), */ + /* HOLE */ + "PredicatedIOINTEL", /* (6257), */ + /* HOLE */ + "RoundedDivideSqrtINTEL", /* (6265), */ + /* HOLE */ + "GroupUniformArithmeticKHR", /* (6400), */ + /* HOLE */ + "TensorFloat32RoundingINTEL", /* (6425), */ + "<unknown>", /* (6426), */ + "MaskedGatherScatterINTEL", /* (6427), */ + /* HOLE */ + "CacheControlsINTEL", /* (6441), */ + /* HOLE */ + "RegisterLimitsINTEL", /* (6460), */ + /* HOLE */ + "BindlessImagesINTEL", /* (6528), */ + /* HOLE */ + "DotProductFloat16AccFloat32VALVE", /* (6912), */ + "DotProductFloat16AccFloat16VALVE", /* (6913), */ + "DotProductBFloat16AccVALVE", /* (6914), */ + "DotProductFloat8AccFloat32VALVE", /* (6915), */ + /* HOLE */ + "IntrinsicSAMSUNG", /* (7041), */ +};
