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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
//
// This confidential and proprietary software may be used only as
// authorised by a licensing agreement from ARM Limited
// (C) COPYRIGHT 2021 ARM Limited
// ALL RIGHTS RESERVED
// The entire notice above must be reproduced on all authorised
// copies and copies may only be made to the extent permitted
// by a licensing agreement from ARM Limited.
== TOSA Pseudocode
The TOSA pseudocode provides precise descriptions of TOSA operations.
Each operator contains pseudocode describing the operator's functionality.
This section contains pseudocode functions shared across multiple operators in the specification.
=== Operator Validation Helpers
The following functions are used to define the valid conditions for TOSA operators.
The REQUIRE function defines the conditions required by the TOSA operator.
If the conditions are not met then the result of the TOSA graph is marked as unpredictable.
Once the tosa_graph_result is set to tosa_unpredictable, the whole graph is considered unpredictable.
The ERROR_IF function defines a condition that must set an error if the condition holds and the graph is not unpredictable.
Note that if a graph contains both unpredictable and error statements then result of tosa_execute_graph() is tosa_unpredictable.
This condition is captured in the ERROR_IF function.
*Implementation Notes*
* An implementation is not required to detect unpredictable behaviour. If tosa_execute_graph() returns tosa_unpredictable then the tosa_test_compliance() function does not require any specific output from an implementation.
* An implementation is required to detect errors in a graph that does not have unpredictable behaviour (see tosa_test_compliance).
* An acceptable implementation is to stop and report an error on the first ERROR_IF condition that occurs. This satifies tosa_test_compliance() even if the tosa_execute_graph() was tosa_unpredictable.
* If the tosa_execute_graphs() result is tosa_unpredictable or tosa_error, then there is no requirement on the implementation to execute any portion of the TOSA graph.
[source,c++]
----
void REQUIRE(condition) {
// Unpredictable overrides any previous result
if (!(condition)) {
tosa_graph_result = tosa_unpredictable;
}
}
void ERROR_IF(condition) {
// Error encodes a predictable error state and so is not registered
// if the graph is marked as unpredictable.
if (tosa_graph_result != tosa_unpredictable && condition) {
tosa_graph_result = tosa_error;
}
}
----
=== General Pseudocode Helpers
This section contains general pseudocode utility functions used throughout the specification.
The following functions provide basic arithmetic while defining requirements such that values stay in the valid range.
[source,c++]
----
acc_t apply_add<acc_t>(acc_t a, acc_t b) {
if (acc_t == float_t) return a + b;
int64_t c = (int64_t)a + (int64_t)b;
REQUIRE(c >= minimum<acc_t> && c <= maximum<acc_t>);
return (acc_t)c;
}
acc_t apply_sub<acc_t>(acc_t a, acc_t b) {
if (acc_t == float_t) return a - b;
int64_t c = (int64_t)a - (int64_t)b;
REQUIRE(c >= minimum<acc_t> && c <= maximum<acc_t>);
return (acc_t)c;
}
----
The following functions are used in the pseudocode to take maximum,
minimum, clip values to a range, or count leading zeros.
[[count_leading_zeros]]
[source,c++]
----
<type> apply_max<type>(<type> a, <type> b) {
if (a >= b) return a; else return b;
}
<type> apply_min<type>(<type> a, <type> b) {
if (a < b) return a; else return b;
}
<type> apply_clip<type>(<type> value, <type> min_val, <type> max_val) {
REQUIRE(min_val <= max_val);
value = apply_max(value, min_val);
value = apply_min(value, max_val);
return value;
}
int32_t count_leading_zeros(int32_t a) {
int32_t acc = 32;
if (a != 0) {
uint32_t mask;
mask = 1 << (32 - 1); // width of int32_t - 1
acc = 0;
while ((mask & a) == 0) {
mask = mask >> 1;
acc = acc + 1;
}
}
return acc;
}
----
The following definitions are used in pseudocode to do numeric conversions.
[source,c++]
----
int round_to_nearest_int(float_t f)
Converts the floating-point value to f, with rounding to the nearest integer value.
float_t round_to_nearest_float(in_t f)
Converts the input value into floating-point, rounding to the nearest representable value.
The behavior for ties is implementation dependent.
out_t sign_extend(in_t input)
Only valid for two's complement integer values where out_t has more bits than in_t.
Output = input
Replicate the top bit of input for all bits between the top bit of input and the top bit of output.
out_t truncate(in_t input)
output is the sizeof(out_t) least significant bits in input.
----
The following definition is used to flatten a list of lists into a single list.
[source,c++]
----
in_t* flatten(in_t lists[]) {
in_t output = [];
for_each(list in lists) {
for_each(element in list) {
output.append(element);
}
}
}
----
Generic helper functions used to keep the pseudocode concise.
[source,c++]
----
int length(in_t input)
return number of elements in input list
int floor(in_t input)
return input value rounded down to nearest integer
int rank(in_t input)
return rank of an input tensor
int sum(in_t input[])
return the sum of values of an input list
----
|
