1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
// RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \
// RUN: -convert-arith-to-llvm \
// RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \
// RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always
func @main() {
// ------------------------------------------------------------------------ //
// Blocking async.await outside of the async.execute.
// ------------------------------------------------------------------------ //
%token, %result = async.execute -> !async.value<f32> {
%0 = arith.constant 123.456 : f32
async.yield %0 : f32
}
%1 = async.await %result : !async.value<f32>
// CHECK: 123.456
vector.print %1 : f32
// ------------------------------------------------------------------------ //
// Non-blocking async.await inside the async.execute
// ------------------------------------------------------------------------ //
%token0, %result0 = async.execute -> !async.value<f32> {
%token1, %result2 = async.execute -> !async.value<f32> {
%2 = arith.constant 456.789 : f32
async.yield %2 : f32
}
%3 = async.await %result2 : !async.value<f32>
async.yield %3 : f32
}
%4 = async.await %result0 : !async.value<f32>
// CHECK: 456.789
vector.print %4 : f32
// ------------------------------------------------------------------------ //
// Memref allocated inside async.execute region.
// ------------------------------------------------------------------------ //
%token2, %result2 = async.execute[%token0] -> !async.value<memref<f32>> {
%5 = memref.alloc() : memref<f32>
%c0 = arith.constant 0.25 : f32
memref.store %c0, %5[]: memref<f32>
async.yield %5 : memref<f32>
}
%6 = async.await %result2 : !async.value<memref<f32>>
%7 = memref.cast %6 : memref<f32> to memref<*xf32>
// CHECK: Unranked Memref
// CHECK-SAME: rank = 0 offset = 0 sizes = [] strides = []
// CHECK-NEXT: [0.25]
call @print_memref_f32(%7): (memref<*xf32>) -> ()
// ------------------------------------------------------------------------ //
// Memref passed as async.execute operand.
// ------------------------------------------------------------------------ //
%token3 = async.execute(%result2 as %unwrapped : !async.value<memref<f32>>) {
%8 = memref.load %unwrapped[]: memref<f32>
%9 = arith.addf %8, %8 : f32
memref.store %9, %unwrapped[]: memref<f32>
async.yield
}
async.await %token3 : !async.token
// CHECK: Unranked Memref
// CHECK-SAME: rank = 0 offset = 0 sizes = [] strides = []
// CHECK-NEXT: [0.5]
call @print_memref_f32(%7): (memref<*xf32>) -> ()
memref.dealloc %6 : memref<f32>
return
}
func private @print_memref_f32(memref<*xf32>)
attributes { llvm.emit_c_interface }
|
