Allow specifying multiple --device= flags in tooling. (#16132)
diff --git a/runtime/src/iree/base/internal/flags.h b/runtime/src/iree/base/internal/flags.h index 2826efd..a322593 100644 --- a/runtime/src/iree/base/internal/flags.h +++ b/runtime/src/iree/base/internal/flags.h
@@ -227,13 +227,7 @@ // List flag utilities //===----------------------------------------------------------------------===// -// A list of string views referencing flag storage. -typedef struct iree_flag_string_list_t { - // Total number of values in the list. - iree_host_size_t count; - // Value list or NULL if no values. - const iree_string_view_t* values; -} iree_flag_string_list_t; +typedef struct iree_string_view_list_t iree_flag_string_list_t; #if IREE_FLAGS_ENABLE_CLI == 1
diff --git a/runtime/src/iree/base/string_view.h b/runtime/src/iree/base/string_view.h index 313e3db..01e243c 100644 --- a/runtime/src/iree/base/string_view.h +++ b/runtime/src/iree/base/string_view.h
@@ -98,6 +98,14 @@ // Returns a string view initialized with the given string literal. #define IREE_SVL(cstr) iree_string_view_literal(cstr) +// A list of string views. +typedef struct iree_string_view_list_t { + // Total number of values in the list. + iree_host_size_t count; + // Value list or NULL if no values. + const iree_string_view_t* values; +} iree_string_view_list_t; + // Returns true if the two strings are equal (compare == 0). IREE_API_EXPORT bool iree_string_view_equal(iree_string_view_t lhs, iree_string_view_t rhs);
diff --git a/runtime/src/iree/hal/device.c b/runtime/src/iree/hal/device.c index c70fa69..4097a8d 100644 --- a/runtime/src/iree/hal/device.c +++ b/runtime/src/iree/hal/device.c
@@ -12,6 +12,10 @@ #include "iree/hal/detail.h" #include "iree/hal/resource.h" +//===----------------------------------------------------------------------===// +// iree_hal_device_t +//===----------------------------------------------------------------------===// + #define _VTABLE_DISPATCH(device, method_name) \ IREE_HAL_VTABLE_DISPATCH(device, iree_hal_device, method_name) @@ -381,3 +385,62 @@ IREE_TRACE_ZONE_END(z0); return status; } + +//===----------------------------------------------------------------------===// +// iree_hal_device_list_t +//===----------------------------------------------------------------------===// + +IREE_API_EXPORT iree_status_t iree_hal_device_list_allocate( + iree_host_size_t capacity, iree_allocator_t host_allocator, + iree_hal_device_list_t** out_list) { + IREE_ASSERT_ARGUMENT(out_list); + *out_list = NULL; + IREE_TRACE_ZONE_BEGIN(z0); + iree_hal_device_list_t* list = NULL; + iree_host_size_t total_size = + sizeof(*list) + capacity * sizeof(list->devices[0]); + IREE_RETURN_AND_END_ZONE_IF_ERROR( + z0, iree_allocator_malloc(host_allocator, total_size, (void**)&list)); + list->host_allocator = host_allocator; + list->capacity = capacity; + list->count = 0; + *out_list = list; + IREE_TRACE_ZONE_END(z0); + return iree_ok_status(); +} + +IREE_API_EXPORT void iree_hal_device_list_free(iree_hal_device_list_t* list) { + if (!list) return; + IREE_TRACE_ZONE_BEGIN(z0); + iree_allocator_t host_allocator = list->host_allocator; + for (iree_host_size_t i = 0; i < list->count; ++i) { + iree_hal_device_release(list->devices[i]); + } + iree_allocator_free(host_allocator, list); + IREE_TRACE_ZONE_END(z0); +} + +IREE_API_EXPORT iree_status_t iree_hal_device_list_push_back( + iree_hal_device_list_t* list, iree_hal_device_t* device) { + IREE_ASSERT_ARGUMENT(list); + IREE_ASSERT_ARGUMENT(device); + IREE_TRACE_ZONE_BEGIN(z0); + iree_status_t status = iree_ok_status(); + if (list->count + 1 <= list->capacity) { + iree_hal_device_retain(device); + list->devices[list->count++] = device; + } else { + status = iree_make_status(IREE_STATUS_RESOURCE_EXHAUSTED, + "list capacity %" PRIhsz + " reached; no more devices can be added", + list->capacity); + } + IREE_TRACE_ZONE_END(z0); + return status; +} + +IREE_API_EXPORT iree_hal_device_t* iree_hal_device_list_at( + const iree_hal_device_list_t* list, iree_host_size_t i) { + IREE_ASSERT_ARGUMENT(list); + return i < list->count ? list->devices[i] : NULL; +}
diff --git a/runtime/src/iree/hal/device.h b/runtime/src/iree/hal/device.h index cc06cf8..7a04654 100644 --- a/runtime/src/iree/hal/device.h +++ b/runtime/src/iree/hal/device.h
@@ -480,6 +480,36 @@ iree_hal_device_profiling_end(iree_hal_device_t* device); //===----------------------------------------------------------------------===// +// iree_hal_device_list_t +//===----------------------------------------------------------------------===// + +// A fixed-size list of retained devices. +typedef struct iree_hal_device_list_t { + iree_allocator_t host_allocator; + iree_host_size_t capacity; + iree_host_size_t count; + iree_hal_device_t* devices[]; +} iree_hal_device_list_t; + +// Allocates an empty device list with the given capacity. +IREE_API_EXPORT iree_status_t iree_hal_device_list_allocate( + iree_host_size_t capacity, iree_allocator_t host_allocator, + iree_hal_device_list_t** out_list); + +// Frees a device |list|. +IREE_API_EXPORT void iree_hal_device_list_free(iree_hal_device_list_t* list); + +// Pushes a |device| onto the |list| and retains it. +IREE_API_EXPORT iree_status_t iree_hal_device_list_push_back( + iree_hal_device_list_t* list, iree_hal_device_t* device); + +// Returns the device at index |i| in the |list| or NULL if out of range. +// Callers must retain the device if it's possible for the returned pointer to +// live beyond the list. +IREE_API_EXPORT iree_hal_device_t* iree_hal_device_list_at( + const iree_hal_device_list_t* list, iree_host_size_t i); + +//===----------------------------------------------------------------------===// // iree_hal_device_t implementation details //===----------------------------------------------------------------------===//
diff --git a/runtime/src/iree/tooling/context_util.c b/runtime/src/iree/tooling/context_util.c index ccb0d9c..5ec1028 100644 --- a/runtime/src/iree/tooling/context_util.c +++ b/runtime/src/iree/tooling/context_util.c
@@ -196,18 +196,20 @@ IREE_RETURN_AND_END_ZONE_IF_ERROR( z0, iree_hal_module_register_all_types(instance)); - // TODO(multi-device): create multiple devices (maybe with an - // iree_hal_device_list_t helper for retaining/managing the dynamic list). - // Create the device to use. - // In the future this will change to a set of available devices instead. + // Create the device(s) to use. if (iree_string_view_is_empty(default_device_uri)) { default_device_uri = iree_hal_default_device_uri(); } - iree_hal_device_t* device = NULL; + iree_hal_device_list_t* device_list = NULL; IREE_RETURN_AND_END_ZONE_IF_ERROR( - z0, iree_hal_create_device_from_flags( + z0, iree_hal_create_devices_from_flags( iree_hal_available_driver_registry(), default_device_uri, - host_allocator, &device)); + host_allocator, &device_list)); + + // Pick a lead device we'll use for bookkeeping. + iree_hal_device_t* device = iree_hal_device_list_at(device_list, 0); + IREE_ASSERT(device, "require at least one device"); + iree_hal_device_retain(device); // Fetch the allocator from the device to pass back to the caller. iree_hal_allocator_t* device_allocator = iree_hal_device_allocator(device); @@ -216,8 +218,11 @@ // Create HAL module wrapping the device created above. iree_hal_module_flags_t flags = IREE_HAL_MODULE_FLAG_NONE; iree_vm_module_t* module = NULL; - iree_status_t status = iree_hal_module_create( - instance, /*device_count=*/1, &device, flags, host_allocator, &module); + iree_status_t status = + iree_hal_module_create(instance, device_list->count, device_list->devices, + flags, host_allocator, &module); + + iree_hal_device_list_free(device_list); if (iree_status_is_ok(status)) { *out_module = module;
diff --git a/runtime/src/iree/tooling/context_util.h b/runtime/src/iree/tooling/context_util.h index 75a2459..8116e8b 100644 --- a/runtime/src/iree/tooling/context_util.h +++ b/runtime/src/iree/tooling/context_util.h
@@ -51,9 +51,12 @@ // // |default_device_uri| can be specified to provide a default if a device flag // is not provided by the user. -// |out_device| will contain the created device if using the full HAL. +// |out_device| will contain the first created device if using the full HAL. // |out_device_allocator| can be used to allocate buffers for use with the // context and is available in all execution models. +// +// If multiple devices are created the one returned (and it's corresponding +// allocator) are considered the 'lead' device for bookkeeping purposes. iree_status_t iree_tooling_resolve_modules( iree_vm_instance_t* instance, iree_host_size_t user_module_count, iree_vm_module_t** user_modules, iree_string_view_t default_device_uri, @@ -86,9 +89,12 @@ // // |default_device_uri| can be specified to provide a default if a device flag // is not provided by the user. -// |out_device| will contain the created device if using the full HAL. +// |out_device| will contain the first created device if using the full HAL. // |out_device_allocator| can be used to allocate buffers for use with the // context and is available in all execution models. +// +// If multiple devices are created the one returned (and it's corresponding +// allocator) are considered the 'lead' device for bookkeeping purposes. iree_status_t iree_tooling_create_context_from_flags( iree_vm_instance_t* instance, iree_host_size_t user_module_count, iree_vm_module_t** user_modules, iree_string_view_t default_device_uri,
diff --git a/runtime/src/iree/tooling/device_util.c b/runtime/src/iree/tooling/device_util.c index 0a0798a..bd864ad 100644 --- a/runtime/src/iree/tooling/device_util.c +++ b/runtime/src/iree/tooling/device_util.c
@@ -307,6 +307,12 @@ // Collectives configuration //===----------------------------------------------------------------------===// +// TODO(multi-device): support more provider types/have a provider registry. +// MPI is insufficient for heterogeneous/multi-device configurations. Currently +// we set the same provider for every device and that'll really confuse things +// as MPI rank/count configuration is global in the environment and not per +// device. Hosting frameworks/runtimes can set their own providers that have +// more meaningful representation of multi-device/multi-node. iree_status_t iree_hal_device_set_default_channel_provider( iree_hal_device_t* device) { if (!iree_hal_mpi_is_configured()) return iree_ok_status(); @@ -330,63 +336,91 @@ "Use --list_devices/--dump_devices to see available devices and their\n" "canonical URI used with this flag."); -// TODO(#5724): remove this and replace with an iree_hal_device_set_t. -void iree_hal_get_devices_flag_list(iree_host_size_t* out_count, - const iree_string_view_t** out_list) { - *out_count = FLAG_device_list().count; - *out_list = FLAG_device_list().values; +iree_string_view_list_t iree_hal_device_flag_list(void) { + return FLAG_device_list(); } iree_status_t iree_hal_create_device_from_flags( iree_hal_driver_registry_t* driver_registry, iree_string_view_t default_device, iree_allocator_t host_allocator, iree_hal_device_t** out_device) { - iree_string_view_t device_uri = default_device; - const iree_flag_string_list_t list = FLAG_device_list(); - if (list.count == 0) { + iree_hal_device_list_t* device_list = NULL; + IREE_RETURN_IF_ERROR(iree_hal_create_devices_from_flags( + driver_registry, default_device, host_allocator, &device_list)); + iree_hal_device_t* device = iree_hal_device_list_at(device_list, 0); + iree_hal_device_retain(device); + iree_hal_device_list_free(device_list); + *out_device = device; + return iree_ok_status(); +} + +iree_status_t iree_hal_create_devices_from_flags( + iree_hal_driver_registry_t* driver_registry, + iree_string_view_t default_device, iree_allocator_t host_allocator, + iree_hal_device_list_t** out_device_list) { + iree_flag_string_list_t flag_list = FLAG_device_list(); + if (flag_list.count == 0) { // No devices specified. Use default if provided. if (iree_string_view_is_empty(default_device)) { return iree_make_status( IREE_STATUS_INVALID_ARGUMENT, - "no device specified; use --list_devices to see the " - "available devices and specify one with --device="); + "no devices specified; use --list_devices to see the " + "available devices and specify one or more with --device="); } - } else if (list.count > 1) { - // Too many devices for the single device creation function. - return iree_make_status(IREE_STATUS_INVALID_ARGUMENT, - "too many devices specified; only one --device= " - "flag may be provided with this API"); - } else { - // Exactly one device specified. - device_uri = list.values[0]; + flag_list.count = 1; + flag_list.values = &default_device; } IREE_TRACE_ZONE_BEGIN(z0); + IREE_TRACE({ + for (iree_host_size_t i = 0; i < flag_list.count; ++i) { + IREE_TRACE_ZONE_APPEND_TEXT(z0, flag_list.values[i].data, + flag_list.values[i].size); + } + }); - // Create the device, which may be slow and dynamically load big dependencies - // (CUDA, Vulkan, etc). - iree_hal_device_t* device = NULL; + iree_hal_device_list_t* device_list = NULL; IREE_RETURN_AND_END_ZONE_IF_ERROR( - z0, iree_hal_create_device(iree_hal_available_driver_registry(), - device_uri, host_allocator, &device)); + z0, iree_hal_device_list_allocate(flag_list.count, host_allocator, + &device_list)); - // Optionally wrap the base device allocator with caching/pooling. - // Doing this here satisfies the requirement that no buffers have been - // allocated yet - if we returned the device without doing this the caller can - // more easily break the rules. - iree_status_t status = iree_hal_configure_allocator_from_flags(device); + iree_status_t status = iree_ok_status(); + for (iree_host_size_t i = 0; i < flag_list.count; ++i) { + // Create the device, which may be slow and dynamically load big + // dependencies (CUDA, Vulkan, etc). + iree_hal_device_t* device = NULL; + status = iree_hal_create_device(driver_registry, flag_list.values[i], + host_allocator, &device); - // Optionally set a collective channel provider used by devices to initialize - // their default channels. Hosting libraries or applications can do the same - // to interface with their own implementations. - if (iree_status_is_ok(status)) { - status = iree_hal_device_set_default_channel_provider(device); + // Optionally wrap the base device allocator with caching/pooling. + // Doing this here satisfies the requirement that no buffers have been + // allocated yet - if we returned the device without doing this the caller + // can more easily break the rules. + if (iree_status_is_ok(status)) { + status = iree_hal_configure_allocator_from_flags(device); + } + + // Optionally set a collective channel provider used by devices to + // initialize their default channels. Hosting libraries or applications can + // do the same to interface with their own implementations. Note that this + // currently sets the same provider for all devices. + if (iree_status_is_ok(status)) { + status = iree_hal_device_set_default_channel_provider(device); + } + + // Add the device to the list to retain it for the caller. + if (iree_status_is_ok(status)) { + status = iree_hal_device_list_push_back(device_list, device); + } + iree_hal_device_release(device); + + if (!iree_status_is_ok(status)) break; } if (iree_status_is_ok(status)) { - *out_device = device; + *out_device_list = device_list; } else { - iree_hal_device_release(device); + iree_hal_device_list_free(device_list); } IREE_TRACE_ZONE_END(z0); return status;
diff --git a/runtime/src/iree/tooling/device_util.h b/runtime/src/iree/tooling/device_util.h index 68aede9..b9a4330 100644 --- a/runtime/src/iree/tooling/device_util.h +++ b/runtime/src/iree/tooling/device_util.h
@@ -22,9 +22,9 @@ // flags and tools should encourage that. iree_string_view_t iree_hal_default_device_uri(void); -// TODO(#5724): remove this and replace with an iree_hal_device_set_t. -void iree_hal_get_devices_flag_list(iree_host_size_t* out_count, - const iree_string_view_t** out_list); +// Returns a reference to the storage of the --device= flag. +// Changes to flags invalidate the storage. +iree_string_view_list_t iree_hal_device_flag_list(void); // Creates a single device from the --device= flag. // Uses the |default_device| if no flags were specified. @@ -34,6 +34,13 @@ iree_string_view_t default_device, iree_allocator_t host_allocator, iree_hal_device_t** out_device); +// Creates one or more devices from the repeatable --device= flag. +// Uses the |default_device| if no flags were specified. +iree_status_t iree_hal_create_devices_from_flags( + iree_hal_driver_registry_t* driver_registry, + iree_string_view_t default_device, iree_allocator_t host_allocator, + iree_hal_device_list_t** out_device_list); + // Configures the |device| channel provider based on the current environment. // Today this simply checks to see if the process is running under MPI and // initializes that unconditionally.
diff --git a/runtime/src/iree/tooling/trace_replay.c b/runtime/src/iree/tooling/trace_replay.c index 7bfdcf7..fea9aa6 100644 --- a/runtime/src/iree/tooling/trace_replay.c +++ b/runtime/src/iree/tooling/trace_replay.c
@@ -88,9 +88,7 @@ } void iree_trace_replay_set_hal_devices_override( - iree_trace_replay_t* replay, iree_host_size_t device_uri_count, - const iree_string_view_t* device_uris) { - replay->device_uri_count = device_uri_count; + iree_trace_replay_t* replay, iree_string_view_list_t device_uris) { replay->device_uris = device_uris; } @@ -133,7 +131,9 @@ // type: module_load //===----------------------------------------------------------------------===// -// TODO(benvanik): rework this to allow for multiple devices from a device set. +// TODO(multi-device): rework this to allow for multiple devices. Today it +// assumes there's a single device but the |device_node| can specify any +// arbitrary device we want to create. static iree_status_t iree_trace_replay_create_device( iree_trace_replay_t* replay, yaml_node_t* device_node, iree_allocator_t host_allocator, iree_hal_device_t** out_device) { @@ -147,15 +147,17 @@ // Use the provided driver name or override with the --device= flag. iree_string_view_t device_uri = iree_yaml_node_as_string(device_node); if (iree_string_view_is_empty(device_uri)) { - if (replay->device_uri_count != 1) { + if (replay->device_uris.count != 1) { return iree_make_status(IREE_STATUS_INVALID_ARGUMENT, "exactly one device must be specified when none " "is present in the trace file"); } - device_uri = replay->device_uris[0]; + device_uri = replay->device_uris.values[0]; } // Try to create the device. + // NOTE: this is assuming a single device only - we may retire trace replay + // before we ever try to make it work with multiple devices. return iree_hal_create_device_from_flags(replay->driver_registry, device_uri, host_allocator, out_device); } @@ -345,7 +347,7 @@ IREE_TRACE_REPLAY_WRITE_ELEMENT_CASE(UINT_16, uint16_t) IREE_TRACE_REPLAY_WRITE_ELEMENT_CASE(UINT_32, uint32_t) IREE_TRACE_REPLAY_WRITE_ELEMENT_CASE(UINT_64, uint64_t) - // clang-format off + // clang-format off case IREE_HAL_ELEMENT_TYPE_FLOAT_16: *(uint16_t*)dst = iree_math_f32_to_f16((float)value); break;
diff --git a/runtime/src/iree/tooling/trace_replay.h b/runtime/src/iree/tooling/trace_replay.h index 27d670b..ee707ed 100644 --- a/runtime/src/iree/tooling/trace_replay.h +++ b/runtime/src/iree/tooling/trace_replay.h
@@ -71,9 +71,11 @@ // be read on each event. Must remain valid for the lifetime of the replay. iree_const_byte_span_t stdin_contents; + // HAL driver registry used to enumerate and create devices. iree_hal_driver_registry_t* driver_registry; - iree_host_size_t device_uri_count; - const iree_string_view_t* device_uris; + // Unowned reference to a list of device URIs overriding the original devices + // specified in the trace. + iree_string_view_list_t device_uris; // All loaded modules, reset each context load unless // IREE_TRACE_REPLAY_FLAG_REUSE_MODULES is set to preserve them. @@ -114,11 +116,10 @@ void iree_trace_replay_deinitialize(iree_trace_replay_t* replay); // TODO(#5724): remove this and instead provide a device set on initialize. -// Overrides the HAL driver used in the trace with the given |driver|. +// Overrides the HAL driver used in the trace with the given devices. // |device_uris| must remain valid for the lifetime of the replay instance. void iree_trace_replay_set_hal_devices_override( - iree_trace_replay_t* replay, iree_host_size_t device_uri_count, - const iree_string_view_t* device_uris); + iree_trace_replay_t* replay, iree_string_view_list_t device_uris); // Resets replay input/output/blackboard state. void iree_trace_replay_reset(iree_trace_replay_t* replay);
diff --git a/tools/iree-benchmark-trace-main.c b/tools/iree-benchmark-trace-main.c index a992261..5920714 100644 --- a/tools/iree-benchmark-trace-main.c +++ b/tools/iree-benchmark-trace-main.c
@@ -188,12 +188,8 @@ // Query device overrides, if any. When omitted the devices from the trace // file will be used. - // TODO(#5724): remove this and instead provide a device set on initialize. - iree_host_size_t device_uri_count = 0; - const iree_string_view_t* device_uris = NULL; - iree_hal_get_devices_flag_list(&device_uri_count, &device_uris); - iree_trace_replay_set_hal_devices_override(&replay, device_uri_count, - device_uris); + iree_trace_replay_set_hal_devices_override(&replay, + iree_hal_device_flag_list()); // Open trace YAML file from the given file_path. FILE* file = fopen(registration->file_path.data, "rb");
diff --git a/tools/iree-e2e-matmul-test.c b/tools/iree-e2e-matmul-test.c index 5d76c48..b6bdff0 100644 --- a/tools/iree-e2e-matmul-test.c +++ b/tools/iree-e2e-matmul-test.c
@@ -1173,12 +1173,8 @@ // Query device overrides, if any. When omitted the devices from the trace // file will be used. - // TODO(#5724): remove this and instead provide a device set on initialize. - iree_host_size_t device_uri_count = 0; - const iree_string_view_t* device_uris = NULL; - iree_hal_get_devices_flag_list(&device_uri_count, &device_uris); - iree_trace_replay_set_hal_devices_override(&replay, device_uri_count, - device_uris); + iree_trace_replay_set_hal_devices_override(&replay, + iree_hal_device_flag_list()); yaml_parser_t parser; if (!yaml_parser_initialize(&parser)) {
diff --git a/tools/iree-run-mlir-main.cc b/tools/iree-run-mlir-main.cc index 00c62fb..d2eb3f8 100644 --- a/tools/iree-run-mlir-main.cc +++ b/tools/iree-run-mlir-main.cc
@@ -129,14 +129,13 @@ // guesswork. If we can't produce a target backend flag value we bail. // Returns a comma-delimited list of target backends. StatusOr<std::string> InferTargetBackendsFromDevices( - iree_host_size_t device_flag_count, - const iree_string_view_t* device_flag_values) { + iree_string_view_list_t device_uris) { // No-op when no devices specified (probably no HAL). - if (device_flag_count == 0) return ""; + if (device_uris.count == 0) return ""; // If multiple devices were provided we need to target all of them. std::set<std::string> target_backends; - for (iree_host_size_t i = 0; i < device_flag_count; ++i) { - auto target_backend = InferTargetBackendFromDevice(device_flag_values[i]); + for (iree_host_size_t i = 0; i < device_uris.count; ++i) { + auto target_backend = InferTargetBackendFromDevice(device_uris.values[i]); if (!target_backend.empty()) { target_backends.insert(std::move(target_backend)); } @@ -176,20 +175,18 @@ // Query the tooling utils for the --device= flag values. Note that zero or // more devices may be specified. - iree_host_size_t device_flag_count = 0; - const iree_string_view_t* device_flag_values = NULL; - iree_hal_get_devices_flag_list(&device_flag_count, &device_flag_values); + iree_string_view_list_t device_uris = iree_hal_device_flag_list(); // No-op if no target backends or devices are specified - this can be an // intentional decision as the user may be running a program that doesn't use // the HAL. - if (target_backends_flag.empty() && device_flag_count == 0) { + if (target_backends_flag.empty() && device_uris.count == 0) { return OkStatus(); } // No-op if both target backends and devices are set as the user has // explicitly specified a configuration. - if (!target_backends_flag.empty() && device_flag_count > 0) { + if (!target_backends_flag.empty() && device_uris.count > 0) { return OkStatus(); } @@ -197,7 +194,7 @@ // the compiler configuration. This only works if there's a single backend // specified; if the user wants multiple target backends then they must // specify the device(s) to use. - if (device_flag_count == 0) { + if (device_uris.count == 0) { if (target_backends_flag.find(',') != std::string::npos) { return iree_make_status( IREE_STATUS_INVALID_ARGUMENT, @@ -216,9 +213,8 @@ // guesses. In the future we'll have more ways of configuring the compiler // from available runtime devices (not just the target backend but also // target-specific settings). - IREE_ASSIGN_OR_RETURN( - auto target_backends, - InferTargetBackendsFromDevices(device_flag_count, device_flag_values)); + IREE_ASSIGN_OR_RETURN(auto target_backends, + InferTargetBackendsFromDevices(device_uris)); if (!target_backends.empty()) { auto target_backends_flag = std::string("--iree-hal-target-backends=") + target_backends;
diff --git a/tools/iree-run-trace-main.c b/tools/iree-run-trace-main.c index b1b39dc..4bca457 100644 --- a/tools/iree-run-trace-main.c +++ b/tools/iree-run-trace-main.c
@@ -146,12 +146,8 @@ // Query device overrides, if any. When omitted the devices from the trace // file will be used. - // TODO(#5724): remove this and instead provide a device set on initialize. - iree_host_size_t device_uri_count = 0; - const iree_string_view_t* device_uris = NULL; - iree_hal_get_devices_flag_list(&device_uri_count, &device_uris); - iree_trace_replay_set_hal_devices_override(&replay, device_uri_count, - device_uris); + iree_trace_replay_set_hal_devices_override(&replay, + iree_hal_device_flag_list()); yaml_parser_t parser; if (!yaml_parser_initialize(&parser)) {