[GSD-13815] Appending a regular command list to an idle immediate command list aborts in LinearStream::getSpace when a UC tag update is pending #1027

// Appending a regular command list to an idle in-order immediate command list aborts in
// LinearStream::getSpace once the CSR has a pending UC tag update.
//
// cc -O2 -o repro repro.c -I<level-zero include> -L<loader dir> -lze_loader
// ./repro [iterations]

#include <level_zero/ze_api.h>
#include <stdio.h>
#include <stdlib.h>

#define CHECK(call)                                                            \
    do {                                                                       \
        ze_result_t res_ = (call);                                             \
        if (res_ != ZE_RESULT_SUCCESS) {                                       \
            fprintf(stderr, "%s failed: 0x%x (line %d)\n", #call, res_,        \
                    __LINE__);                                                 \
            exit(1);                                                           \
        }                                                                      \
    } while (0)

int main(int argc, char **argv) {
    int iterations = argc > 1 ? atoi(argv[1]) : 10000;

    CHECK(zeInit(0));
    uint32_t count = 1;
    ze_driver_handle_t driver;
    CHECK(zeDriverGet(&count, &driver));
    count = 1;
    ze_device_handle_t device;
    CHECK(zeDeviceGet(driver, &count, &device));

    ze_device_properties_t props = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
    CHECK(zeDeviceGetProperties(device, &props));
    printf("device: %s\n", props.name);

    ze_context_desc_t context_desc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC};
    ze_context_handle_t context;
    CHECK(zeContextCreate(driver, &context_desc, &context));

    // compute engine group
    uint32_t ngroups = 0;
    CHECK(zeDeviceGetCommandQueueGroupProperties(device, &ngroups, NULL));
    ze_command_queue_group_properties_t groups[16];
    for (uint32_t i = 0; i < ngroups && i < 16; i++)
        groups[i] = (ze_command_queue_group_properties_t){
            ZE_STRUCTURE_TYPE_COMMAND_QUEUE_GROUP_PROPERTIES};
    CHECK(zeDeviceGetCommandQueueGroupProperties(device, &ngroups, groups));
    uint32_t ordinal = 0;
    for (uint32_t i = 0; i < ngroups; i++)
        if (groups[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) {
            ordinal = i;
            break;
        }

    ze_command_queue_desc_t queue_desc = {ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC};
    queue_desc.ordinal = ordinal;
    queue_desc.flags = ZE_COMMAND_QUEUE_FLAG_IN_ORDER;
    queue_desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
    ze_command_list_handle_t immediate;
    CHECK(zeCommandListCreateImmediate(context, device, &queue_desc, &immediate));

    ze_command_list_desc_t list_desc = {ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC};
    list_desc.commandQueueGroupOrdinal = ordinal;
    list_desc.flags = ZE_COMMAND_LIST_FLAG_IN_ORDER;
    ze_command_list_handle_t regular;
    CHECK(zeCommandListCreate(context, device, &list_desc, &regular));

    const size_t size = 4096;
    ze_device_mem_alloc_desc_t mem_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC};
    void *a, *b;
    CHECK(zeMemAllocDevice(context, &mem_desc, size, 64, device, &a));
    CHECK(zeMemAllocDevice(context, &mem_desc, size, 64, device, &b));

    for (int i = 0; i < iterations; i++) {
        // work on the immediate list, which consumes space in the CSR's command buffer;
        // when that buffer is replaced, the CSR schedules a UC tag update for its next flush
        CHECK(zeCommandListAppendMemoryCopy(immediate, b, a, size, NULL, 0, NULL));
        CHECK(zeCommandListHostSynchronize(immediate, UINT64_MAX));

        // append a regular command list to the now idle immediate list: with nothing to
        // dispatch from the queue, the regular list's own buffer becomes the batch buffer
        CHECK(zeCommandListReset(regular));
        for (int j = 0; j < 4; j++) {
            uint32_t pattern = i + j;
            CHECK(zeCommandListAppendMemoryFill(regular, a, &pattern, sizeof(pattern),
                                                size, NULL, 0, NULL));
        }
        CHECK(zeCommandListClose(regular));
        CHECK(zeCommandListImmediateAppendCommandListsExp(immediate, 1, &regular, NULL,
                                                          0, NULL));
        CHECK(zeCommandListHostSynchronize(immediate, UINT64_MAX));

        if ((i + 1) % 1000 == 0)
            printf("%d iterations\n", i + 1);
    }

    printf("done\n");
    CHECK(zeMemFree(context, a));
    CHECK(zeMemFree(context, b));
    CHECK(zeCommandListDestroy(regular));
    CHECK(zeCommandListDestroy(immediate));
    CHECK(zeContextDestroy(context));
    return 0;
}