From 0030787540b7ee5aa88bc4bbed289e02338791b2 Mon Sep 17 00:00:00 2001 From: andraghetti Date: Mon, 26 Oct 2026 11:31:04 +0100 Subject: [PATCH] fix(hrr): regenerate sources for hipKernelSetCacheConfig #12628 appended hipKernelSetCacheConfig to HipDispatchTable without regenerating the HRR sources, so the checked-in capture and playback dispatch, hrr_api_args.h and the API matrix expectations no longer match the headers and ctest hrr-generator-rules fails on develop. Capture records it through a generated shim. Playback is a no-op: its hipKernel_t argument cannot be translated back into a live kernel, the same reason hipKernelSetAttributeForDevice is a no-op. The SDK headers the matrix workloads build against do not declare it, so the matrix lists it as unreachable with the other APIs absent from them. The new runtime slot takes the first compiler API ID and shifts the compiler IDs up by one, so HRR_VERSION goes from 10 to 11. The enable-recording inspector gets the v11 ID of __hipRegisterFatBinary. --- .../hipamd/src/hrr/hip_capture_generated.cpp | 15 ++++++ projects/hrr/DESIGN.md | 15 +++--- projects/hrr/include/hrr/hrr_api_args.h | 38 ++++++++++----- .../hrr/playback/hip_playback_generated.cpp | 48 ++++++++++++------- projects/hrr/skills/enable-recording/SKILL.md | 2 +- .../scripts/inspect_archive.py | 12 ++--- .../integration/hrr_api_matrix_expectations.h | 3 +- .../api-matrix/api_classes_baseline.json | 10 ++-- projects/hrr/tools/api-matrix/api_matrix.yaml | 1 + projects/hrr/tools/gen_hrr_api_args.py | 7 ++- 10 files changed, 100 insertions(+), 51 deletions(-) diff --git a/projects/clr/hipamd/src/hrr/hip_capture_generated.cpp b/projects/clr/hipamd/src/hrr/hip_capture_generated.cpp index c0294170b2ac..806ee3a4a1c9 100644 --- a/projects/clr/hipamd/src/hrr/hip_capture_generated.cpp +++ b/projects/clr/hipamd/src/hrr/hip_capture_generated.cpp @@ -7837,6 +7837,20 @@ static hipError_t capture_hipKernelSetAttributeForDevice(hipKernel_t kernel, hip return r; } +// Generated shim +static hipError_t capture_hipKernelSetCacheConfig(hipKernel_t kernel, hipFuncCache_t config, hipDevice_t dev) { + hipError_t r = g_real_table.hipKernelSetCacheConfig_fn(kernel, config, dev); + if (r == hipSuccess) { + hrr_args_hipKernelSetCacheConfig a{}; + a.ret = static_cast(r); + a.kernel = reinterpret_cast(kernel); + a.config = static_cast(config); + a.dev = static_cast(static_cast(dev)); + hrr_cap::writer::write_event_raw(HRR_API_HIPKERNELSETCACHECONFIG, &a.hdr, sizeof(a)); + } + return r; +} + // Generated shim static hipError_t capture___hipPopCallConfiguration(dim3* gridDim, dim3* blockDim, size_t* sharedMem, hipStream_t* stream) { hipError_t r = g_real_compiler_table.__hipPopCallConfiguration_fn(gridDim, blockDim, sharedMem, stream); @@ -8575,6 +8589,7 @@ void hip_capture_build_table() { g_cap_table.hipDeviceFlushGPUDirectRDMAWrites_fn = capture_hipDeviceFlushGPUDirectRDMAWrites; g_cap_table.hipLibraryGetModule_fn = capture_hipLibraryGetModule; g_cap_table.hipKernelSetAttributeForDevice_fn = capture_hipKernelSetAttributeForDevice; + g_cap_table.hipKernelSetCacheConfig_fn = capture_hipKernelSetCacheConfig; } void hip_capture_build_compiler_table() { diff --git a/projects/hrr/DESIGN.md b/projects/hrr/DESIGN.md index abf37f698abe..900876a49b28 100644 --- a/projects/hrr/DESIGN.md +++ b/projects/hrr/DESIGN.md @@ -180,7 +180,7 @@ the parent that exited cleanly needs no repair. A sub-archive is skipped when payloads, finds it complete in the sense `load_archive` uses. `--info` on a root applies the same check before it shows a process as complete. -### Archive Format (v10) +### Archive Format (v11) ``` capture.hrr/ manifest.json { version, capture_mode, owner_pid, processes[] } @@ -298,7 +298,7 @@ projects/hrr/ — standalone HRR project (portable layer) Not used by capture — it is the format an out-of-tree producer writes and playback reads playback/ - hrr_reader.h/.cpp — archive loader, v10 format; record framing + hrr_reader.h/.cpp — archive loader, v11 format; record framing (read_raw_record / open_record_stream) shared with the region sidecars hrr_region_map.h/.cpp — region timeline: merge, cursor, live block set, @@ -383,13 +383,13 @@ The generator classifies each API: Generated capture shims for manual APIs are pass-throughs (no `write_event()`). When adding HIP API support, update this script to classify the API in the appropriate capture and playback policy sets. APIs requiring non-trivial serialization or replay belong in `MANUAL_CAPTURE_APIS` and/or `MANUAL_PLAYBACK_APIS`; intentionally unsupported replay APIs belong in `NOOP_PLAYBACK_APIS`. -## Archive Format (v10) +## Archive Format (v11) Single-authority definition in `hrr_api_args.h` (auto-generated): ``` HRR_MAGIC = 0x52524845 ("HRRE") -HRR_VERSION = 10 +HRR_VERSION = 11 ``` Version history, so an archive written by an older runtime can be placed: @@ -429,12 +429,15 @@ Version history, so an archive written by an older runtime can be placed: - **v10** puts pinned host snapshot records after a kernel launch's arguments (`num_snapshots` was always 0). A v9 reader would not restore them. See Pinned Host Snapshots below. +- **v11** records `hipKernelSetCacheConfig`, appended to + `HipDispatchTable`, which shifts the compiler API IDs up by one again. A v10 + reader would decode those events as the wrong API. ``` / manifest.json { version, capture_mode, owner_pid, processes[] } (version here is the manifest schema = 1, distinct from the - events.bin HRR_VERSION = 10) + events.bin HRR_VERSION = 11) pid-/ manifest.json { pid, parent_pid, complete, event_count, blob_count } active one line naming the process instance (boot id and @@ -1543,7 +1546,7 @@ The event wire format (finding H5): shrinking `reserved` to 2 bytes), so kernel launches with large serialized payloads (many args / long mangled names / large by-value structs) up to ~4 GiB are recorded normally instead of being dropped at 65535 bytes. This is the change that bumped - `HRR_VERSION` to 4; the current version is 10, see Archive Format above. The + `HRR_VERSION` to 4; the current version is 11, see Archive Format above. The writer's single-record buffer path now writes any oversized record straight through. - **Per-argument size limit (64 KiB) now fails loudly.** Each kernel arg's size is still a `uint16_t`. A by-value struct argument ≥ 64 KiB cannot be represented, so the launch diff --git a/projects/hrr/include/hrr/hrr_api_args.h b/projects/hrr/include/hrr/hrr_api_args.h index 87a9bd6cd851..6544dca057ec 100644 --- a/projects/hrr/include/hrr/hrr_api_args.h +++ b/projects/hrr/include/hrr/hrr_api_args.h @@ -85,8 +85,11 @@ * taking the first compiler ID and shifting the compiler API IDs up by one. * A v8 reader would decode those events as the wrong API. * v10: a kernel launch event carries pinned host snapshot records after its - * arguments (num_snapshots was always 0). A v9 reader would not restore them. */ -#define HRR_VERSION ((uint16_t)10u) + * arguments (num_snapshots was always 0). A v9 reader would not restore them. + * v11: hipKernelSetCacheConfig was appended to HipDispatchTable, taking the + * first compiler ID and shifting the compiler API IDs up by one. + * A v10 reader would decode those events as the wrong API. */ +#define HRR_VERSION ((uint16_t)11u) /* Written once at byte 0 of events.bin. */ #pragma pack(push, 1) @@ -5868,6 +5871,15 @@ typedef struct { int32_t device; } hrr_args_hipKernelSetAttributeForDevice; +/* hipError_t hipKernelSetCacheConfig(hipKernel_t kernel, hipFuncCache_t config, hipDevice_t dev) */ +typedef struct { + hrr_event_header hdr; + int32_t ret; + uint64_t kernel; + int32_t config; + uint64_t dev; +} hrr_args_hipKernelSetCacheConfig; + /* ---- API id enumeration ---- */ typedef enum hrr_api_id { HRR_API_HIPAPINAME = 0, @@ -6418,16 +6430,17 @@ typedef enum hrr_api_id { HRR_API_HIPDEVICEFLUSHGPUDIRECTRDMAWRITES = 545, HRR_API_HIPLIBRARYGETMODULE = 546, HRR_API_HIPKERNELSETATTRIBUTEFORDEVICE = 547, - HRR_API_HIPPOPCALLCONFIGURATION = 548, - HRR_API_HIPPUSHCALLCONFIGURATION = 549, - HRR_API_HIPREGISTERFATBINARY = 550, - HRR_API_HIPREGISTERFUNCTION = 551, - HRR_API_HIPREGISTERMANAGEDVAR = 552, - HRR_API_HIPREGISTERSURFACE = 553, - HRR_API_HIPREGISTERTEXTURE = 554, - HRR_API_HIPREGISTERVAR = 555, - HRR_API_HIPUNREGISTERFATBINARY = 556, - HRR_API_COUNT = 557 + HRR_API_HIPKERNELSETCACHECONFIG = 548, + HRR_API_HIPPOPCALLCONFIGURATION = 549, + HRR_API_HIPPUSHCALLCONFIGURATION = 550, + HRR_API_HIPREGISTERFATBINARY = 551, + HRR_API_HIPREGISTERFUNCTION = 552, + HRR_API_HIPREGISTERMANAGEDVAR = 553, + HRR_API_HIPREGISTERSURFACE = 554, + HRR_API_HIPREGISTERTEXTURE = 555, + HRR_API_HIPREGISTERVAR = 556, + HRR_API_HIPUNREGISTERFATBINARY = 557, + HRR_API_COUNT = 558 } hrr_api_id_t; /* Array of API names indexed by hrr_api_id_t */ @@ -6981,6 +6994,7 @@ const char* const hrr_api_names[HRR_API_COUNT] = { "hipDeviceFlushGPUDirectRDMAWrites", "hipLibraryGetModule", "hipKernelSetAttributeForDevice", + "hipKernelSetCacheConfig", "__hipPopCallConfiguration", "__hipPushCallConfiguration", "__hipRegisterFatBinary", diff --git a/projects/hrr/playback/hip_playback_generated.cpp b/projects/hrr/playback/hip_playback_generated.cpp index 3cb0dcb819c0..c6100545a056 100644 --- a/projects/hrr/playback/hip_playback_generated.cpp +++ b/projects/hrr/playback/hip_playback_generated.cpp @@ -5490,6 +5490,16 @@ static hipError_t playback_hipKernelSetAttributeForDevice(PlaybackContext& ctx, return hipSuccess; } +static hipError_t playback_hipKernelSetCacheConfig(PlaybackContext& ctx, const uint8_t* payload) { + (void)ctx; (void)payload; + static std::atomic warned{false}; + if (!warned.exchange(true)) { + fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelSetCacheConfig — " + "this API is not replayed; results may differ from capture.\n"); + } + return hipSuccess; +} + static hipError_t playback___hipPopCallConfiguration(PlaybackContext& ctx, const uint8_t* payload) { (void)ctx; (void)payload; return hipSuccess; @@ -6084,15 +6094,16 @@ const uint32_t hrr_api_min_payload_size[HRR_API_COUNT] = { static_cast(sizeof(hrr_args_hipDeviceFlushGPUDirectRDMAWrites)), // [545] HRR_API_HIPDEVICEFLUSHGPUDIRECTRDMAWRITES static_cast(sizeof(hrr_args_hipLibraryGetModule)), // [546] HRR_API_HIPLIBRARYGETMODULE static_cast(sizeof(hrr_args_hipKernelSetAttributeForDevice)), // [547] HRR_API_HIPKERNELSETATTRIBUTEFORDEVICE - static_cast(sizeof(hrr_args___hipPopCallConfiguration)), // [548] HRR_API_HIPPOPCALLCONFIGURATION - static_cast(sizeof(hrr_args___hipPushCallConfiguration)), // [549] HRR_API_HIPPUSHCALLCONFIGURATION - static_cast(sizeof(hrr_args___hipRegisterFatBinary)), // [550] HRR_API_HIPREGISTERFATBINARY - static_cast(sizeof(hrr_args___hipRegisterFunction)), // [551] HRR_API_HIPREGISTERFUNCTION - static_cast(sizeof(hrr_args___hipRegisterManagedVar)), // [552] HRR_API_HIPREGISTERMANAGEDVAR - static_cast(sizeof(hrr_args___hipRegisterSurface)), // [553] HRR_API_HIPREGISTERSURFACE - static_cast(sizeof(hrr_args___hipRegisterTexture)), // [554] HRR_API_HIPREGISTERTEXTURE - static_cast(sizeof(hrr_args___hipRegisterVar)), // [555] HRR_API_HIPREGISTERVAR - static_cast(sizeof(hrr_args___hipUnregisterFatBinary)), // [556] HRR_API_HIPUNREGISTERFATBINARY + static_cast(sizeof(hrr_args_hipKernelSetCacheConfig)), // [548] HRR_API_HIPKERNELSETCACHECONFIG + static_cast(sizeof(hrr_args___hipPopCallConfiguration)), // [549] HRR_API_HIPPOPCALLCONFIGURATION + static_cast(sizeof(hrr_args___hipPushCallConfiguration)), // [550] HRR_API_HIPPUSHCALLCONFIGURATION + static_cast(sizeof(hrr_args___hipRegisterFatBinary)), // [551] HRR_API_HIPREGISTERFATBINARY + static_cast(sizeof(hrr_args___hipRegisterFunction)), // [552] HRR_API_HIPREGISTERFUNCTION + static_cast(sizeof(hrr_args___hipRegisterManagedVar)), // [553] HRR_API_HIPREGISTERMANAGEDVAR + static_cast(sizeof(hrr_args___hipRegisterSurface)), // [554] HRR_API_HIPREGISTERSURFACE + static_cast(sizeof(hrr_args___hipRegisterTexture)), // [555] HRR_API_HIPREGISTERTEXTURE + static_cast(sizeof(hrr_args___hipRegisterVar)), // [556] HRR_API_HIPREGISTERVAR + static_cast(sizeof(hrr_args___hipUnregisterFatBinary)), // [557] HRR_API_HIPUNREGISTERFATBINARY }; // ============================================================ @@ -6647,13 +6658,14 @@ hrr_playback_fn_t hrr_playback_dispatch[HRR_API_COUNT] = { playback_hipDeviceFlushGPUDirectRDMAWrites, // [545] HRR_API_HIPDEVICEFLUSHGPUDIRECTRDMAWRITES playback_hipLibraryGetModule, // [546] HRR_API_HIPLIBRARYGETMODULE playback_hipKernelSetAttributeForDevice, // [547] HRR_API_HIPKERNELSETATTRIBUTEFORDEVICE - playback___hipPopCallConfiguration, // [548] HRR_API_HIPPOPCALLCONFIGURATION - playback___hipPushCallConfiguration, // [549] HRR_API_HIPPUSHCALLCONFIGURATION - playback___hipRegisterFatBinary, // [550] HRR_API_HIPREGISTERFATBINARY - playback___hipRegisterFunction, // [551] HRR_API_HIPREGISTERFUNCTION - playback___hipRegisterManagedVar, // [552] HRR_API_HIPREGISTERMANAGEDVAR - playback___hipRegisterSurface, // [553] HRR_API_HIPREGISTERSURFACE - playback___hipRegisterTexture, // [554] HRR_API_HIPREGISTERTEXTURE - playback___hipRegisterVar, // [555] HRR_API_HIPREGISTERVAR - playback___hipUnregisterFatBinary, // [556] HRR_API_HIPUNREGISTERFATBINARY + playback_hipKernelSetCacheConfig, // [548] HRR_API_HIPKERNELSETCACHECONFIG + playback___hipPopCallConfiguration, // [549] HRR_API_HIPPOPCALLCONFIGURATION + playback___hipPushCallConfiguration, // [550] HRR_API_HIPPUSHCALLCONFIGURATION + playback___hipRegisterFatBinary, // [551] HRR_API_HIPREGISTERFATBINARY + playback___hipRegisterFunction, // [552] HRR_API_HIPREGISTERFUNCTION + playback___hipRegisterManagedVar, // [553] HRR_API_HIPREGISTERMANAGEDVAR + playback___hipRegisterSurface, // [554] HRR_API_HIPREGISTERSURFACE + playback___hipRegisterTexture, // [555] HRR_API_HIPREGISTERTEXTURE + playback___hipRegisterVar, // [556] HRR_API_HIPREGISTERVAR + playback___hipUnregisterFatBinary, // [557] HRR_API_HIPUNREGISTERFATBINARY }; diff --git a/projects/hrr/skills/enable-recording/SKILL.md b/projects/hrr/skills/enable-recording/SKILL.md index cf87598eca9d..f1b4ad27530a 100644 --- a/projects/hrr/skills/enable-recording/SKILL.md +++ b/projects/hrr/skills/enable-recording/SKILL.md @@ -136,7 +136,7 @@ What the archive holds, per process, and it is worth reading out to whoever has Apart from the few exceptions in step 2, failed HIP calls are not recorded, and nothing that never crossed a HIP call is. The archive is exactly as sensitive as the data the workload handled, so where it may go has to be agreed before it is uploaded. [PRIVACY.md](../../PRIVACY.md) is the page to hand to whoever approves it. -`verify --json` gives each process's counts and sizes in a form you can attach to the request, and says whether any hardware identifier or code object build information is left (`hardware_ids`; `debug_info_files` for code objects still holding `.comment` or `.debug*` bytes; `path_files` for code objects whose loaded data holds an absolute path; `unchecked_fat_binaries` for the compressed ones it cannot read; `fat_binaries_scanned`, false when the archive's format version is not v8 to v10 and it cannot tell which blobs are fat binaries); the device details are in each `manifest.json`. For a multi-process archive, `hrr-playback --info` against the archive root prints a table covering every process at once. The cross-check in `verify` reports on one process, which is enough to judge the capture and not enough for a disclosure inventory. +`verify --json` gives each process's counts and sizes in a form you can attach to the request, and says whether any hardware identifier or code object build information is left (`hardware_ids`; `debug_info_files` for code objects still holding `.comment` or `.debug*` bytes; `path_files` for code objects whose loaded data holds an absolute path; `unchecked_fat_binaries` for the compressed ones it cannot read; `fat_binaries_scanned`, false when the archive's format version is not v8 to v11 and it cannot tell which blobs are fat binaries); the device details are in each `manifest.json`. For a multi-process archive, `hrr-playback --info` against the archive root prints a table covering every process at once. The cross-check in `verify` reports on one process, which is enough to judge the capture and not enough for a disclosure inventory. If the content is the obstacle, three things exist and none of them is scrubbing. Re-capture the same failure driven by synthetic input, if it still reproduces. Replay the archive yourself and send only the finding, which is a few lines and carries no buffers. Or agree the handling of a production-data transfer before uploading, because that is what this is. diff --git a/projects/hrr/skills/enable-recording/scripts/inspect_archive.py b/projects/hrr/skills/enable-recording/scripts/inspect_archive.py index 2b39f5ca00ed..2282a3654510 100755 --- a/projects/hrr/skills/enable-recording/scripts/inspect_archive.py +++ b/projects/hrr/skills/enable-recording/scripts/inspect_archive.py @@ -83,12 +83,12 @@ # `blobs/` holds buffer contents as well as fat binaries, so the fat binaries # are the blobs a `__hipRegisterFatBinary` record names: its hrr_api_id_t, and # where the record keeps the hash after the event header and `uint64 ret`. -# The id is per archive format version (hrr_api_args.h): v8 put two compiler -# APIs ahead of it, v9 one more, and v10 left it where it was. A v7 archive may -# hold either numbering, so that and any other version leaves the fat binaries -# unscanned. tools/tests/test_skill_api_ids.py fails when HRR_VERSION moves -# past this table. -REGISTER_FAT_BINARY = {8: 549, 9: 550, 10: 550} +# The id is per archive format version (hrr_api_args.h): v8 put two runtime +# APIs ahead of it, v9 one more, v10 left it where it was and v11 one more. A v7 +# archive may hold either numbering, so that and any other version leaves the +# fat binaries unscanned. tools/tests/test_skill_api_ids.py fails when +# HRR_VERSION moves past this table. +REGISTER_FAT_BINARY = {8: 549, 9: 550, 10: 550, 11: 551} FAT_BINARY_HASH_OFFSET = EVENT_HEADER_BYTES + 8 HARDWARE_ID_FIELDS = ("pci", "uuid", "luid") # Capture cannot zero what the GPU loads, so `verify` looks there for strings diff --git a/projects/hrr/tests/integration/hrr_api_matrix_expectations.h b/projects/hrr/tests/integration/hrr_api_matrix_expectations.h index 7b230966f40f..5ddefa89581e 100644 --- a/projects/hrr/tests/integration/hrr_api_matrix_expectations.h +++ b/projects/hrr/tests/integration/hrr_api_matrix_expectations.h @@ -17,7 +17,7 @@ * what keeps the Catch2 tests and the matrix reporter from drifting into * disagreeing about what an API is supposed to do at replay. * - * Generated from 557 HIP APIs. + * Generated from 558 HIP APIs. */ #pragma once @@ -394,6 +394,7 @@ inline constexpr HrrApiExpectation kHrrApiMatrix[] = { {"hipKernelNameRefByPtr", "T4", 1, false, true, false, false}, {"hipKernelSetAttribute", "T4", 1, false, true, false, false}, {"hipKernelSetAttributeForDevice", "T4", 1, false, true, false, false}, + {"hipKernelSetCacheConfig", "T4", 1, false, true, false, false}, {"hipLaunchCooperativeKernel_spt", "T4", 0, false, true, false, false}, {"hipLaunchHostFunc_spt", "T4", 5, false, true, false, false}, {"hipLaunchKernel_spt", "T4", 0, false, true, false, false}, diff --git a/projects/hrr/tools/api-matrix/api_classes_baseline.json b/projects/hrr/tools/api-matrix/api_classes_baseline.json index 0ed2d95b6cc8..a3cd39677eb7 100644 --- a/projects/hrr/tools/api-matrix/api_classes_baseline.json +++ b/projects/hrr/tools/api-matrix/api_classes_baseline.json @@ -1,9 +1,9 @@ { - "capture_class.GENERATED": 500, + "capture_class.GENERATED": 501, "capture_class.MANUAL": 56, "capture_class.PASSTHROUGH_ONLY": 1, "observable_class.ERROR_STUB": 4, - "observable_class.NOOP": 221, + "observable_class.NOOP": 222, "observable_class.REAL": 320, "observable_class.UNREPLAYABLE": 12, "payload_loss.BIG_STRUCT_BY_VALUE": 8, @@ -15,10 +15,10 @@ "replay_class.ERROR_STUB": 4, "replay_class.GENERATED": 205, "replay_class.MANUAL": 101, - "replay_class.NOOP": 221, + "replay_class.NOOP": 222, "replay_class.SPECIAL": 6, "replay_class.UNREPLAYABLE": 12, "table.compiler": 9, - "table.runtime": 548, - "total": 557 + "table.runtime": 549, + "total": 558 } diff --git a/projects/hrr/tools/api-matrix/api_matrix.yaml b/projects/hrr/tools/api-matrix/api_matrix.yaml index f4f4741300d3..832c3da85888 100644 --- a/projects/hrr/tools/api-matrix/api_matrix.yaml +++ b/projects/hrr/tools/api-matrix/api_matrix.yaml @@ -578,6 +578,7 @@ unreachable: - hipLibraryGetGlobal - hipLibraryGetManaged - hipKernelSetAttributeForDevice + - hipKernelSetCacheConfig - hipOccupancyMaxActiveClusters - hipOccupancyMaxPotentialClusterSize - hipDeviceFlushGPUDirectRDMAWrites diff --git a/projects/hrr/tools/gen_hrr_api_args.py b/projects/hrr/tools/gen_hrr_api_args.py index bd93f9b12978..f429af126c20 100644 --- a/projects/hrr/tools/gen_hrr_api_args.py +++ b/projects/hrr/tools/gen_hrr_api_args.py @@ -2061,8 +2061,11 @@ def validate_capture_coverage(entries: List[ApiEntry], * taking the first compiler ID and shifting the compiler API IDs up by one. * A v8 reader would decode those events as the wrong API. * v10: a kernel launch event carries pinned host snapshot records after its - * arguments (num_snapshots was always 0). A v9 reader would not restore them. */ -#define HRR_VERSION ((uint16_t)10u) + * arguments (num_snapshots was always 0). A v9 reader would not restore them. + * v11: hipKernelSetCacheConfig was appended to HipDispatchTable, taking the + * first compiler ID and shifting the compiler API IDs up by one. + * A v10 reader would decode those events as the wrong API. */ +#define HRR_VERSION ((uint16_t)11u) /* Written once at byte 0 of events.bin. */ #pragma pack(push, 1)