Skip to content

Commit eec9316

Browse files
benvanikbenvanik
authored
Adding support for #hal.device.optimal<...> through to runtime. (#20879)
This is an experimental approach for representing a set of device affinities that are able to be resolved at runtime. Currently this is limited to allocation-related ops but may be extended in the future to allow for runtime-provided device rankings based on benchmarked performance. The new `#hal.device.optimal<...>` affinity attribute represents a set of affinities that an operation is able to execute with. The expectation is that the exact affinity can be resolved during compilation if sufficient information is available (TBD) or at runtime based on a user-provided policy (`iree_hal_module_device_policy_t`). As with other treatments of device topology in the runtime this policy is left to the hosting framework or application to decide how they want to configure their overall topology. The common IREE command line tooling adds a `--device_lead_allocator=N` flag to let the user denote which device ordinal (of `--device=` flags) is to be chosen when a `#hal.device.optimal` request makes it all the way to runtime. For simple cases of CPU+accelerator this allows for hack-free ways to indicate the lead allocator that is responsible for any buffer allocation that is used on multiple devices. The `#hal.device.optimal<...>` attr lowers to a `hal.allocator.select` op/runtime call that takes a list of devices/queue masks along with the memory types and buffer usage of the request and returns the selected device/queue mask. Size is not included such that the selection can be memoized across an entire program at initialization time. A pass is added that runs at the same time as device query memoization to hoist the selection into globals. Future changes can enhance the pass to fold the selection when sufficient information has been provided. Future work on #20855 will result in affinity assignment on resource allocations lowering into this new `#hal.device.optimal<...>` attr and deallocations switching to either use the recently added `origin` attr or the same optimal attr (given that it should be consistent and provides more information). Future work on #20856 will ensure that allocations that may be used on multiple devices (regardless of whether runtime-selected) get the appropriate bits set but that may require #20854. Progress on #20851. Progress on #20855 (analysis will lower into this attr). Progress on #20856 (will be used to set bits). Fixes #20857.
1 parent deaf026 commit eec9316

File tree

42 files changed

+1350
-109
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

42 files changed

+1350
-109
lines changed

‎compiler/src/iree/compiler/Bindings/Native/Transforms/test/wrap_entry_points_coarse_fences.mlir‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -185,7 +185,7 @@ util.func private @pinnedImport(tensor<2xi32> {iree.abi.affinity = #hal.device.a
185185
}
186186

187187
// CHECK: util.func private @_pinnedImport(%[[ARG_TENSOR:.+]]: tensor<2xi32>) -> tensor<2xi32> {
188-
// CHECK-DAG: %[[DEVICE_C:.+]] = hal.device.resolve on(<@dev_c>) : !hal.device
188+
// CHECK-DAG: %[[DEVICE_C:.+]] = hal.device.resolve on(#hal.device.affinity<@dev_c>) : !hal.device
189189
// CHECK-DAG: %[[ARG_FENCE:.+]] = hal.fence.create device(%[[DEVICE_C]] : !hal.device) flags("None") : !hal.fence
190190
// CHECK-DAG: %[[ARG_READY:.+]] = hal.tensor.barrier join(%[[ARG_TENSOR]] : tensor<2xi32>) => %[[ARG_FENCE]] : !hal.fence
191191
// CHECK-DAG: %[[ARG_VIEW:.+]] = hal.tensor.export on(#hal.device.affinity<@dev_a>) %[[ARG_READY]] : tensor<2xi32> -> !hal.buffer_view

‎compiler/src/iree/compiler/ConstEval/Runtime.cpp‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -469,10 +469,11 @@ LogicalResult CompiledBinary::initialize(Location loc, void *data,
469469
// Create hal module.
470470
if (iree_status_is_ok(status)) {
471471
std::array<iree_hal_device_t *, 1> devices = {device.get()};
472-
status = iree_hal_module_create(runtime.instance.get(), devices.size(),
473-
devices.data(), IREE_HAL_MODULE_FLAG_NONE,
474-
iree_hal_module_debug_sink_stdio(stderr),
475-
iree_allocator_system(), &hal_module);
472+
status = iree_hal_module_create(
473+
runtime.instance.get(), iree_hal_module_device_policy_default(),
474+
devices.size(), devices.data(), IREE_HAL_MODULE_FLAG_NONE,
475+
iree_hal_module_debug_sink_stdio(stderr), iree_allocator_system(),
476+
&hal_module);
476477
}
477478

478479
// Bytecode module.

‎compiler/src/iree/compiler/Dialect/HAL/Analysis/Attributes/DeviceTargetPVS.cpp‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -171,6 +171,26 @@ void DeviceTargetValuePVS::initializeValue(Value value, DFX::Solver &solver) {
171171
}
172172
}
173173
}
174+
175+
// If the value is defined by a select op we can initialize the set and
176+
// finalize the attribute immediately.
177+
if (auto selectOp = dyn_cast_if_present<IREE::HAL::AllocatorSelectAttrOp>(
178+
value.getDefiningOp())) {
179+
for (auto affinityAttr : selectOp.getOptimalSet().getAffinities()) {
180+
if (auto deviceAffinityAttr =
181+
dyn_cast<IREE::HAL::DeviceAffinityAttr>(affinityAttr)) {
182+
auto *globalInfo = solver.getExplorer().queryGlobalInfoFrom(
183+
deviceAffinityAttr.getDevice().getLeafReference(), selectOp);
184+
assert(globalInfo && "must have global defined");
185+
auto &globalPVS = solver.getElementFor<DeviceTargetGlobalPVS>(
186+
*this, Position::forOperation(globalInfo->op),
187+
DFX::Resolution::REQUIRED);
188+
unionAssumed(globalPVS.getState());
189+
}
190+
}
191+
indicateOptimisticFixpoint();
192+
return;
193+
}
174194
}
175195

176196
ChangeStatus DeviceTargetValuePVS::updateValue(Value value,

‎compiler/src/iree/compiler/Dialect/HAL/Conversion/HALToVM/ConvertAllocatorOps.cpp‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
// See https://llvm.org/LICENSE.txt for license information.
55
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
66

7+
#include "iree/compiler/Dialect/HAL/Conversion/HALToVM/Patterns.h"
78
#include "iree/compiler/Dialect/HAL/IR/HALOps.h"
89
#include "iree/compiler/Dialect/VM/Conversion/ImportUtils.h"
910
#include "iree/compiler/Dialect/VM/IR/VMOps.h"
@@ -13,6 +14,51 @@ namespace mlir::iree_compiler {
1314

1415
namespace {
1516

17+
class AllocatorSelectOpConversion
18+
: public OpConversionPattern<IREE::HAL::AllocatorSelectOp> {
19+
public:
20+
AllocatorSelectOpConversion(TypeConverter &typeConverter,
21+
MLIRContext *context, SymbolTable &importSymbols)
22+
: OpConversionPattern(typeConverter, context) {
23+
importOp = importSymbols.lookup<IREE::VM::ImportOp>("hal.allocator.select");
24+
assert(importOp);
25+
}
26+
27+
LogicalResult
28+
matchAndRewrite(IREE::HAL::AllocatorSelectOp op, OpAdaptor adaptor,
29+
ConversionPatternRewriter &rewriter) const override {
30+
auto importType = importOp.getFunctionType();
31+
auto i32Type = rewriter.getI32Type();
32+
33+
SmallVector<Value> callOperands = {
34+
castToImportType(adaptor.getMemoryTypes(), i32Type, rewriter),
35+
castToImportType(adaptor.getBufferUsage(), i32Type, rewriter),
36+
getFlagsI64(op.getLoc(), {}, rewriter),
37+
};
38+
SmallVector<int16_t> segmentSizes = {
39+
/*memory_types=*/-1,
40+
/*buffer_usage=*/-1,
41+
/*flags=*/-1,
42+
/*from=*/
43+
static_cast<int16_t>(adaptor.getDevices().size()),
44+
};
45+
for (auto [device, queueAffinity] :
46+
llvm::zip_equal(adaptor.getDevices(), adaptor.getQueueAffinities())) {
47+
callOperands.push_back(device);
48+
callOperands.push_back(queueAffinity);
49+
}
50+
51+
auto callOp = rewriter.replaceOpWithNewOp<IREE::VM::CallVariadicOp>(
52+
op, SymbolRefAttr::get(importOp), importType.getResults(), segmentSizes,
53+
importType.getInputs(), callOperands);
54+
copyImportAttrs(importOp, callOp);
55+
return success();
56+
}
57+
58+
private:
59+
mutable IREE::VM::ImportOp importOp;
60+
};
61+
1662
class AllocatorAllocateOpConversion
1763
: public OpConversionPattern<IREE::HAL::AllocatorAllocateOp> {
1864
public:
@@ -103,6 +149,8 @@ void populateHALAllocatorToVMPatterns(MLIRContext *context,
103149
SymbolTable &importSymbols,
104150
TypeConverter &typeConverter,
105151
RewritePatternSet &patterns) {
152+
patterns.insert<AllocatorSelectOpConversion>(typeConverter, context,
153+
importSymbols);
106154
patterns.insert<AllocatorAllocateOpConversion>(typeConverter, context,
107155
importSymbols);
108156
patterns.insert<AllocatorImportOpConversion>(typeConverter, context,

‎compiler/src/iree/compiler/Dialect/HAL/Conversion/HALToVM/test/allocator_ops.mlir‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,28 @@
11
// RUN: iree-opt --split-input-file --canonicalize --iree-vm-conversion %s | FileCheck %s
22

3+
// CHECK-LABEL: vm.func private @allocatorSelect
4+
// CHECK-SAME: (%[[DEVICE_A:.+]]: !vm.ref<!hal.device>, %[[AFFINITY_A:.+]]: i64, %[[DEVICE_B:.+]]: !vm.ref<!hal.device>, %[[AFFINITY_B:.+]]: i64)
5+
util.func public @allocatorSelect(%device_a: !hal.device, %affinity_a: i64, %device_b: !hal.device, %affinity_b: i64) -> (!hal.device, i64) {
6+
// CHECK-DAG: %[[TYPE:.+]] = vm.const.i32 2
7+
%type = arith.constant 2 : i32
8+
// CHECK-DAG: %[[USAGE:.+]] = vm.const.i32 3
9+
%usage = arith.constant 3 : i32
10+
// CHECK-DAG: %[[FLAGS:.+]] = vm.const.i64.zero
11+
// CHECK: %[[DEVICE_AFFINITY:.+]]:2 = vm.call.variadic @hal.allocator.select(
12+
// CHECK-SAME: %[[TYPE]], %[[USAGE]], %[[FLAGS]],
13+
// CHECK-SAME: [(%[[DEVICE_A]], %[[AFFINITY_A]]), (%[[DEVICE_B]], %[[AFFINITY_B]])]
14+
%device, %queue_affinity = hal.allocator.select
15+
from([
16+
(%device_a, %affinity_a : !hal.device, i64),
17+
(%device_b, %affinity_b : !hal.device, i64)
18+
])
19+
type(%type) usage(%usage) : !hal.device, i64
20+
// CHECK: vm.return %[[DEVICE_AFFINITY]]#0, %[[DEVICE_AFFINITY]]#1
21+
util.return %device, %queue_affinity : !hal.device, i64
22+
}
23+
24+
// -----
25+
326
// CHECK-LABEL: vm.func private @allocatorAllocate
427
util.func public @allocatorAllocate(%arg0 : !hal.allocator) -> !hal.buffer {
528
// CHECK-DAG: %[[SIZE:.+]] = vm.const.i64 1024

‎compiler/src/iree/compiler/Dialect/HAL/Conversion/StreamToHAL/Patterns.cpp‎

Lines changed: 16 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -87,20 +87,21 @@ struct ResourceAllocOpPattern
8787
LogicalResult
8888
matchAndRewrite(IREE::Stream::ResourceAllocOp allocOp, OpAdaptor adaptor,
8989
ConversionPatternRewriter &rewriter) const override {
90-
auto [allocator, queueAffinity] =
91-
lookupAllocatorAndQueueAffinityFor(allocOp, rewriter);
9290
auto bufferType = rewriter.getType<IREE::HAL::BufferType>();
93-
9491
auto resourceType =
9592
cast<IREE::Stream::ResourceType>(allocOp.getResult().getType());
96-
9793
auto memoryTypes = IREE::HAL::MemoryTypeBitfield::None;
9894
auto bufferUsage = IREE::HAL::BufferUsageBitfield::None;
9995
if (failed(deriveAllowedResourceBufferBits(allocOp.getLoc(), resourceType,
10096
memoryTypes, bufferUsage))) {
10197
return failure();
10298
}
10399

100+
// Lookup the appropriate allocator/queue for allocation based on the buffer
101+
// propreties.
102+
auto [allocator, queueAffinity] = lookupAllocatorAndQueueAffinityFor(
103+
allocOp, memoryTypes, bufferUsage, rewriter);
104+
104105
rewriter.replaceOpWithNewOp<IREE::HAL::AllocatorAllocateOp>(
105106
allocOp, bufferType, allocator, queueAffinity, memoryTypes, bufferUsage,
106107
adaptor.getStorageSize());
@@ -115,10 +116,6 @@ struct ResourceAllocaOpPattern
115116
matchAndRewrite(IREE::Stream::ResourceAllocaOp allocaOp, OpAdaptor adaptor,
116117
ConversionPatternRewriter &rewriter) const override {
117118
auto loc = allocaOp.getLoc();
118-
auto [device, queueAffinity] =
119-
lookupDeviceAndQueueAffinityFor(allocaOp, rewriter);
120-
auto bufferType = rewriter.getType<IREE::HAL::BufferType>();
121-
122119
auto resourceType =
123120
cast<IREE::Stream::ResourceType>(allocaOp.getResult().getType());
124121
auto memoryTypes = IREE::HAL::MemoryTypeBitfield::None;
@@ -127,6 +124,12 @@ struct ResourceAllocaOpPattern
127124
bufferUsage))) {
128125
return failure();
129126
}
127+
auto bufferType = rewriter.getType<IREE::HAL::BufferType>();
128+
129+
// Lookup the appropriate device/queue for allocation based on the buffer
130+
// propreties.
131+
auto [device, queueAffinity] = lookupDeviceAndQueueAffinityFor(
132+
allocaOp, memoryTypes, bufferUsage, rewriter);
130133

131134
// Behavior flags.
132135
IREE::HAL::AllocaFlagBitfield flags = IREE::HAL::AllocaFlagBitfield::None;
@@ -239,12 +242,9 @@ struct ResourceTryMapOpPattern
239242
LogicalResult
240243
matchAndRewrite(IREE::Stream::ResourceTryMapOp tryMapOp, OpAdaptor adaptor,
241244
ConversionPatternRewriter &rewriter) const override {
242-
auto [allocator, queueAffinity] =
243-
lookupAllocatorAndQueueAffinityFor(tryMapOp, rewriter);
244245
auto resourceType =
245246
llvm::cast<IREE::Stream::ResourceType>(tryMapOp.getResult().getType());
246247
auto bufferType = rewriter.getType<IREE::HAL::BufferType>();
247-
248248
auto memoryTypes = IREE::HAL::MemoryTypeBitfield::None;
249249
auto bufferUsage = IREE::HAL::BufferUsageBitfield::None;
250250
switch (resourceType.getLifetime()) {
@@ -280,6 +280,11 @@ struct ResourceTryMapOpPattern
280280
break;
281281
}
282282

283+
// Lookup the appropriate allocator/queue for allocation based on the buffer
284+
// propreties.
285+
auto [allocator, queueAffinity] = lookupAllocatorAndQueueAffinityFor(
286+
tryMapOp, memoryTypes, bufferUsage, rewriter);
287+
283288
rewriter.replaceOpWithNewOp<IREE::HAL::AllocatorImportOp>(
284289
tryMapOp, rewriter.getI1Type(), bufferType, allocator, queueAffinity,
285290
memoryTypes, bufferUsage, adaptor.getSource(),

‎compiler/src/iree/compiler/Dialect/HAL/Conversion/StreamToHAL/Utils.cpp‎

Lines changed: 35 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,10 @@ namespace mlir::iree_compiler {
2424

2525
Value lookupDeviceFor(Operation *op, OpBuilder &builder) {
2626
auto affinityAttr = IREE::Stream::AffinityAttr::lookupOrDefault(op);
27+
if (isa<IREE::HAL::DeviceOptimalAttr>(affinityAttr)) {
28+
llvm::report_fatal_error("#hal.device.optimal not supported on op type " +
29+
op->getName().getStringRef());
30+
}
2731
auto resolveOp = builder.create<IREE::Stream::ContextResolveOp>(
2832
op->getLoc(),
2933
TypeRange{
@@ -36,6 +40,10 @@ Value lookupDeviceFor(Operation *op, OpBuilder &builder) {
3640
std::tuple<Value, Value> lookupDeviceAndQueueAffinityFor(Operation *op,
3741
OpBuilder &builder) {
3842
auto affinityAttr = IREE::Stream::AffinityAttr::lookupOrDefault(op);
43+
if (isa<IREE::HAL::DeviceOptimalAttr>(affinityAttr)) {
44+
llvm::report_fatal_error("#hal.device.optimal not supported on op type " +
45+
op->getName().getStringRef());
46+
}
3947
auto resolveOp = builder.create<IREE::Stream::ContextResolveOp>(
4048
op->getLoc(),
4149
TypeRange{
@@ -46,8 +54,27 @@ std::tuple<Value, Value> lookupDeviceAndQueueAffinityFor(Operation *op,
4654
return std::make_tuple(resolveOp.getResult(0), resolveOp.getResult(1));
4755
}
4856

57+
std::tuple<Value, Value> lookupDeviceAndQueueAffinityFor(
58+
Operation *op, IREE::HAL::MemoryTypeBitfield memoryTypes,
59+
IREE::HAL::BufferUsageBitfield bufferUsage, OpBuilder &builder) {
60+
// Emit a select op to let the runtime decide which device/queue affinity to
61+
// use if required.
62+
auto affinityAttr = IREE::Stream::AffinityAttr::lookupOrDefault(op);
63+
if (auto optimalAttr = dyn_cast<IREE::HAL::DeviceOptimalAttr>(affinityAttr)) {
64+
auto selectOp = builder.create<IREE::HAL::AllocatorSelectAttrOp>(
65+
op->getLoc(), optimalAttr, memoryTypes, bufferUsage);
66+
return {selectOp.getResult(0), selectOp.getResult(1)};
67+
}
68+
// Unconditionally routed affinities go down the normal resolve path.
69+
return lookupDeviceAndQueueAffinityFor(op, builder);
70+
}
71+
4972
Value lookupAllocatorFor(Operation *op, OpBuilder &builder) {
5073
auto affinityAttr = IREE::Stream::AffinityAttr::lookupOrDefault(op);
74+
if (isa<IREE::HAL::DeviceOptimalAttr>(affinityAttr)) {
75+
llvm::report_fatal_error("#hal.device.optimal not supported on op type " +
76+
op->getName().getStringRef());
77+
}
5178
auto resolveOp = builder.create<IREE::Stream::ContextResolveOp>(
5279
op->getLoc(),
5380
TypeRange{
@@ -57,17 +84,14 @@ Value lookupAllocatorFor(Operation *op, OpBuilder &builder) {
5784
return resolveOp.getResult(0);
5885
}
5986

60-
std::tuple<Value, Value>
61-
lookupAllocatorAndQueueAffinityFor(Operation *op, OpBuilder &builder) {
62-
auto affinityAttr = IREE::Stream::AffinityAttr::lookupOrDefault(op);
63-
auto resolveOp = builder.create<IREE::Stream::ContextResolveOp>(
64-
op->getLoc(),
65-
TypeRange{
66-
builder.getType<IREE::HAL::AllocatorType>(),
67-
builder.getI64Type(),
68-
},
69-
affinityAttr);
70-
return std::make_tuple(resolveOp.getResult(0), resolveOp.getResult(1));
87+
std::tuple<Value, Value> lookupAllocatorAndQueueAffinityFor(
88+
Operation *op, IREE::HAL::MemoryTypeBitfield memoryTypes,
89+
IREE::HAL::BufferUsageBitfield bufferUsage, OpBuilder &builder) {
90+
auto [device, queueAffinity] =
91+
lookupDeviceAndQueueAffinityFor(op, memoryTypes, bufferUsage, builder);
92+
Value allocator =
93+
builder.create<IREE::HAL::DeviceAllocatorOp>(op->getLoc(), device);
94+
return {allocator, queueAffinity};
7195
}
7296

7397
Value getOrCreateWaitFence(Location loc, Value timepointFence,

‎compiler/src/iree/compiler/Dialect/HAL/Conversion/StreamToHAL/Utils.h‎

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,13 +25,21 @@ Value lookupDeviceFor(Operation *op, OpBuilder &builder);
2525
std::tuple<Value, Value> lookupDeviceAndQueueAffinityFor(Operation *op,
2626
OpBuilder &builder);
2727

28+
// Returns a !hal.device and queue affinity i64 for the affinity specified on
29+
// |op| for use as an allocation. This may insert a runtime device selection
30+
// op to resolve the responsible allocator.
31+
std::tuple<Value, Value> lookupDeviceAndQueueAffinityFor(
32+
Operation *op, IREE::HAL::MemoryTypeBitfield memoryTypes,
33+
IREE::HAL::BufferUsageBitfield bufferUsage, OpBuilder &builder);
34+
2835
// Returns the !hal.allocator for the affinity specified on |op|.
2936
Value lookupAllocatorFor(Operation *op, OpBuilder &builder);
3037

3138
// Returns a !hal.allocator and queue affinity i64 for the affinity specified on
3239
// |op|.
33-
std::tuple<Value, Value> lookupAllocatorAndQueueAffinityFor(Operation *op,
34-
OpBuilder &builder);
40+
std::tuple<Value, Value> lookupAllocatorAndQueueAffinityFor(
41+
Operation *op, IREE::HAL::MemoryTypeBitfield memoryTypes,
42+
IREE::HAL::BufferUsageBitfield bufferUsage, OpBuilder &builder);
3543

3644
// Returns the |timepointFence| or a util.null if the wait is to be ignored.
3745
Value getOrCreateWaitFence(Location loc, Value timepointFence,

‎compiler/src/iree/compiler/Dialect/HAL/Conversion/StreamToHAL/test/resource_ops.mlir‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,25 @@ util.func public @resourceAllocaAwait(%size: index, %await_timepoint: !stream.ti
6060

6161
// -----
6262

63+
util.global private @device_a : !hal.device
64+
util.global private @device_b : !hal.device
65+
66+
// CHECK-LABEL: @resourceAllocaOptimal
67+
// CHECK-SAME: (%[[SIZE:.+]]: index)
68+
util.func public @resourceAllocaOptimal(%size: index) -> (!stream.resource<transient>, !stream.timepoint) {
69+
// CHECK: %[[DEVICE:.+]], %[[QUEUE_AFFINITY:.+]] = hal.allocator.select.attr
70+
// CHECK-SAME: from(#hal.device.optimal<[#hal.device.affinity<@device_a>, #hal.device.affinity<@device_b>]>)
71+
// CHECK-SAME: type("DeviceVisible|DeviceLocal")
72+
// CHECK-SAME: usage("{{.+}}Transfer{{.+}}DispatchStorage")
73+
// CHECK: %[[RET0:.+]] = hal.device.queue.alloca
74+
// CHECK-SAME: <%[[DEVICE]] : !hal.device>
75+
// CHECK-SAME: affinity(%[[QUEUE_AFFINITY]])
76+
%0:2 = stream.resource.alloca uninitialized on(#hal.device.optimal<[#hal.device.affinity<@device_a>, #hal.device.affinity<@device_b>]>) : !stream.resource<transient>{%size} => !stream.timepoint
77+
util.return %0#0, %0#1 : !stream.resource<transient>, !stream.timepoint
78+
}
79+
80+
// -----
81+
6382
util.global private @device : !hal.device
6483

6584
// CHECK-LABEL: @resourceDealloca

0 commit comments

Comments
 (0)