Gitiles
Code Review Sign In
review.mlplatform.org / tosa / reference_model / ed1a15b641128e38e6efc9128e7cff97b782446d / . / reference_model / src / operators.cc
blob: 1ae0683541f7880a7b37c60330b80a01f18352af [file] [log] [blame]
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2// Copyright (c) 2022-2023, ARM Limited.
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16// THIS FILE IS GENERATED. DO NOT EDIT!
17// See scripts/operator_api/generate_api.py
18
19#include "operators.h"
20#include "model_runner_impl.h"
21#include "ops/op_factory.h"
22
23#define TOSA_RETURN_ON_ERROR(status) \
24 do \
25 { \
26 if (status != 0) \
27 { \
28 return tosa_status_error; \
29 } \
30 } while (false)
31
32#define TOSA_RETURN_ON_GRAPH_STATUS_ERROR(status) \
33 do \
34 { \
35 if (status != GraphStatus::TOSA_VALID) \
36 { \
37 auto ustatus = static_cast<std::underlying_type_t<GraphStatus>>(status); \
38 return static_cast<tosa_status_t>(ustatus); \
39 } \
40 } while (false)
41
42namespace
43{
44
45tosa::DType translate_client_datatype(tosa_datatype_t type)
46{
47 switch (type)
48 {
Jiacheng Liange7c7cab2023-07-14 12:43:46 +0100[diff] [blame]49 case tosa_datatype_bf16_t:
50 return tosa::DType::DType_BF16;
51 case tosa_datatype_bool_t:
52 return tosa::DType::DType_BOOL;
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]53 case tosa_datatype_fp16_t:
54 return tosa::DType::DType_FP16;
55 case tosa_datatype_fp32_t:
56 return tosa::DType::DType_FP32;
Jiacheng Liange7c7cab2023-07-14 12:43:46 +0100[diff] [blame]57 case tosa_datatype_int16_t:
58 return tosa::DType::DType_INT16;
59 case tosa_datatype_int32_t:
60 return tosa::DType::DType_INT32;
61 case tosa_datatype_int48_t:
62 return tosa::DType::DType_INT48;
63 case tosa_datatype_int4_t:
64 return tosa::DType::DType_INT4;
65 case tosa_datatype_int8_t:
66 return tosa::DType::DType_INT8;
67 case tosa_datatype_uint16_t:
68 return tosa::DType::DType_UINT16;
69 case tosa_datatype_uint8_t:
70 return tosa::DType::DType_UINT8;
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]71 default:
72 return tosa::DType::DType_UNKNOWN;
73 }
74};
75
76tosa::TosaSerializationTensor* translate_client_tensor(tosa_tensor_t& tensor, const std::string& name)
77{
78 std::vector<int32_t> shape(tensor.shape, tensor.shape + tensor.num_dims);
79 return new tosa::TosaSerializationTensor(name, shape, translate_client_datatype(tensor.data_type), {});
80}
81
82tosa::ResizeMode translate_client_tosa_mode(tosa_mode_t mode)
83{
84 switch (mode)
85 {
86 case tosa_mode_nearest:
87 return tosa::ResizeMode_NEAREST;
88 case tosa_mode_max:
89 case tosa_mode_bilinear:
90 return tosa::ResizeMode_BILINEAR;
91 default:
92 return tosa::ResizeMode_UNKNOWN;
93 }
94}
95
96} // namespace
97
98extern "C"
99{
100
101 tosa_status_t tosa_run_argmax(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
102 {
103 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]104 const int32_t axis = client_axis;
105 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]106
107 // Create tensors
108 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
109 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
110
111 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]112 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ARGMAX, tosa::Attribute::Attribute_AxisAttribute,
113 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]114
115 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]116 tosa::TosaSerializationBasicBlock block("argmax", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]117 { output->GetName() });
118
119 // Setup model
120 TosaReference::ModelRunnerImpl runner;
121 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
122 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
123
124 // Execute
125 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
126
127 // Extract outputs
128 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
129
130 return tosa_status_valid;
131 }
132
133 tosa_status_t tosa_run_avg_pool2d(tosa_tensor_t client_input,
134 const int32_t client_kernel[2],
135 const int32_t client_stride[2],
136 const int32_t client_pad[4],
137 const int32_t client_input_zp,
138 const int32_t client_output_zp,
139 tosa_tensor_t client_output)
140 {
141 // Create operator attributes
142 const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
143 const std::vector<int32_t> kernel(&client_kernel[0], &client_kernel[2]);
144 const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
145 const int32_t input_zp = client_input_zp;
146 const int32_t output_zp = client_output_zp;
147 const tosa::DType accum_dtype = tosa::DType::DType_FP32;
148 TosaPoolAttribute attr(pad, kernel, stride, input_zp, output_zp, accum_dtype);
149
150 // Create tensors
151 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
152 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
153
154 // Create operator
155 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_AVG_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
156 &attr, { input->GetName() }, { output->GetName() });
157
158 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]159 tosa::TosaSerializationBasicBlock block("avg_pool2d", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]160 { output->GetName() });
161
162 // Setup model
163 TosaReference::ModelRunnerImpl runner;
164 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
165 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
166
167 // Execute
168 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
169
170 // Extract outputs
171 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
172
173 return tosa_status_valid;
174 }
175
176 tosa_status_t tosa_run_conv2d(tosa_tensor_t client_input,
177 tosa_tensor_t client_weight,
178 tosa_tensor_t client_bias,
179 const int32_t client_pad[4],
180 const int32_t client_stride[2],
181 const int32_t client_dilation[2],
182 const int32_t client_input_zp,
183 const int32_t client_weight_zp,
184 tosa_tensor_t client_output)
185 {
186 // Create operator attributes
187 const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
188 const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
189 const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[2]);
James Wardd34b3fc2023-01-18 14:51:25 +0000[diff] [blame]190 const int32_t input_zp = client_input_zp;
191 const int32_t weight_zp = client_weight_zp;
192 TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]193
194 // Create tensors
195 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
196 tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
197 tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");
198 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
199
200 // Create operator
201 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONV2D, tosa::Attribute::Attribute_ConvAttribute,
202 &attr, { input->GetName(), weight->GetName(), bias->GetName() },
203 { output->GetName() });
204
205 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]206 tosa::TosaSerializationBasicBlock block("conv2d", "main", { op }, { input, weight, bias, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]207 { input->GetName(), weight->GetName(), bias->GetName() },
208 { output->GetName() });
209
210 // Setup model
211 TosaReference::ModelRunnerImpl runner;
212 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
213 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
214 TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
215 TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
216
217 // Execute
218 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
219
220 // Extract outputs
221 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
222
223 return tosa_status_valid;
224 }
225
226 tosa_status_t tosa_run_conv3d(tosa_tensor_t client_input,
227 tosa_tensor_t client_weight,
228 tosa_tensor_t client_bias,
229 const int32_t client_pad[6],
230 const int32_t client_stride[3],
231 const int32_t client_dilation[3],
232 const int32_t client_input_zp,
233 const int32_t client_weight_zp,
234 tosa_tensor_t client_output)
235 {
236 // Create operator attributes
237 const std::vector<int32_t> pad(&client_pad[0], &client_pad[6]);
238 const std::vector<int32_t> stride(&client_stride[0], &client_stride[3]);
239 const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[3]);
James Wardd34b3fc2023-01-18 14:51:25 +0000[diff] [blame]240 const int32_t input_zp = client_input_zp;
241 const int32_t weight_zp = client_weight_zp;
242 TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]243
244 // Create tensors
245 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
246 tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
247 tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");
248 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
249
250 // Create operator
251 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONV3D, tosa::Attribute::Attribute_ConvAttribute,
252 &attr, { input->GetName(), weight->GetName(), bias->GetName() },
253 { output->GetName() });
254
255 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]256 tosa::TosaSerializationBasicBlock block("conv3d", "main", { op }, { input, weight, bias, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]257 { input->GetName(), weight->GetName(), bias->GetName() },
258 { output->GetName() });
259
260 // Setup model
261 TosaReference::ModelRunnerImpl runner;
262 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
263 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
264 TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
265 TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
266
267 // Execute
268 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
269
270 // Extract outputs
271 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
272
273 return tosa_status_valid;
274 }
275
276 tosa_status_t tosa_run_depthwise_conv2d(tosa_tensor_t client_input,
277 tosa_tensor_t client_weight,
278 tosa_tensor_t client_bias,
279 const int32_t client_pad[4],
280 const int32_t client_stride[2],
281 const int32_t client_dilation[2],
282 const int32_t client_input_zp,
283 const int32_t client_weight_zp,
284 tosa_tensor_t client_output)
285 {
286 // Create operator attributes
287 const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
288 const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
289 const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[2]);
James Wardd34b3fc2023-01-18 14:51:25 +0000[diff] [blame]290 const int32_t input_zp = client_input_zp;
291 const int32_t weight_zp = client_weight_zp;
292 TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]293
294 // Create tensors
295 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
296 tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
297 tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");
298 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
299
300 // Create operator
301 auto op = new tosa::TosaSerializationOperator(
302 tosa::Op::Op_DEPTHWISE_CONV2D, tosa::Attribute::Attribute_ConvAttribute, &attr,
303 { input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });
304
305 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]306 tosa::TosaSerializationBasicBlock block("depthwise_conv2d", "main", { op }, { input, weight, bias, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]307 { input->GetName(), weight->GetName(), bias->GetName() },
308 { output->GetName() });
309
310 // Setup model
311 TosaReference::ModelRunnerImpl runner;
312 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
313 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
314 TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
315 TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
316
317 // Execute
318 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
319
320 // Extract outputs
321 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
322
323 return tosa_status_valid;
324 }
325
326 tosa_status_t tosa_run_fully_connected(tosa_tensor_t client_input,
Jiacheng Lianged1a15b2023-07-27 16:50:15 +0100[diff] [blame^]327 tosa_tensor_t client_weight,
328 tosa_tensor_t client_bias,
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]329 const int32_t client_input_zp,
330 const int32_t client_weight_zp,
331 tosa_tensor_t client_output)
332 {
333 // Create operator attributes
James Wardd34b3fc2023-01-18 14:51:25 +0000[diff] [blame]334 const int32_t input_zp = client_input_zp;
335 const int32_t weight_zp = client_weight_zp;
336 TosaFullyConnectedAttribute attr(input_zp, weight_zp);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]337
338 // Create tensors
339 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
Jiacheng Lianged1a15b2023-07-27 16:50:15 +0100[diff] [blame^]340 tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
341 tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]342 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
343
344 // Create operator
Jiacheng Lianged1a15b2023-07-27 16:50:15 +0100[diff] [blame^]345 auto op = new tosa::TosaSerializationOperator(
346 tosa::Op::Op_FULLY_CONNECTED, tosa::Attribute::Attribute_FullyConnectedAttribute, &attr,
347 { input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]348
349 // Create a tosa single-op basic block
Jiacheng Lianged1a15b2023-07-27 16:50:15 +0100[diff] [blame^]350 tosa::TosaSerializationBasicBlock block("fully_connected", "main", { op }, { input, weight, bias, output },
351 { input->GetName(), weight->GetName(), bias->GetName() },
352 { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]353
354 // Setup model
355 TosaReference::ModelRunnerImpl runner;
356 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
357 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
Jiacheng Lianged1a15b2023-07-27 16:50:15 +0100[diff] [blame^]358 TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
359 TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]360
361 // Execute
362 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
363
364 // Extract outputs
365 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
366
367 return tosa_status_valid;
368 }
369
370 tosa_status_t tosa_run_matmul(tosa_tensor_t client_a,
371 tosa_tensor_t client_b,
372 const int32_t client_a_zp,
373 const int32_t client_b_zp,
374 tosa_tensor_t client_output)
375 {
376 // Create operator attributes
James Wardd34b3fc2023-01-18 14:51:25 +0000[diff] [blame]377 const int32_t a_zp = client_a_zp;
378 const int32_t b_zp = client_b_zp;
379 TosaMatMulAttribute attr(a_zp, b_zp);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]380
381 // Create tensors
382 tosa::TosaSerializationTensor* a = translate_client_tensor(client_a, "a");
383 tosa::TosaSerializationTensor* b = translate_client_tensor(client_b, "b");
384 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
385
386 // Create operator
387 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MATMUL, tosa::Attribute::Attribute_MatMulAttribute,
388 &attr, { a->GetName(), b->GetName() }, { output->GetName() });
389
390 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]391 tosa::TosaSerializationBasicBlock block("matmul", "main", { op }, { a, b, output },
392 { a->GetName(), b->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]393
394 // Setup model
395 TosaReference::ModelRunnerImpl runner;
396 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
397 TOSA_RETURN_ON_ERROR(runner.setInput(a->GetName(), client_a.data, client_a.size));
398 TOSA_RETURN_ON_ERROR(runner.setInput(b->GetName(), client_b.data, client_b.size));
399
400 // Execute
401 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
402
403 // Extract outputs
404 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
405
406 return tosa_status_valid;
407 }
408
409 tosa_status_t tosa_run_max_pool2d(tosa_tensor_t client_input,
410 const int32_t client_kernel[2],
411 const int32_t client_stride[2],
412 const int32_t client_pad[4],
413 const int32_t client_input_zp,
414 const int32_t client_output_zp,
415 tosa_tensor_t client_output)
416 {
417 // Create operator attributes
418 const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
419 const std::vector<int32_t> kernel(&client_kernel[0], &client_kernel[2]);
420 const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
421 const int32_t input_zp = client_input_zp;
422 const int32_t output_zp = client_output_zp;
423 const tosa::DType accum_dtype = tosa::DType::DType_FP32;
424 TosaPoolAttribute attr(pad, kernel, stride, input_zp, output_zp, accum_dtype);
425
426 // Create tensors
427 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
428 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
429
430 // Create operator
431 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MAX_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
432 &attr, { input->GetName() }, { output->GetName() });
433
434 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]435 tosa::TosaSerializationBasicBlock block("max_pool2d", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]436 { output->GetName() });
437
438 // Setup model
439 TosaReference::ModelRunnerImpl runner;
440 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
441 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
442
443 // Execute
444 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
445
446 // Extract outputs
447 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
448
449 return tosa_status_valid;
450 }
451
452 tosa_status_t tosa_run_transpose_conv2d(tosa_tensor_t client_input,
453 tosa_tensor_t client_weight,
454 tosa_tensor_t client_bias,
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]455 const int32_t client_stride[2],
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]456 const int32_t client_input_zp,
457 const int32_t client_weight_zp,
458 const int32_t client_pad_len,
459 const int32_t client_pad[],
460 const int32_t client_dilation_len,
461 const int32_t client_dilation[],
462 tosa_tensor_t client_output)
463 {
464 // Create operator attributes
465 const std::vector<int32_t> pad(&client_pad[0], &client_pad[0] + client_pad_len);
466 const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
467 const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[0] + client_dilation_len);
James Wardd34b3fc2023-01-18 14:51:25 +0000[diff] [blame]468 const int32_t input_zp = client_input_zp;
469 const int32_t weight_zp = client_weight_zp;
470 TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]471
472 // Create tensors
473 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
474 tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");
475 tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");
476 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
477
478 // Create operator
479 auto op = new tosa::TosaSerializationOperator(
480 tosa::Op::Op_TRANSPOSE_CONV2D, tosa::Attribute::Attribute_ConvAttribute, &attr,
481 { input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });
482
483 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]484 tosa::TosaSerializationBasicBlock block("transpose_conv2d", "main", { op }, { input, weight, bias, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]485 { input->GetName(), weight->GetName(), bias->GetName() },
486 { output->GetName() });
487
488 // Setup model
489 TosaReference::ModelRunnerImpl runner;
490 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
491 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
492 TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
493 TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));
494
495 // Execute
496 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
497
498 // Extract outputs
499 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
500
501 return tosa_status_valid;
502 }
503
504 tosa_status_t tosa_run_clamp(tosa_tensor_t client_input,
505 const int32_t client_min_int,
506 const int32_t client_max_int,
507 const float client_min_fp,
508 const float client_max_fp,
509 tosa_tensor_t client_output)
510 {
511 // Create operator attributes
512 const int32_t min_int = client_min_int;
513 const int32_t max_int = client_max_int;
514 const float min_fp = client_min_fp;
515 const float max_fp = client_max_fp;
516 TosaClampAttribute attr(min_int, max_int, min_fp, max_fp);
517
518 // Create tensors
519 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
520 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
521
522 // Create operator
523 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CLAMP, tosa::Attribute::Attribute_ClampAttribute,
524 &attr, { input->GetName() }, { output->GetName() });
525
526 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]527 tosa::TosaSerializationBasicBlock block("clamp", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]528 { output->GetName() });
529
530 // Setup model
531 TosaReference::ModelRunnerImpl runner;
532 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
533 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
534
535 // Execute
536 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
537
538 // Extract outputs
539 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
540
541 return tosa_status_valid;
542 }
543
544 tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input, tosa_tensor_t client_output)
545 {
546 // Create operator attributes
547 TosaNoneAttribute attr;
548
549 // Create tensors
550 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
551 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
552
553 // Create operator
554 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SIGMOID, tosa::Attribute::Attribute_NONE, &attr,
555 { input->GetName() }, { output->GetName() });
556
557 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]558 tosa::TosaSerializationBasicBlock block("sigmoid", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]559 { output->GetName() });
560
561 // Setup model
562 TosaReference::ModelRunnerImpl runner;
563 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
564 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
565
566 // Execute
567 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
568
569 // Extract outputs
570 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
571
572 return tosa_status_valid;
573 }
574
575 tosa_status_t tosa_run_tanh(tosa_tensor_t client_input, tosa_tensor_t client_output)
576 {
577 // Create operator attributes
578 TosaNoneAttribute attr;
579
580 // Create tensors
581 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
582 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
583
584 // Create operator
585 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TANH, tosa::Attribute::Attribute_NONE, &attr,
586 { input->GetName() }, { output->GetName() });
587
588 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]589 tosa::TosaSerializationBasicBlock block("tanh", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]590 { output->GetName() });
591
592 // Setup model
593 TosaReference::ModelRunnerImpl runner;
594 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
595 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
596
597 // Execute
598 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
599
600 // Extract outputs
601 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
602
603 return tosa_status_valid;
604 }
605
Won Jeon78155c62023-06-10 00:20:04 +0000[diff] [blame]606 tosa_status_t tosa_run_erf(tosa_tensor_t client_input, tosa_tensor_t client_output)
607 {
608 // Create operator attributes
609 TosaNoneAttribute attr;
610
611 // Create tensors
Jerry Ge9c9c8da2023-07-19 23:08:16 +0000[diff] [blame]612 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
Won Jeon78155c62023-06-10 00:20:04 +0000[diff] [blame]613 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
614
615 // Create operator
616 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ERF, tosa::Attribute::Attribute_NONE, &attr,
617 { input->GetName() }, { output->GetName() });
618
619 // Create a tosa single-op basic block
620 tosa::TosaSerializationBasicBlock block("erf", "main", { op }, { input, output }, { input->GetName() },
621 { output->GetName() });
622
623 // Setup model
624 TosaReference::ModelRunnerImpl runner;
625 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
626 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
627
628 // Execute
629 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
630
631 // Extract outputs
632 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
633
634 return tosa_status_valid;
635 }
636
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]637 tosa_status_t tosa_run_add(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
638 {
639 // Create operator attributes
640 TosaNoneAttribute attr;
641
642 // Create tensors
643 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
644 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
645 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
646
647 // Create operator
648 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ADD, tosa::Attribute::Attribute_NONE, &attr,
649 { input1->GetName(), input2->GetName() }, { output->GetName() });
650
651 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]652 tosa::TosaSerializationBasicBlock block("add", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]653 { input1->GetName(), input2->GetName() }, { output->GetName() });
654
655 // Setup model
656 TosaReference::ModelRunnerImpl runner;
657 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
658 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
659 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
660
661 // Execute
662 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
663
664 // Extract outputs
665 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
666
667 return tosa_status_valid;
668 }
669
670 tosa_status_t tosa_run_arithmetic_right_shift(tosa_tensor_t client_input1,
671 tosa_tensor_t client_input2,
672 const bool client_round,
673 tosa_tensor_t client_output)
674 {
675 // Create operator attributes
676 const bool round = client_round;
677 TosaArithmeticRightShiftAttribute attr(round);
678
679 // Create tensors
680 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
681 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
682 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
683
684 // Create operator
685 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ARITHMETIC_RIGHT_SHIFT,
686 tosa::Attribute::Attribute_ArithmeticRightShiftAttribute, &attr,
687 { input1->GetName(), input2->GetName() }, { output->GetName() });
688
689 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]690 tosa::TosaSerializationBasicBlock block("arithmetic_right_shift", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]691 { input1->GetName(), input2->GetName() }, { output->GetName() });
692
693 // Setup model
694 TosaReference::ModelRunnerImpl runner;
695 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
696 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
697 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
698
699 // Execute
700 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
701
702 // Extract outputs
703 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
704
705 return tosa_status_valid;
706 }
707
708 tosa_status_t
709 tosa_run_bitwise_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
710 {
711 // Create operator attributes
712 TosaNoneAttribute attr;
713
714 // Create tensors
715 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
716 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
717 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
718
719 // Create operator
720 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_AND, tosa::Attribute::Attribute_NONE, &attr,
721 { input1->GetName(), input2->GetName() }, { output->GetName() });
722
723 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]724 tosa::TosaSerializationBasicBlock block("bitwise_and", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]725 { input1->GetName(), input2->GetName() }, { output->GetName() });
726
727 // Setup model
728 TosaReference::ModelRunnerImpl runner;
729 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
730 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
731 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
732
733 // Execute
734 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
735
736 // Extract outputs
737 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
738
739 return tosa_status_valid;
740 }
741
742 tosa_status_t
743 tosa_run_bitwise_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
744 {
745 // Create operator attributes
746 TosaNoneAttribute attr;
747
748 // Create tensors
749 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
750 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
751 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
752
753 // Create operator
754 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_OR, tosa::Attribute::Attribute_NONE, &attr,
755 { input1->GetName(), input2->GetName() }, { output->GetName() });
756
757 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]758 tosa::TosaSerializationBasicBlock block("bitwise_or", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]759 { input1->GetName(), input2->GetName() }, { output->GetName() });
760
761 // Setup model
762 TosaReference::ModelRunnerImpl runner;
763 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
764 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
765 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
766
767 // Execute
768 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
769
770 // Extract outputs
771 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
772
773 return tosa_status_valid;
774 }
775
776 tosa_status_t
777 tosa_run_bitwise_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
778 {
779 // Create operator attributes
780 TosaNoneAttribute attr;
781
782 // Create tensors
783 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
784 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
785 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
786
787 // Create operator
788 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_XOR, tosa::Attribute::Attribute_NONE, &attr,
789 { input1->GetName(), input2->GetName() }, { output->GetName() });
790
791 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]792 tosa::TosaSerializationBasicBlock block("bitwise_xor", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]793 { input1->GetName(), input2->GetName() }, { output->GetName() });
794
795 // Setup model
796 TosaReference::ModelRunnerImpl runner;
797 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
798 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
799 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
800
801 // Execute
802 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
803
804 // Extract outputs
805 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
806
807 return tosa_status_valid;
808 }
809
810 tosa_status_t tosa_run_intdiv(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
811 {
812 // Create operator attributes
813 TosaNoneAttribute attr;
814
815 // Create tensors
816 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
817 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
818 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
819
820 // Create operator
821 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_INTDIV, tosa::Attribute::Attribute_NONE, &attr,
822 { input1->GetName(), input2->GetName() }, { output->GetName() });
823
824 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]825 tosa::TosaSerializationBasicBlock block("intdiv", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]826 { input1->GetName(), input2->GetName() }, { output->GetName() });
827
828 // Setup model
829 TosaReference::ModelRunnerImpl runner;
830 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
831 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
832 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
833
834 // Execute
835 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
836
837 // Extract outputs
838 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
839
840 return tosa_status_valid;
841 }
842
843 tosa_status_t
844 tosa_run_logical_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
845 {
846 // Create operator attributes
847 TosaNoneAttribute attr;
848
849 // Create tensors
850 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
851 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
852 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
853
854 // Create operator
855 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_AND, tosa::Attribute::Attribute_NONE, &attr,
856 { input1->GetName(), input2->GetName() }, { output->GetName() });
857
858 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]859 tosa::TosaSerializationBasicBlock block("logical_and", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]860 { input1->GetName(), input2->GetName() }, { output->GetName() });
861
862 // Setup model
863 TosaReference::ModelRunnerImpl runner;
864 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
865 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
866 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
867
868 // Execute
869 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
870
871 // Extract outputs
872 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
873
874 return tosa_status_valid;
875 }
876
877 tosa_status_t tosa_run_logical_left_shift(tosa_tensor_t client_input1,
878 tosa_tensor_t client_input2,
879 tosa_tensor_t client_output)
880 {
881 // Create operator attributes
882 TosaNoneAttribute attr;
883
884 // Create tensors
885 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
886 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
887 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
888
889 // Create operator
890 auto op =
891 new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_LEFT_SHIFT, tosa::Attribute::Attribute_NONE, &attr,
892 { input1->GetName(), input2->GetName() }, { output->GetName() });
893
894 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]895 tosa::TosaSerializationBasicBlock block("logical_left_shift", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]896 { input1->GetName(), input2->GetName() }, { output->GetName() });
897
898 // Setup model
899 TosaReference::ModelRunnerImpl runner;
900 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
901 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
902 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
903
904 // Execute
905 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
906
907 // Extract outputs
908 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
909
910 return tosa_status_valid;
911 }
912
913 tosa_status_t tosa_run_logical_right_shift(tosa_tensor_t client_input1,
914 tosa_tensor_t client_input2,
915 tosa_tensor_t client_output)
916 {
917 // Create operator attributes
918 TosaNoneAttribute attr;
919
920 // Create tensors
921 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
922 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
923 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
924
925 // Create operator
926 auto op =
927 new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_RIGHT_SHIFT, tosa::Attribute::Attribute_NONE,
928 &attr, { input1->GetName(), input2->GetName() }, { output->GetName() });
929
930 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]931 tosa::TosaSerializationBasicBlock block("logical_right_shift", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]932 { input1->GetName(), input2->GetName() }, { output->GetName() });
933
934 // Setup model
935 TosaReference::ModelRunnerImpl runner;
936 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
937 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
938 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
939
940 // Execute
941 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
942
943 // Extract outputs
944 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
945
946 return tosa_status_valid;
947 }
948
949 tosa_status_t
950 tosa_run_logical_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
951 {
952 // Create operator attributes
953 TosaNoneAttribute attr;
954
955 // Create tensors
956 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
957 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
958 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
959
960 // Create operator
961 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_OR, tosa::Attribute::Attribute_NONE, &attr,
962 { input1->GetName(), input2->GetName() }, { output->GetName() });
963
964 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]965 tosa::TosaSerializationBasicBlock block("logical_or", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]966 { input1->GetName(), input2->GetName() }, { output->GetName() });
967
968 // Setup model
969 TosaReference::ModelRunnerImpl runner;
970 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
971 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
972 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
973
974 // Execute
975 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
976
977 // Extract outputs
978 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
979
980 return tosa_status_valid;
981 }
982
983 tosa_status_t
984 tosa_run_logical_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
985 {
986 // Create operator attributes
987 TosaNoneAttribute attr;
988
989 // Create tensors
990 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
991 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
992 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
993
994 // Create operator
995 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_XOR, tosa::Attribute::Attribute_NONE, &attr,
996 { input1->GetName(), input2->GetName() }, { output->GetName() });
997
998 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]999 tosa::TosaSerializationBasicBlock block("logical_xor", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1000 { input1->GetName(), input2->GetName() }, { output->GetName() });
1001
1002 // Setup model
1003 TosaReference::ModelRunnerImpl runner;
1004 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1005 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1006 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1007
1008 // Execute
1009 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1010
1011 // Extract outputs
1012 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1013
1014 return tosa_status_valid;
1015 }
1016
1017 tosa_status_t
1018 tosa_run_maximum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
1019 {
1020 // Create operator attributes
1021 TosaNoneAttribute attr;
1022
1023 // Create tensors
1024 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1025 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1026 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1027
1028 // Create operator
1029 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MAXIMUM, tosa::Attribute::Attribute_NONE, &attr,
1030 { input1->GetName(), input2->GetName() }, { output->GetName() });
1031
1032 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1033 tosa::TosaSerializationBasicBlock block("maximum", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1034 { input1->GetName(), input2->GetName() }, { output->GetName() });
1035
1036 // Setup model
1037 TosaReference::ModelRunnerImpl runner;
1038 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1039 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1040 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1041
1042 // Execute
1043 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1044
1045 // Extract outputs
1046 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1047
1048 return tosa_status_valid;
1049 }
1050
1051 tosa_status_t
1052 tosa_run_minimum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
1053 {
1054 // Create operator attributes
1055 TosaNoneAttribute attr;
1056
1057 // Create tensors
1058 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1059 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1060 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1061
1062 // Create operator
1063 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MINIMUM, tosa::Attribute::Attribute_NONE, &attr,
1064 { input1->GetName(), input2->GetName() }, { output->GetName() });
1065
1066 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1067 tosa::TosaSerializationBasicBlock block("minimum", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1068 { input1->GetName(), input2->GetName() }, { output->GetName() });
1069
1070 // Setup model
1071 TosaReference::ModelRunnerImpl runner;
1072 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1073 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1074 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1075
1076 // Execute
1077 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1078
1079 // Extract outputs
1080 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1081
1082 return tosa_status_valid;
1083 }
1084
1085 tosa_status_t tosa_run_mul(tosa_tensor_t client_input1,
1086 tosa_tensor_t client_input2,
Grant Watsoneb741062023-06-23 16:52:12 +0100[diff] [blame]1087 const int32_t client_shift,
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1088 tosa_tensor_t client_output)
1089 {
1090 // Create operator attributes
1091 const int32_t shift = client_shift;
1092 TosaMulAttribute attr(shift);
1093
1094 // Create tensors
1095 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1096 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1097 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1098
1099 // Create operator
1100 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MUL, tosa::Attribute::Attribute_MulAttribute, &attr,
1101 { input1->GetName(), input2->GetName() }, { output->GetName() });
1102
1103 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1104 tosa::TosaSerializationBasicBlock block("mul", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1105 { input1->GetName(), input2->GetName() }, { output->GetName() });
1106
1107 // Setup model
1108 TosaReference::ModelRunnerImpl runner;
1109 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1110 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1111 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1112
1113 // Execute
1114 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1115
1116 // Extract outputs
1117 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1118
1119 return tosa_status_valid;
1120 }
1121
1122 tosa_status_t tosa_run_pow(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
1123 {
1124 // Create operator attributes
1125 TosaNoneAttribute attr;
1126
1127 // Create tensors
1128 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1129 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1130 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1131
1132 // Create operator
1133 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_POW, tosa::Attribute::Attribute_NONE, &attr,
1134 { input1->GetName(), input2->GetName() }, { output->GetName() });
1135
1136 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1137 tosa::TosaSerializationBasicBlock block("pow", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1138 { input1->GetName(), input2->GetName() }, { output->GetName() });
1139
1140 // Setup model
1141 TosaReference::ModelRunnerImpl runner;
1142 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1143 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1144 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1145
1146 // Execute
1147 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1148
1149 // Extract outputs
1150 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1151
1152 return tosa_status_valid;
1153 }
1154
1155 tosa_status_t tosa_run_sub(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
1156 {
1157 // Create operator attributes
1158 TosaNoneAttribute attr;
1159
1160 // Create tensors
1161 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1162 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1163 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1164
1165 // Create operator
1166 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SUB, tosa::Attribute::Attribute_NONE, &attr,
1167 { input1->GetName(), input2->GetName() }, { output->GetName() });
1168
1169 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1170 tosa::TosaSerializationBasicBlock block("sub", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1171 { input1->GetName(), input2->GetName() }, { output->GetName() });
1172
1173 // Setup model
1174 TosaReference::ModelRunnerImpl runner;
1175 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1176 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1177 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1178
1179 // Execute
1180 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1181
1182 // Extract outputs
1183 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1184
1185 return tosa_status_valid;
1186 }
1187
1188 tosa_status_t tosa_run_table(tosa_tensor_t client_input,
1189 const int32_t client_table_len,
1190 const int16_t client_table[],
1191 tosa_tensor_t client_output)
1192 {
1193 // Create operator attributes
1194 const std::vector<int16_t> table(&client_table[0], &client_table[0] + client_table_len);
1195 TosaTableAttribute attr(table);
1196
1197 // Create tensors
1198 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
1199 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1200
1201 // Create operator
1202 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TABLE, tosa::Attribute::Attribute_TableAttribute,
1203 &attr, { input->GetName() }, { output->GetName() });
1204
1205 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1206 tosa::TosaSerializationBasicBlock block("table", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1207 { output->GetName() });
1208
1209 // Setup model
1210 TosaReference::ModelRunnerImpl runner;
1211 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1212 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
1213
1214 // Execute
1215 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1216
1217 // Extract outputs
1218 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1219
1220 return tosa_status_valid;
1221 }
1222
1223 tosa_status_t tosa_run_abs(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1224 {
1225 // Create operator attributes
1226 TosaNoneAttribute attr;
1227
1228 // Create tensors
1229 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1230 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1231
1232 // Create operator
1233 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ABS, tosa::Attribute::Attribute_NONE, &attr,
1234 { input1->GetName() }, { output->GetName() });
1235
1236 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1237 tosa::TosaSerializationBasicBlock block("abs", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1238 { output->GetName() });
1239
1240 // Setup model
1241 TosaReference::ModelRunnerImpl runner;
1242 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1243 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1244
1245 // Execute
1246 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1247
1248 // Extract outputs
1249 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1250
1251 return tosa_status_valid;
1252 }
1253
1254 tosa_status_t tosa_run_bitwise_not(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1255 {
1256 // Create operator attributes
1257 TosaNoneAttribute attr;
1258
1259 // Create tensors
1260 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1261 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1262
1263 // Create operator
1264 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_NOT, tosa::Attribute::Attribute_NONE, &attr,
1265 { input1->GetName() }, { output->GetName() });
1266
1267 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1268 tosa::TosaSerializationBasicBlock block("bitwise_not", "main", { op }, { input1, output },
1269 { input1->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1270
1271 // Setup model
1272 TosaReference::ModelRunnerImpl runner;
1273 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1274 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1275
1276 // Execute
1277 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1278
1279 // Extract outputs
1280 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1281
1282 return tosa_status_valid;
1283 }
1284
1285 tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1286 {
1287 // Create operator attributes
1288 TosaNoneAttribute attr;
1289
1290 // Create tensors
1291 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1292 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1293
1294 // Create operator
1295 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CEIL, tosa::Attribute::Attribute_NONE, &attr,
1296 { input1->GetName() }, { output->GetName() });
1297
1298 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1299 tosa::TosaSerializationBasicBlock block("ceil", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1300 { output->GetName() });
1301
1302 // Setup model
1303 TosaReference::ModelRunnerImpl runner;
1304 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1305 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1306
1307 // Execute
1308 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1309
1310 // Extract outputs
1311 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1312
1313 return tosa_status_valid;
1314 }
1315
1316 tosa_status_t tosa_run_clz(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1317 {
1318 // Create operator attributes
1319 TosaNoneAttribute attr;
1320
1321 // Create tensors
1322 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1323 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1324
1325 // Create operator
1326 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CLZ, tosa::Attribute::Attribute_NONE, &attr,
1327 { input1->GetName() }, { output->GetName() });
1328
1329 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1330 tosa::TosaSerializationBasicBlock block("clz", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1331 { output->GetName() });
1332
1333 // Setup model
1334 TosaReference::ModelRunnerImpl runner;
1335 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1336 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1337
1338 // Execute
1339 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1340
1341 // Extract outputs
1342 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1343
1344 return tosa_status_valid;
1345 }
1346
1347 tosa_status_t tosa_run_exp(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1348 {
1349 // Create operator attributes
1350 TosaNoneAttribute attr;
1351
1352 // Create tensors
1353 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1354 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1355
1356 // Create operator
1357 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EXP, tosa::Attribute::Attribute_NONE, &attr,
1358 { input1->GetName() }, { output->GetName() });
1359
1360 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1361 tosa::TosaSerializationBasicBlock block("exp", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1362 { output->GetName() });
1363
1364 // Setup model
1365 TosaReference::ModelRunnerImpl runner;
1366 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1367 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1368
1369 // Execute
1370 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1371
1372 // Extract outputs
1373 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1374
1375 return tosa_status_valid;
1376 }
1377
1378 tosa_status_t tosa_run_floor(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1379 {
1380 // Create operator attributes
1381 TosaNoneAttribute attr;
1382
1383 // Create tensors
1384 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1385 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1386
1387 // Create operator
1388 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FLOOR, tosa::Attribute::Attribute_NONE, &attr,
1389 { input1->GetName() }, { output->GetName() });
1390
1391 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1392 tosa::TosaSerializationBasicBlock block("floor", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1393 { output->GetName() });
1394
1395 // Setup model
1396 TosaReference::ModelRunnerImpl runner;
1397 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1398 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1399
1400 // Execute
1401 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1402
1403 // Extract outputs
1404 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1405
1406 return tosa_status_valid;
1407 }
1408
1409 tosa_status_t tosa_run_log(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1410 {
1411 // Create operator attributes
1412 TosaNoneAttribute attr;
1413
1414 // Create tensors
1415 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1416 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1417
1418 // Create operator
1419 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOG, tosa::Attribute::Attribute_NONE, &attr,
1420 { input1->GetName() }, { output->GetName() });
1421
1422 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1423 tosa::TosaSerializationBasicBlock block("log", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1424 { output->GetName() });
1425
1426 // Setup model
1427 TosaReference::ModelRunnerImpl runner;
1428 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1429 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1430
1431 // Execute
1432 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1433
1434 // Extract outputs
1435 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1436
1437 return tosa_status_valid;
1438 }
1439
1440 tosa_status_t tosa_run_logical_not(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1441 {
1442 // Create operator attributes
1443 TosaNoneAttribute attr;
1444
1445 // Create tensors
1446 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1447 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1448
1449 // Create operator
1450 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_NOT, tosa::Attribute::Attribute_NONE, &attr,
1451 { input1->GetName() }, { output->GetName() });
1452
1453 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1454 tosa::TosaSerializationBasicBlock block("logical_not", "main", { op }, { input1, output },
1455 { input1->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1456
1457 // Setup model
1458 TosaReference::ModelRunnerImpl runner;
1459 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1460 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1461
1462 // Execute
1463 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1464
1465 // Extract outputs
1466 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1467
1468 return tosa_status_valid;
1469 }
1470
1471 tosa_status_t tosa_run_negate(tosa_tensor_t client_input1,
1472 const int32_t client_input1_zp,
1473 const int32_t client_output_zp,
1474 tosa_tensor_t client_output)
1475 {
1476 // Create operator attributes
1477 const int32_t input1_zp = client_input1_zp;
1478 const int32_t output_zp = client_output_zp;
1479 TosaNegateAttribute attr(input1_zp, output_zp);
1480
1481 // Create tensors
1482 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1483 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1484
1485 // Create operator
1486 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_NEGATE, tosa::Attribute::Attribute_NegateAttribute,
1487 &attr, { input1->GetName() }, { output->GetName() });
1488
1489 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1490 tosa::TosaSerializationBasicBlock block("negate", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1491 { output->GetName() });
1492
1493 // Setup model
1494 TosaReference::ModelRunnerImpl runner;
1495 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1496 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1497
1498 // Execute
1499 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1500
1501 // Extract outputs
1502 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1503
1504 return tosa_status_valid;
1505 }
1506
1507 tosa_status_t tosa_run_reciprocal(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1508 {
1509 // Create operator attributes
1510 TosaNoneAttribute attr;
1511
1512 // Create tensors
1513 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1514 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1515
1516 // Create operator
1517 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RECIPROCAL, tosa::Attribute::Attribute_NONE, &attr,
1518 { input1->GetName() }, { output->GetName() });
1519
1520 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1521 tosa::TosaSerializationBasicBlock block("reciprocal", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1522 { output->GetName() });
1523
1524 // Setup model
1525 TosaReference::ModelRunnerImpl runner;
1526 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1527 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1528
1529 // Execute
1530 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1531
1532 // Extract outputs
1533 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1534
1535 return tosa_status_valid;
1536 }
1537
1538 tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1, tosa_tensor_t client_output)
1539 {
1540 // Create operator attributes
1541 TosaNoneAttribute attr;
1542
1543 // Create tensors
1544 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1545 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1546
1547 // Create operator
1548 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RSQRT, tosa::Attribute::Attribute_NONE, &attr,
1549 { input1->GetName() }, { output->GetName() });
1550
1551 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1552 tosa::TosaSerializationBasicBlock block("rsqrt", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1553 { output->GetName() });
1554
1555 // Setup model
1556 TosaReference::ModelRunnerImpl runner;
1557 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1558 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1559
1560 // Execute
1561 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1562
1563 // Extract outputs
1564 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1565
1566 return tosa_status_valid;
1567 }
1568
1569 tosa_status_t tosa_run_select(tosa_tensor_t client_input1,
1570 tosa_tensor_t client_input2,
1571 tosa_tensor_t client_input3,
1572 tosa_tensor_t client_output)
1573 {
1574 // Create operator attributes
1575 TosaNoneAttribute attr;
1576
1577 // Create tensors
1578 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1579 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1580 tosa::TosaSerializationTensor* input3 = translate_client_tensor(client_input3, "input3");
1581 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1582
1583 // Create operator
1584 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SELECT, tosa::Attribute::Attribute_NONE, &attr,
1585 { input1->GetName(), input2->GetName(), input3->GetName() },
1586 { output->GetName() });
1587
1588 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1589 tosa::TosaSerializationBasicBlock block("select", "main", { op }, { input1, input2, input3, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1590 { input1->GetName(), input2->GetName(), input3->GetName() },
1591 { output->GetName() });
1592
1593 // Setup model
1594 TosaReference::ModelRunnerImpl runner;
1595 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1596 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1597 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1598 TOSA_RETURN_ON_ERROR(runner.setInput(input3->GetName(), client_input3.data, client_input3.size));
1599
1600 // Execute
1601 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1602
1603 // Extract outputs
1604 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1605
1606 return tosa_status_valid;
1607 }
1608
1609 tosa_status_t tosa_run_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
1610 {
1611 // Create operator attributes
1612 TosaNoneAttribute attr;
1613
1614 // Create tensors
1615 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1616 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1617 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1618
1619 // Create operator
1620 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EQUAL, tosa::Attribute::Attribute_NONE, &attr,
1621 { input1->GetName(), input2->GetName() }, { output->GetName() });
1622
1623 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1624 tosa::TosaSerializationBasicBlock block("equal", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1625 { input1->GetName(), input2->GetName() }, { output->GetName() });
1626
1627 // Setup model
1628 TosaReference::ModelRunnerImpl runner;
1629 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1630 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1631 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1632
1633 // Execute
1634 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1635
1636 // Extract outputs
1637 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1638
1639 return tosa_status_valid;
1640 }
1641
1642 tosa_status_t
1643 tosa_run_greater(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
1644 {
1645 // Create operator attributes
1646 TosaNoneAttribute attr;
1647
1648 // Create tensors
1649 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1650 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1651 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1652
1653 // Create operator
1654 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER, tosa::Attribute::Attribute_NONE, &attr,
1655 { input1->GetName(), input2->GetName() }, { output->GetName() });
1656
1657 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1658 tosa::TosaSerializationBasicBlock block("greater", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1659 { input1->GetName(), input2->GetName() }, { output->GetName() });
1660
1661 // Setup model
1662 TosaReference::ModelRunnerImpl runner;
1663 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1664 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1665 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1666
1667 // Execute
1668 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1669
1670 // Extract outputs
1671 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1672
1673 return tosa_status_valid;
1674 }
1675
1676 tosa_status_t
1677 tosa_run_greater_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
1678 {
1679 // Create operator attributes
1680 TosaNoneAttribute attr;
1681
1682 // Create tensors
1683 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1684 tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");
1685 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1686
1687 // Create operator
1688 auto op =
1689 new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER_EQUAL, tosa::Attribute::Attribute_NONE, &attr,
1690 { input1->GetName(), input2->GetName() }, { output->GetName() });
1691
1692 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1693 tosa::TosaSerializationBasicBlock block("greater_equal", "main", { op }, { input1, input2, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1694 { input1->GetName(), input2->GetName() }, { output->GetName() });
1695
1696 // Setup model
1697 TosaReference::ModelRunnerImpl runner;
1698 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1699 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1700 TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
1701
1702 // Execute
1703 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1704
1705 // Extract outputs
1706 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1707
1708 return tosa_status_valid;
1709 }
1710
1711 tosa_status_t
1712 tosa_run_reduce_all(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
1713 {
1714 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1715 const int32_t axis = client_axis;
1716 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1717
1718 // Create tensors
1719 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
1720 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1721
1722 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1723 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ALL, tosa::Attribute::Attribute_AxisAttribute,
1724 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1725
1726 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1727 tosa::TosaSerializationBasicBlock block("reduce_all", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1728 { output->GetName() });
1729
1730 // Setup model
1731 TosaReference::ModelRunnerImpl runner;
1732 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1733 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
1734
1735 // Execute
1736 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1737
1738 // Extract outputs
1739 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1740
1741 return tosa_status_valid;
1742 }
1743
1744 tosa_status_t
1745 tosa_run_reduce_any(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
1746 {
1747 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1748 const int32_t axis = client_axis;
1749 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1750
1751 // Create tensors
1752 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
1753 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1754
1755 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1756 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ANY, tosa::Attribute::Attribute_AxisAttribute,
1757 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1758
1759 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1760 tosa::TosaSerializationBasicBlock block("reduce_any", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1761 { output->GetName() });
1762
1763 // Setup model
1764 TosaReference::ModelRunnerImpl runner;
1765 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1766 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
1767
1768 // Execute
1769 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1770
1771 // Extract outputs
1772 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1773
1774 return tosa_status_valid;
1775 }
1776
1777 tosa_status_t
1778 tosa_run_reduce_max(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
1779 {
1780 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1781 const int32_t axis = client_axis;
1782 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1783
1784 // Create tensors
1785 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
1786 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1787
1788 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1789 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MAX, tosa::Attribute::Attribute_AxisAttribute,
1790 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1791
1792 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1793 tosa::TosaSerializationBasicBlock block("reduce_max", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1794 { output->GetName() });
1795
1796 // Setup model
1797 TosaReference::ModelRunnerImpl runner;
1798 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1799 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
1800
1801 // Execute
1802 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1803
1804 // Extract outputs
1805 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1806
1807 return tosa_status_valid;
1808 }
1809
1810 tosa_status_t
1811 tosa_run_reduce_min(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
1812 {
1813 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1814 const int32_t axis = client_axis;
1815 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1816
1817 // Create tensors
1818 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
1819 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1820
1821 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1822 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MIN, tosa::Attribute::Attribute_AxisAttribute,
1823 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1824
1825 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1826 tosa::TosaSerializationBasicBlock block("reduce_min", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1827 { output->GetName() });
1828
1829 // Setup model
1830 TosaReference::ModelRunnerImpl runner;
1831 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1832 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
1833
1834 // Execute
1835 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1836
1837 // Extract outputs
1838 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1839
1840 return tosa_status_valid;
1841 }
1842
1843 tosa_status_t
1844 tosa_run_reduce_product(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
1845 {
1846 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1847 const int32_t axis = client_axis;
1848 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1849
1850 // Create tensors
1851 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
1852 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1853
1854 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1855 auto op =
1856 new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_PRODUCT, tosa::Attribute::Attribute_AxisAttribute,
1857 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1858
1859 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1860 tosa::TosaSerializationBasicBlock block("reduce_product", "main", { op }, { input, output },
1861 { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1862
1863 // Setup model
1864 TosaReference::ModelRunnerImpl runner;
1865 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1866 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
1867
1868 // Execute
1869 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1870
1871 // Extract outputs
1872 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1873
1874 return tosa_status_valid;
1875 }
1876
1877 tosa_status_t
1878 tosa_run_reduce_sum(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
1879 {
1880 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1881 const int32_t axis = client_axis;
1882 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1883
1884 // Create tensors
1885 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
1886 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1887
1888 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1889 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_SUM, tosa::Attribute::Attribute_AxisAttribute,
1890 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1891
1892 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1893 tosa::TosaSerializationBasicBlock block("reduce_sum", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1894 { output->GetName() });
1895
1896 // Setup model
1897 TosaReference::ModelRunnerImpl runner;
1898 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1899 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
1900
1901 // Execute
1902 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1903
1904 // Extract outputs
1905 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1906
1907 return tosa_status_valid;
1908 }
1909
1910 tosa_status_t tosa_run_concat(tosa_tensor_t client_input1, const int32_t client_axis, tosa_tensor_t client_output)
1911 {
1912 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1913 const int32_t axis = client_axis;
1914 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1915
1916 // Create tensors
1917 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1918 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1919
1920 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]1921 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONCAT, tosa::Attribute::Attribute_AxisAttribute,
1922 &attr, { input1->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1923
1924 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1925 tosa::TosaSerializationBasicBlock block("concat", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1926 { output->GetName() });
1927
1928 // Setup model
1929 TosaReference::ModelRunnerImpl runner;
1930 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1931 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1932
1933 // Execute
1934 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1935
1936 // Extract outputs
1937 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1938
1939 return tosa_status_valid;
1940 }
1941
1942 tosa_status_t tosa_run_pad(tosa_tensor_t client_input1,
1943 const int32_t client_padding_len,
1944 const int32_t client_padding[],
1945 const int32_t client_pad_const_int,
1946 const float client_pad_const_fp,
1947 tosa_tensor_t client_output)
1948 {
1949 // Create operator attributes
1950 const std::vector<int32_t> padding(&client_padding[0], &client_padding[0] + client_padding_len);
1951 const int32_t pad_const_int = client_pad_const_int;
1952 const float pad_const_fp = client_pad_const_fp;
1953 TosaPadAttribute attr(padding, pad_const_int, pad_const_fp);
1954
1955 // Create tensors
1956 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1957 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1958
1959 // Create operator
1960 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_PAD, tosa::Attribute::Attribute_PadAttribute, &attr,
1961 { input1->GetName() }, { output->GetName() });
1962
1963 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1964 tosa::TosaSerializationBasicBlock block("pad", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]1965 { output->GetName() });
1966
1967 // Setup model
1968 TosaReference::ModelRunnerImpl runner;
1969 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
1970 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
1971
1972 // Execute
1973 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
1974
1975 // Extract outputs
1976 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
1977
1978 return tosa_status_valid;
1979 }
1980
1981 tosa_status_t tosa_run_reshape(tosa_tensor_t client_input1,
1982 const int32_t client_new_shape_len,
1983 const int32_t client_new_shape[],
1984 tosa_tensor_t client_output)
1985 {
1986 // Create operator attributes
1987 const std::vector<int32_t> new_shape(&client_new_shape[0], &client_new_shape[0] + client_new_shape_len);
1988 TosaReshapeAttribute attr(new_shape);
1989
1990 // Create tensors
1991 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
1992 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
1993
1994 // Create operator
1995 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESHAPE, tosa::Attribute::Attribute_ReshapeAttribute,
1996 &attr, { input1->GetName() }, { output->GetName() });
1997
1998 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]1999 tosa::TosaSerializationBasicBlock block("reshape", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2000 { output->GetName() });
2001
2002 // Setup model
2003 TosaReference::ModelRunnerImpl runner;
2004 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2005 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
2006
2007 // Execute
2008 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2009
2010 // Extract outputs
2011 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2012
2013 return tosa_status_valid;
2014 }
2015
2016 tosa_status_t tosa_run_reverse(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
2017 {
2018 // Create operator attributes
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]2019 const int32_t axis = client_axis;
2020 TosaAxisAttribute attr(axis);
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2021
2022 // Create tensors
2023 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
2024 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2025
2026 // Create operator
Grant Watson61680472023-05-31 14:56:13 +0100[diff] [blame]2027 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REVERSE, tosa::Attribute::Attribute_AxisAttribute,
2028 &attr, { input->GetName() }, { output->GetName() });
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2029
2030 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2031 tosa::TosaSerializationBasicBlock block("reverse", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2032 { output->GetName() });
2033
2034 // Setup model
2035 TosaReference::ModelRunnerImpl runner;
2036 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2037 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
2038
2039 // Execute
2040 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2041
2042 // Extract outputs
2043 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2044
2045 return tosa_status_valid;
2046 }
2047
2048 tosa_status_t tosa_run_slice(tosa_tensor_t client_input1,
2049 const int32_t client_start_len,
2050 const int32_t client_start[],
2051 const int32_t client_size_len,
2052 const int32_t client_size[],
2053 tosa_tensor_t client_output)
2054 {
2055 // Create operator attributes
2056 const std::vector<int32_t> start(&client_start[0], &client_start[0] + client_start_len);
2057 const std::vector<int32_t> size(&client_size[0], &client_size[0] + client_size_len);
2058 TosaSliceAttribute attr(start, size);
2059
2060 // Create tensors
2061 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
2062 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2063
2064 // Create operator
2065 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SLICE, tosa::Attribute::Attribute_SliceAttribute,
2066 &attr, { input1->GetName() }, { output->GetName() });
2067
2068 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2069 tosa::TosaSerializationBasicBlock block("slice", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2070 { output->GetName() });
2071
2072 // Setup model
2073 TosaReference::ModelRunnerImpl runner;
2074 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2075 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
2076
2077 // Execute
2078 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2079
2080 // Extract outputs
2081 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2082
2083 return tosa_status_valid;
2084 }
2085
2086 tosa_status_t tosa_run_tile(tosa_tensor_t client_input1,
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2087 const int32_t client_multiples_len,
2088 const int32_t client_multiples[],
2089 tosa_tensor_t client_output)
2090 {
2091 // Create operator attributes
2092 const std::vector<int32_t> multiples(&client_multiples[0], &client_multiples[0] + client_multiples_len);
2093 TosaTileAttribute attr(multiples);
2094
2095 // Create tensors
2096 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
2097 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2098
2099 // Create operator
2100 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TILE, tosa::Attribute::Attribute_TileAttribute,
2101 &attr, { input1->GetName() }, { output->GetName() });
2102
2103 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2104 tosa::TosaSerializationBasicBlock block("tile", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2105 { output->GetName() });
2106
2107 // Setup model
2108 TosaReference::ModelRunnerImpl runner;
2109 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2110 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
2111
2112 // Execute
2113 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2114
2115 // Extract outputs
2116 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2117
2118 return tosa_status_valid;
2119 }
2120
2121 tosa_status_t tosa_run_transpose(tosa_tensor_t client_input1,
2122 const int32_t client_perms_len,
2123 const int32_t client_perms[],
2124 tosa_tensor_t client_output)
2125 {
2126 // Create operator attributes
2127 const std::vector<int32_t> perms(&client_perms[0], &client_perms[0] + client_perms_len);
2128 TosaTransposeAttribute attr(perms);
2129
2130 // Create tensors
2131 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
2132 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2133
2134 // Create operator
2135 auto op =
2136 new tosa::TosaSerializationOperator(tosa::Op::Op_TRANSPOSE, tosa::Attribute::Attribute_TransposeAttribute,
2137 &attr, { input1->GetName() }, { output->GetName() });
2138
2139 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2140 tosa::TosaSerializationBasicBlock block("transpose", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2141 { output->GetName() });
2142
2143 // Setup model
2144 TosaReference::ModelRunnerImpl runner;
2145 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2146 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
2147
2148 // Execute
2149 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2150
2151 // Extract outputs
2152 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2153
2154 return tosa_status_valid;
2155 }
2156
2157 tosa_status_t
2158 tosa_run_gather(tosa_tensor_t client_values, tosa_tensor_t client_indices, tosa_tensor_t client_output)
2159 {
2160 // Create operator attributes
2161 TosaNoneAttribute attr;
2162
2163 // Create tensors
2164 tosa::TosaSerializationTensor* values = translate_client_tensor(client_values, "values");
2165 tosa::TosaSerializationTensor* indices = translate_client_tensor(client_indices, "indices");
2166 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2167
2168 // Create operator
2169 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GATHER, tosa::Attribute::Attribute_NONE, &attr,
2170 { values->GetName(), indices->GetName() }, { output->GetName() });
2171
2172 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2173 tosa::TosaSerializationBasicBlock block("gather", "main", { op }, { values, indices, output },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2174 { values->GetName(), indices->GetName() }, { output->GetName() });
2175
2176 // Setup model
2177 TosaReference::ModelRunnerImpl runner;
2178 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2179 TOSA_RETURN_ON_ERROR(runner.setInput(values->GetName(), client_values.data, client_values.size));
2180 TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));
2181
2182 // Execute
2183 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2184
2185 // Extract outputs
2186 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2187
2188 return tosa_status_valid;
2189 }
2190
2191 tosa_status_t tosa_run_scatter(tosa_tensor_t client_values_in,
2192 tosa_tensor_t client_indices,
2193 tosa_tensor_t client_input,
2194 tosa_tensor_t client_values_out)
2195 {
2196 // Create operator attributes
2197 TosaNoneAttribute attr;
2198
2199 // Create tensors
2200 tosa::TosaSerializationTensor* values_in = translate_client_tensor(client_values_in, "values_in");
2201 tosa::TosaSerializationTensor* indices = translate_client_tensor(client_indices, "indices");
2202 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
2203 tosa::TosaSerializationTensor* values_out = translate_client_tensor(client_values_out, "values_out");
2204
2205 // Create operator
2206 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SCATTER, tosa::Attribute::Attribute_NONE, &attr,
2207 { values_in->GetName(), indices->GetName(), input->GetName() },
2208 { values_out->GetName() });
2209
2210 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2211 tosa::TosaSerializationBasicBlock block("scatter", "main", { op }, { values_in, indices, input, values_out },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2212 { values_in->GetName(), indices->GetName(), input->GetName() },
2213 { values_out->GetName() });
2214
2215 // Setup model
2216 TosaReference::ModelRunnerImpl runner;
2217 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2218 TOSA_RETURN_ON_ERROR(runner.setInput(values_in->GetName(), client_values_in.data, client_values_in.size));
2219 TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));
2220 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
2221
2222 // Execute
2223 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2224
2225 // Extract outputs
2226 TOSA_RETURN_ON_ERROR(runner.getOutput(values_out->GetName(), client_values_out.data, client_values_out.size));
2227
2228 return tosa_status_valid;
2229 }
2230
2231 tosa_status_t tosa_run_resize(tosa_tensor_t client_input,
2232 const int16_t client_scale[4],
2233 const int16_t client_offset[2],
2234 const int16_t client_border[2],
2235 const tosa_mode_t client_mode,
2236 tosa_tensor_t client_output)
2237 {
2238 // Create operator attributes
2239 const std::vector<int16_t> scale(&client_scale[0], &client_scale[4]);
2240 const std::vector<int16_t> offset(&client_offset[0], &client_offset[2]);
2241 const std::vector<int16_t> border(&client_border[0], &client_border[2]);
2242 const ResizeMode mode = translate_client_tosa_mode(client_mode);
2243 TosaResizeAttribute attr(scale, offset, border, mode);
2244
2245 // Create tensors
2246 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
2247 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2248
2249 // Create operator
2250 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESIZE, tosa::Attribute::Attribute_ResizeAttribute,
2251 &attr, { input->GetName() }, { output->GetName() });
2252
2253 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2254 tosa::TosaSerializationBasicBlock block("resize", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2255 { output->GetName() });
2256
2257 // Setup model
2258 TosaReference::ModelRunnerImpl runner;
2259 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2260 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
2261
2262 // Execute
2263 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2264
2265 // Extract outputs
2266 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2267
2268 return tosa_status_valid;
2269 }
2270
2271 tosa_status_t tosa_run_cast(tosa_tensor_t client_input, tosa_tensor_t client_output)
2272 {
2273 // Create operator attributes
2274 TosaNoneAttribute attr;
2275
2276 // Create tensors
2277 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
2278 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2279
2280 // Create operator
2281 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CAST, tosa::Attribute::Attribute_NONE, &attr,
2282 { input->GetName() }, { output->GetName() });
2283
2284 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2285 tosa::TosaSerializationBasicBlock block("cast", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2286 { output->GetName() });
2287
2288 // Setup model
2289 TosaReference::ModelRunnerImpl runner;
2290 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2291 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
2292
2293 // Execute
2294 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2295
2296 // Extract outputs
2297 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2298
2299 return tosa_status_valid;
2300 }
2301
2302 tosa_status_t tosa_run_rescale(tosa_tensor_t client_input,
2303 tosa_tensor_t client_output,
2304 const int32_t client_input_zp,
2305 const int32_t client_output_zp,
2306 const int32_t client_multiplier_len,
2307 const int32_t client_multiplier[],
2308 const int32_t client_shift_len,
Grant Watsoneb741062023-06-23 16:52:12 +0100[diff] [blame]2309 const int32_t client_shift[],
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2310 const bool client_scale32,
2311 const bool client_double_round,
2312 const bool client_per_channel)
2313 {
2314 // Create operator attributes
2315 const int32_t input_zp = client_input_zp;
2316 const int32_t output_zp = client_output_zp;
2317 const std::vector<int32_t> multiplier(&client_multiplier[0], &client_multiplier[0] + client_multiplier_len);
2318 const std::vector<int32_t> shift(&client_shift[0], &client_shift[0] + client_shift_len);
2319 const bool scale32 = client_scale32;
2320 const bool double_round = client_double_round;
2321 const bool per_channel = client_per_channel;
2322 TosaRescaleAttribute attr(input_zp, output_zp, multiplier, shift, scale32, double_round, per_channel);
2323
2324 // Create tensors
2325 tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");
2326 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2327
2328 // Create operator
2329 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESCALE, tosa::Attribute::Attribute_RescaleAttribute,
2330 &attr, { input->GetName() }, { output->GetName() });
2331
2332 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2333 tosa::TosaSerializationBasicBlock block("rescale", "main", { op }, { input, output }, { input->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2334 { output->GetName() });
2335
2336 // Setup model
2337 TosaReference::ModelRunnerImpl runner;
2338 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2339 TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
2340
2341 // Execute
2342 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2343
2344 // Extract outputs
2345 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2346
2347 return tosa_status_valid;
2348 }
2349
2350 tosa_status_t tosa_run_identity(tosa_tensor_t client_input1, tosa_tensor_t client_output)
2351 {
2352 // Create operator attributes
2353 TosaNoneAttribute attr;
2354
2355 // Create tensors
2356 tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");
2357 tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
2358
2359 // Create operator
2360 auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_IDENTITY, tosa::Attribute::Attribute_NONE, &attr,
2361 { input1->GetName() }, { output->GetName() });
2362
2363 // Create a tosa single-op basic block
Jerry Ge9e94af82022-10-27 09:57:00 -0700[diff] [blame]2364 tosa::TosaSerializationBasicBlock block("identity", "main", { op }, { input1, output }, { input1->GetName() },
Grant Watson64285a12022-11-16 15:32:39 +0000[diff] [blame]2365 { output->GetName() });
2366
2367 // Setup model
2368 TosaReference::ModelRunnerImpl runner;
2369 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
2370 TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
2371
2372 // Execute
2373 TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
2374
2375 // Extract outputs
2376 TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
2377
2378 return tosa_status_valid;
2379 }
2380
Won Jeon78155c62023-06-10 00:20:04 +0000[diff] [blame]2381} // extern "C"