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
|
result code = 0
standard error = {
ir_global_var %1 : Ptr<@ThreadGroup vector<float,4>[64]>;
ir_global_var %2 : Ptr<StructuredBuffer<vector<float,4>>>;
ir_global_var %3 : Ptr<RWStructuredBuffer<vector<float,4>>>;
ir_func @_S04mainp3uuuV : (uint, uint, uint) -> void
{
block %4(
param %5 : uint,
param %6 : uint,
param %7 : uint):
let %8 : Ptr<uint> = var()
store(%8, %5)
let %9 : Ptr<uint> = var()
store(%9, %6)
let %10 : Ptr<uint> = var()
store(%10, %7)
let %11 : uint = load(%9)
let %12 : Ptr<vector<float,4>> = getElementPtr(%1, %11)
let %13 : StructuredBuffer<vector<float,4>> = load(%2)
let %14 : uint = load(%8)
let %15 : vector<float,4> = bufferLoad(%13, %14)
store(%12, %15)
let %16 : Ptr<uint> = var()
let %17 : uint = construct(1)
store(%16, %17)
loop(%18, %19, %20)
block %18:
let %21 : uint = load(%16)
let %22 : uint = construct(64)
let %23 : bool = cmpLT(%21, %22)
loopTest(%23, %24, %19)
block %24:
GroupMemoryBarrierWithGroupSync()
let %25 : uint = load(%9)
let %26 : Ptr<vector<float,4>> = getElementPtr(%1, %25)
let %27 : Ptr<vector<float,4>> = var()
let %28 : vector<float,4> = load(%26)
store(%27, %28)
let %29 : uint = load(%9)
let %30 : uint = load(%16)
let %31 : uint = sub(%29, %30)
let %32 : Ptr<vector<float,4>> = getElementPtr(%1, %31)
let %33 : vector<float,4> = load(%32)
let %34 : vector<float,4> = load(%27)
let %35 : vector<float,4> = add(%34, %33)
store(%27, %35)
let %36 : vector<float,4> = load(%27)
store(%26, %36)
unconditionalBranch(%20)
block %20:
let %37 : Ptr<uint> = var()
let %38 : uint = load(%16)
store(%37, %38)
let %39 : uint = construct(1)
let %40 : uint = load(%37)
let %41 : uint = shl(%40, %39)
store(%37, %41)
let %42 : uint = load(%37)
store(%16, %42)
unconditionalBranch(%18)
block %19:
GroupMemoryBarrierWithGroupSync()
let %43 : RWStructuredBuffer<vector<float,4>> = load(%3)
let %44 : uint = load(%8)
let %45 : Ptr<vector<float,4>> = getElementPtr(%1, 0)
let %46 : vector<float,4> = load(%45)
bufferStore(%43, %44, %46)
return_void()
}
}
standard output = {
}
|
