Blame - reference_model/src/operators.cc - tosa/reference_model

Grant Watson

64285a1

2022-11-16 15:32:39 +0000

[diff] [blame^]

//

// 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) \

do \

{ \

if (status != 0) \

{ \

return tosa_status_error; \

} \

} while (false)

#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); \

} \

} while (false)

namespace

{

tosa::DType translate_client_datatype(tosa_datatype_t type)

{

switch (type)

{

case tosa_datatype_fp16_t:

50

return tosa::DType::DType_FP16;

51

case tosa_datatype_fp32_t:

52

return tosa::DType::DType_FP32;

53

default:

54

return tosa::DType::DType_UNKNOWN;

}

};

tosa::TosaSerializationTensor* translate_client_tensor(tosa_tensor_t& tensor, const std::string& name)

59

{

60

std::vector<int32_t> shape(tensor.shape, tensor.shape + tensor.num_dims);

61

return new tosa::TosaSerializationTensor(name, shape, translate_client_datatype(tensor.data_type), {});

62

}

63

64

tosa::ResizeMode translate_client_tosa_mode(tosa_mode_t mode)

{

switch (mode)

{

case tosa_mode_nearest:

69

return tosa::ResizeMode_NEAREST;

70

case tosa_mode_max:

71

case tosa_mode_bilinear:

72

return tosa::ResizeMode_BILINEAR;

73

default:

74

return tosa::ResizeMode_UNKNOWN;

}

}

} // namespace

extern "C"

{

tosa_status_t tosa_run_argmax(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

84

{

85

// Create operator attributes

86

TosaNoneAttribute attr;

87

88

// Create tensors

89

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

90

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

91

92

// Create operator

93

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ARGMAX, tosa::Attribute::Attribute_NONE, &attr,

94

{ input->GetName() }, { output->GetName() });

95

96

// Create a tosa single-op basic block

97

tosa::TosaSerializationBasicBlock block("argmax", { op }, { input, output }, { input->GetName() },

98

{ output->GetName() });

99

100

// Setup model

101

TosaReference::ModelRunnerImpl runner;

102

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

103

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

104

105

// Execute

106

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

107

108

// Extract outputs

109

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

110

111

return tosa_status_valid;

112

}

113

114

tosa_status_t tosa_run_avg_pool2d(tosa_tensor_t client_input,

115

const int32_t client_kernel[2],

116

const int32_t client_stride[2],

117

const int32_t client_pad[4],

118

const int32_t client_input_zp,

119

const int32_t client_output_zp,

120

tosa_tensor_t client_output)

121

{

122

// Create operator attributes

123

const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);

124

const std::vector<int32_t> kernel(&client_kernel[0], &client_kernel[2]);

125

const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);

126

const int32_t input_zp = client_input_zp;

127

const int32_t output_zp = client_output_zp;

128

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

129

TosaPoolAttribute attr(pad, kernel, stride, input_zp, output_zp, accum_dtype);

130

131

// Create tensors

132

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

133

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

134

135

// Create operator

136

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_AVG_POOL2D, tosa::Attribute::Attribute_PoolAttribute,

137

&attr, { input->GetName() }, { output->GetName() });

138

139

// Create a tosa single-op basic block

140

tosa::TosaSerializationBasicBlock block("avg_pool2d", { op }, { input, output }, { input->GetName() },

141

{ output->GetName() });

142

143

// Setup model

144

TosaReference::ModelRunnerImpl runner;

145

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

146

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

147

148

// Execute

149

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

150

151

// Extract outputs

152

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

153

154

return tosa_status_valid;

155

}

156

157

tosa_status_t tosa_run_conv2d(tosa_tensor_t client_input,

158

tosa_tensor_t client_weight,

159

tosa_tensor_t client_bias,

160

const int32_t client_pad[4],

161

const int32_t client_stride[2],

162

const int32_t client_dilation[2],

163

const int32_t client_input_zp,

164

const int32_t client_weight_zp,

165

tosa_tensor_t client_output)

166

{

167

// Create operator attributes

168

const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);

169

const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);

170

const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[2]);

171

const int32_t input_zp = client_input_zp;

172

const int32_t weight_zp = client_weight_zp;

173

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

174

TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp, accum_dtype);

175

176

// Create tensors

177

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

178

tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");

179

tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");

180

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

181

182

// Create operator

183

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONV2D, tosa::Attribute::Attribute_ConvAttribute,

184

&attr, { input->GetName(), weight->GetName(), bias->GetName() },

185

{ output->GetName() });

186

187

// Create a tosa single-op basic block

188

tosa::TosaSerializationBasicBlock block("conv2d", { op }, { input, weight, bias, output },

189

{ input->GetName(), weight->GetName(), bias->GetName() },

190

{ output->GetName() });

191

192

// Setup model

193

TosaReference::ModelRunnerImpl runner;

194

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

195

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

196

TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));

197

TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));

198

199

// Execute

200

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

201

202

// Extract outputs

203

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

204

205

return tosa_status_valid;

206

}

207

208

tosa_status_t tosa_run_conv3d(tosa_tensor_t client_input,

209

tosa_tensor_t client_weight,

210

tosa_tensor_t client_bias,

211

const int32_t client_pad[6],

212

const int32_t client_stride[3],

213

const int32_t client_dilation[3],

214

const int32_t client_input_zp,

215

const int32_t client_weight_zp,

216

tosa_tensor_t client_output)

217

{

218

// Create operator attributes

219

const std::vector<int32_t> pad(&client_pad[0], &client_pad[6]);

220

const std::vector<int32_t> stride(&client_stride[0], &client_stride[3]);

221

const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[3]);

222

const int32_t input_zp = client_input_zp;

223

const int32_t weight_zp = client_weight_zp;

224

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

225

TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp, accum_dtype);

226

227

// Create tensors

228

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

229

tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");

230

tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");

231

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

232

233

// Create operator

234

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONV3D, tosa::Attribute::Attribute_ConvAttribute,

235

&attr, { input->GetName(), weight->GetName(), bias->GetName() },

236

{ output->GetName() });

237

238

// Create a tosa single-op basic block

239

tosa::TosaSerializationBasicBlock block("conv3d", { op }, { input, weight, bias, output },

240

{ input->GetName(), weight->GetName(), bias->GetName() },

241

{ output->GetName() });

242

243

// Setup model

244

TosaReference::ModelRunnerImpl runner;

245

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

246

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

247

TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));

248

TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));

249

250

// Execute

251

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

252

253

// Extract outputs

254

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

255

256

return tosa_status_valid;

257

}

258

259

tosa_status_t tosa_run_depthwise_conv2d(tosa_tensor_t client_input,

260

tosa_tensor_t client_weight,

261

tosa_tensor_t client_bias,

262

const int32_t client_pad[4],

263

const int32_t client_stride[2],

264

const int32_t client_dilation[2],

265

const int32_t client_input_zp,

266

const int32_t client_weight_zp,

267

tosa_tensor_t client_output)

268

{

269

// Create operator attributes

270

const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);

271

const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);

272

const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[2]);

273

const int32_t input_zp = client_input_zp;

274

const int32_t weight_zp = client_weight_zp;

275

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

276

TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp, accum_dtype);

277

278

// Create tensors

279

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

280

tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");

281

tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");

282

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

283

284

// Create operator

285

auto op = new tosa::TosaSerializationOperator(

286

tosa::Op::Op_DEPTHWISE_CONV2D, tosa::Attribute::Attribute_ConvAttribute, &attr,

287

{ input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });

288

289

// Create a tosa single-op basic block

290

tosa::TosaSerializationBasicBlock block("depthwise_conv2d", { op }, { input, weight, bias, output },

291

{ input->GetName(), weight->GetName(), bias->GetName() },

292

{ output->GetName() });

293

294

// Setup model

295

TosaReference::ModelRunnerImpl runner;

296

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

297

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

298

TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));

299

TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));

300

301

// Execute

302

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

303

304

// Extract outputs

305

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

306

307

return tosa_status_valid;

308

}

309

310

tosa_status_t tosa_run_fully_connected(tosa_tensor_t client_input,

311

const int32_t client_input_zp,

312

const int32_t client_weight_zp,

313

tosa_tensor_t client_output)

314

{

315

// Create operator attributes

316

const int32_t input_zp = client_input_zp;

317

const int32_t weight_zp = client_weight_zp;

318

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

319

TosaFullyConnectedAttribute attr(input_zp, weight_zp, accum_dtype);

320

321

// Create tensors

322

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

323

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

324

325

// Create operator

326

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FULLY_CONNECTED,

327

tosa::Attribute::Attribute_FullyConnectedAttribute, &attr,

328

{ input->GetName() }, { output->GetName() });

329

330

// Create a tosa single-op basic block

331

tosa::TosaSerializationBasicBlock block("fully_connected", { op }, { input, output }, { input->GetName() },

332

{ output->GetName() });

333

334

// Setup model

335

TosaReference::ModelRunnerImpl runner;

336

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

337

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

338

339

// Execute

340

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

341

342

// Extract outputs

343

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

344

345

return tosa_status_valid;

346

}

347

348

tosa_status_t tosa_run_matmul(tosa_tensor_t client_a,

349

tosa_tensor_t client_b,

350

const int32_t client_a_zp,

351

const int32_t client_b_zp,

352

tosa_tensor_t client_output)

353

{

354

// Create operator attributes

355

const int32_t a_zp = client_a_zp;

356

const int32_t b_zp = client_b_zp;

357

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

358

TosaMatMulAttribute attr(a_zp, b_zp, accum_dtype);

359

360

// Create tensors

361

tosa::TosaSerializationTensor* a = translate_client_tensor(client_a, "a");

362

tosa::TosaSerializationTensor* b = translate_client_tensor(client_b, "b");

363

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

364

365

// Create operator

366

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MATMUL, tosa::Attribute::Attribute_MatMulAttribute,

367

&attr, { a->GetName(), b->GetName() }, { output->GetName() });

368

369

// Create a tosa single-op basic block

370

tosa::TosaSerializationBasicBlock block("matmul", { op }, { a, b, output }, { a->GetName(), b->GetName() },

371

{ output->GetName() });

372

373

// Setup model

374

TosaReference::ModelRunnerImpl runner;

375

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

376

TOSA_RETURN_ON_ERROR(runner.setInput(a->GetName(), client_a.data, client_a.size));

377

TOSA_RETURN_ON_ERROR(runner.setInput(b->GetName(), client_b.data, client_b.size));

378

379

// Execute

380

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

381

382

// Extract outputs

383

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

384

385

return tosa_status_valid;

386

}

387

388

tosa_status_t tosa_run_max_pool2d(tosa_tensor_t client_input,

389

const int32_t client_kernel[2],

390

const int32_t client_stride[2],

391

const int32_t client_pad[4],

392

const int32_t client_input_zp,

393

const int32_t client_output_zp,

394

tosa_tensor_t client_output)

395

{

396

// Create operator attributes

397

const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);

398

const std::vector<int32_t> kernel(&client_kernel[0], &client_kernel[2]);

399

const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);

400

const int32_t input_zp = client_input_zp;

401

const int32_t output_zp = client_output_zp;

402

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

403

TosaPoolAttribute attr(pad, kernel, stride, input_zp, output_zp, accum_dtype);

404

405

// Create tensors

406

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

407

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

408

409

// Create operator

410

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MAX_POOL2D, tosa::Attribute::Attribute_PoolAttribute,

411

&attr, { input->GetName() }, { output->GetName() });

412

413

// Create a tosa single-op basic block

414

tosa::TosaSerializationBasicBlock block("max_pool2d", { op }, { input, output }, { input->GetName() },

415

{ output->GetName() });

416

417

// Setup model

418

TosaReference::ModelRunnerImpl runner;

419

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

420

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

421

422

// Execute

423

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

424

425

// Extract outputs

426

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

427

428

return tosa_status_valid;

429

}

430

431

tosa_status_t tosa_run_transpose_conv2d(tosa_tensor_t client_input,

432

tosa_tensor_t client_weight,

433

tosa_tensor_t client_bias,

434

const int32_t client_out_pad[4],

435

const int32_t client_stride[2],

436

const int32_t client_out_shape[4],

437

const int32_t client_input_zp,

438

const int32_t client_weight_zp,

439

const int32_t client_pad_len,

440

const int32_t client_pad[],

441

const int32_t client_dilation_len,

442

const int32_t client_dilation[],

443

tosa_tensor_t client_output)

444

{

445

// Create operator attributes

446

const std::vector<int32_t> pad(&client_pad[0], &client_pad[0] + client_pad_len);

447

const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);

448

const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[0] + client_dilation_len);

449

const int32_t input_zp = client_input_zp;

450

const int32_t weight_zp = client_weight_zp;

451

const tosa::DType accum_dtype = tosa::DType::DType_FP32;

452

TosaConvAttribute attr(pad, stride, dilation, input_zp, weight_zp, accum_dtype);

453

454

// Create tensors

455

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

456

tosa::TosaSerializationTensor* weight = translate_client_tensor(client_weight, "weight");

457

tosa::TosaSerializationTensor* bias = translate_client_tensor(client_bias, "bias");

458

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

459

460

// Create operator

461

auto op = new tosa::TosaSerializationOperator(

462

tosa::Op::Op_TRANSPOSE_CONV2D, tosa::Attribute::Attribute_ConvAttribute, &attr,

463

{ input->GetName(), weight->GetName(), bias->GetName() }, { output->GetName() });

464

465

// Create a tosa single-op basic block

466

tosa::TosaSerializationBasicBlock block("transpose_conv2d", { op }, { input, weight, bias, output },

467

{ input->GetName(), weight->GetName(), bias->GetName() },

468

{ output->GetName() });

469

470

// Setup model

471

TosaReference::ModelRunnerImpl runner;

472

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

473

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

474

TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));

475

TOSA_RETURN_ON_ERROR(runner.setInput(bias->GetName(), client_bias.data, client_bias.size));

476

477

// Execute

478

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

479

480

// Extract outputs

481

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

482

483

return tosa_status_valid;

484

}

485

486

tosa_status_t tosa_run_clamp(tosa_tensor_t client_input,

487

const int32_t client_min_int,

488

const int32_t client_max_int,

489

const float client_min_fp,

490

const float client_max_fp,

491

tosa_tensor_t client_output)

492

{

493

// Create operator attributes

494

const int32_t min_int = client_min_int;

495

const int32_t max_int = client_max_int;

496

const float min_fp = client_min_fp;

497

const float max_fp = client_max_fp;

498

TosaClampAttribute attr(min_int, max_int, min_fp, max_fp);

499

500

// Create tensors

501

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

502

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

503

504

// Create operator

505

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CLAMP, tosa::Attribute::Attribute_ClampAttribute,

506

&attr, { input->GetName() }, { output->GetName() });

507

508

// Create a tosa single-op basic block

509

tosa::TosaSerializationBasicBlock block("clamp", { op }, { input, output }, { input->GetName() },

510

{ output->GetName() });

511

512

// Setup model

513

TosaReference::ModelRunnerImpl runner;

514

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

515

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

516

517

// Execute

518

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

519

520

// Extract outputs

521

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

522

523

return tosa_status_valid;

524

}

525

526

tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input, tosa_tensor_t client_output)

527

{

528

// Create operator attributes

529

TosaNoneAttribute attr;

530

531

// Create tensors

532

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

533

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

534

535

// Create operator

536

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SIGMOID, tosa::Attribute::Attribute_NONE, &attr,

537

{ input->GetName() }, { output->GetName() });

538

539

// Create a tosa single-op basic block

540

tosa::TosaSerializationBasicBlock block("sigmoid", { op }, { input, output }, { input->GetName() },

541

{ output->GetName() });

542

543

// Setup model

544

TosaReference::ModelRunnerImpl runner;

545

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

546

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

547

548

// Execute

549

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

550

551

// Extract outputs

552

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

553

554

return tosa_status_valid;

555

}

556

557

tosa_status_t tosa_run_tanh(tosa_tensor_t client_input, tosa_tensor_t client_output)

558

{

559

// Create operator attributes

560

TosaNoneAttribute attr;

561

562

// Create tensors

563

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

564

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

565

566

// Create operator

567

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TANH, tosa::Attribute::Attribute_NONE, &attr,

568

{ input->GetName() }, { output->GetName() });

569

570

// Create a tosa single-op basic block

571

tosa::TosaSerializationBasicBlock block("tanh", { op }, { input, output }, { input->GetName() },

572

{ output->GetName() });

573

574

// Setup model

575

TosaReference::ModelRunnerImpl runner;

576

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

577

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

578

579

// Execute

580

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

581

582

// Extract outputs

583

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

584

585

return tosa_status_valid;

586

}

587

588

tosa_status_t tosa_run_add(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

589

{

590

// Create operator attributes

591

TosaNoneAttribute attr;

592

593

// Create tensors

594

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

595

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

596

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

597

598

// Create operator

599

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ADD, tosa::Attribute::Attribute_NONE, &attr,

600

{ input1->GetName(), input2->GetName() }, { output->GetName() });

601

602

// Create a tosa single-op basic block

603

tosa::TosaSerializationBasicBlock block("add", { op }, { input1, input2, output },

604

{ input1->GetName(), input2->GetName() }, { output->GetName() });

605

606

// Setup model

607

TosaReference::ModelRunnerImpl runner;

608

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

609

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

610

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

611

612

// Execute

613

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

614

615

// Extract outputs

616

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

617

618

return tosa_status_valid;

619

}

620

621

tosa_status_t tosa_run_arithmetic_right_shift(tosa_tensor_t client_input1,

622

tosa_tensor_t client_input2,

623

const bool client_round,

624

tosa_tensor_t client_output)

625

{

626

// Create operator attributes

627

const bool round = client_round;

628

TosaArithmeticRightShiftAttribute attr(round);

629

630

// Create tensors

631

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

632

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

633

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

634

635

// Create operator

636

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ARITHMETIC_RIGHT_SHIFT,

637

tosa::Attribute::Attribute_ArithmeticRightShiftAttribute, &attr,

638

{ input1->GetName(), input2->GetName() }, { output->GetName() });

639

640

// Create a tosa single-op basic block

641

tosa::TosaSerializationBasicBlock block("arithmetic_right_shift", { op }, { input1, input2, output },

642

{ input1->GetName(), input2->GetName() }, { output->GetName() });

643

644

// Setup model

645

TosaReference::ModelRunnerImpl runner;

646

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

647

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

648

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

649

650

// Execute

651

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

652

653

// Extract outputs

654

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

655

656

return tosa_status_valid;

}

tosa_status_t

tosa_run_bitwise_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

661

{

662

// Create operator attributes

663

TosaNoneAttribute attr;

664

665

// Create tensors

666

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

667

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

668

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

669

670

// Create operator

671

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_AND, tosa::Attribute::Attribute_NONE, &attr,

672

{ input1->GetName(), input2->GetName() }, { output->GetName() });

673

674

// Create a tosa single-op basic block

675

tosa::TosaSerializationBasicBlock block("bitwise_and", { op }, { input1, input2, output },

676

{ input1->GetName(), input2->GetName() }, { output->GetName() });

677

678

// Setup model

679

TosaReference::ModelRunnerImpl runner;

680

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

681

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

682

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

683

684

// Execute

685

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

686

687

// Extract outputs

688

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

689

690

return tosa_status_valid;

}

tosa_status_t

tosa_run_bitwise_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

695

{

696

// Create operator attributes

697

TosaNoneAttribute attr;

698

699

// Create tensors

700

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

701

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

702

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

703

704

// Create operator

705

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_OR, tosa::Attribute::Attribute_NONE, &attr,

706

{ input1->GetName(), input2->GetName() }, { output->GetName() });

707

708

// Create a tosa single-op basic block

709

tosa::TosaSerializationBasicBlock block("bitwise_or", { op }, { input1, input2, output },

710

{ input1->GetName(), input2->GetName() }, { output->GetName() });

711

712

// Setup model

713

TosaReference::ModelRunnerImpl runner;

714

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

715

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

716

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

717

718

// Execute

719

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

720

721

// Extract outputs

722

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

723

724

return tosa_status_valid;

}

tosa_status_t

tosa_run_bitwise_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

729

{

730

// Create operator attributes

731

TosaNoneAttribute attr;

732

733

// Create tensors

734

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

735

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

736

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

737

738

// Create operator

739

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_XOR, tosa::Attribute::Attribute_NONE, &attr,

740

{ input1->GetName(), input2->GetName() }, { output->GetName() });

741

742

// Create a tosa single-op basic block

743

tosa::TosaSerializationBasicBlock block("bitwise_xor", { op }, { input1, input2, output },

744

{ input1->GetName(), input2->GetName() }, { output->GetName() });

745

746

// Setup model

747

TosaReference::ModelRunnerImpl runner;

748

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

749

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

750

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

751

752

// Execute

753

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

754

755

// Extract outputs

756

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

757

758

return tosa_status_valid;

759

}

760

761

tosa_status_t tosa_run_intdiv(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

762

{

763

// Create operator attributes

764

TosaNoneAttribute attr;

765

766

// Create tensors

767

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

768

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

769

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

770

771

// Create operator

772

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_INTDIV, tosa::Attribute::Attribute_NONE, &attr,

773

{ input1->GetName(), input2->GetName() }, { output->GetName() });

774

775

// Create a tosa single-op basic block

776

tosa::TosaSerializationBasicBlock block("intdiv", { op }, { input1, input2, output },

777

{ input1->GetName(), input2->GetName() }, { output->GetName() });

778

779

// Setup model

780

TosaReference::ModelRunnerImpl runner;

781

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

782

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

783

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

784

785

// Execute

786

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

787

788

// Extract outputs

789

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

790

791

return tosa_status_valid;

}

tosa_status_t

tosa_run_logical_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

796

{

797

// Create operator attributes

798

TosaNoneAttribute attr;

799

800

// Create tensors

801

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

802

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

803

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

804

805

// Create operator

806

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_AND, tosa::Attribute::Attribute_NONE, &attr,

807

{ input1->GetName(), input2->GetName() }, { output->GetName() });

808

809

// Create a tosa single-op basic block

810

tosa::TosaSerializationBasicBlock block("logical_and", { op }, { input1, input2, output },

811

{ input1->GetName(), input2->GetName() }, { output->GetName() });

812

813

// Setup model

814

TosaReference::ModelRunnerImpl runner;

815

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

816

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

817

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

818

819

// Execute

820

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

821

822

// Extract outputs

823

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

824

825

return tosa_status_valid;

826

}

827

828

tosa_status_t tosa_run_logical_left_shift(tosa_tensor_t client_input1,

829

tosa_tensor_t client_input2,

830

tosa_tensor_t client_output)

831

{

832

// Create operator attributes

833

TosaNoneAttribute attr;

834

835

// Create tensors

836

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

837

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

838

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

// Create operator

auto op =

new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_LEFT_SHIFT, tosa::Attribute::Attribute_NONE, &attr,

843

{ input1->GetName(), input2->GetName() }, { output->GetName() });

844

845

// Create a tosa single-op basic block

846

tosa::TosaSerializationBasicBlock block("logical_left_shift", { op }, { input1, input2, output },

847

{ input1->GetName(), input2->GetName() }, { output->GetName() });

848

849

// Setup model

850

TosaReference::ModelRunnerImpl runner;

851

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

852

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

853

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

854

855

// Execute

856

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

857

858

// Extract outputs

859

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

860

861

return tosa_status_valid;

862

}

863

864

tosa_status_t tosa_run_logical_right_shift(tosa_tensor_t client_input1,

865

tosa_tensor_t client_input2,

866

tosa_tensor_t client_output)

867

{

868

// Create operator attributes

869

TosaNoneAttribute attr;

870

871

// Create tensors

872

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

873

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

874

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

// Create operator

auto op =

new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_RIGHT_SHIFT, tosa::Attribute::Attribute_NONE,

879

&attr, { input1->GetName(), input2->GetName() }, { output->GetName() });

880

881

// Create a tosa single-op basic block

882

tosa::TosaSerializationBasicBlock block("logical_right_shift", { op }, { input1, input2, output },

883

{ input1->GetName(), input2->GetName() }, { output->GetName() });

884

885

// Setup model

886

TosaReference::ModelRunnerImpl runner;

887

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

888

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

889

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

890

891

// Execute

892

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

893

894

// Extract outputs

895

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

896

897

return tosa_status_valid;

}

tosa_status_t

tosa_run_logical_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

902

{

903

// Create operator attributes

904

TosaNoneAttribute attr;

905

906

// Create tensors

907

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

908

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

909

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

910

911

// Create operator

912

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_OR, tosa::Attribute::Attribute_NONE, &attr,

913

{ input1->GetName(), input2->GetName() }, { output->GetName() });

914

915

// Create a tosa single-op basic block

916

tosa::TosaSerializationBasicBlock block("logical_or", { op }, { input1, input2, output },

917

{ input1->GetName(), input2->GetName() }, { output->GetName() });

918

919

// Setup model

920

TosaReference::ModelRunnerImpl runner;

921

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

922

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

923

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

924

925

// Execute

926

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

927

928

// Extract outputs

929

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

930

931

return tosa_status_valid;

}

tosa_status_t

tosa_run_logical_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

936

{

937

// Create operator attributes

938

TosaNoneAttribute attr;

939

940

// Create tensors

941

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

942

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

943

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

944

945

// Create operator

946

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_XOR, tosa::Attribute::Attribute_NONE, &attr,

947

{ input1->GetName(), input2->GetName() }, { output->GetName() });

948

949

// Create a tosa single-op basic block

950

tosa::TosaSerializationBasicBlock block("logical_xor", { op }, { input1, input2, output },

951

{ input1->GetName(), input2->GetName() }, { output->GetName() });

952

953

// Setup model

954

TosaReference::ModelRunnerImpl runner;

955

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

956

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

957

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

958

959

// Execute

960

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

961

962

// Extract outputs

963

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

964

965

return tosa_status_valid;

}

tosa_status_t

tosa_run_maximum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

970

{

971

// Create operator attributes

972

TosaNoneAttribute attr;

973

974

// Create tensors

975

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

976

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

977

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

978

979

// Create operator

980

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MAXIMUM, tosa::Attribute::Attribute_NONE, &attr,

981

{ input1->GetName(), input2->GetName() }, { output->GetName() });

982

983

// Create a tosa single-op basic block

984

tosa::TosaSerializationBasicBlock block("maximum", { op }, { input1, input2, output },

985

{ input1->GetName(), input2->GetName() }, { output->GetName() });

986

987

// Setup model

988

TosaReference::ModelRunnerImpl runner;

989

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

990

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

991

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

992

993

// Execute

994

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

995

996

// Extract outputs

997

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

998

999

return tosa_status_valid;

}

tosa_status_t

tosa_run_minimum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

1004

{

1005

// Create operator attributes

1006

TosaNoneAttribute attr;

1007

1008

// Create tensors

1009

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1010

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1011

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1012

1013

// Create operator

1014

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MINIMUM, tosa::Attribute::Attribute_NONE, &attr,

1015

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1016

1017

// Create a tosa single-op basic block

1018

tosa::TosaSerializationBasicBlock block("minimum", { op }, { input1, input2, output },

1019

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1020

1021

// Setup model

1022

TosaReference::ModelRunnerImpl runner;

1023

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1024

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1025

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1026

1027

// Execute

1028

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1029

1030

// Extract outputs

1031

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1032

1033

return tosa_status_valid;

1034

}

1035

1036

tosa_status_t tosa_run_mul(tosa_tensor_t client_input1,

1037

tosa_tensor_t client_input2,

1038

const uint8_t client_shift,

1039

tosa_tensor_t client_output)

1040

{

1041

// Create operator attributes

1042

const int32_t shift = client_shift;

1043

TosaMulAttribute attr(shift);

1044

1045

// Create tensors

1046

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1047

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1048

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1049

1050

// Create operator

1051

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MUL, tosa::Attribute::Attribute_MulAttribute, &attr,

1052

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1053

1054

// Create a tosa single-op basic block

1055

tosa::TosaSerializationBasicBlock block("mul", { op }, { input1, input2, output },

1056

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1057

1058

// Setup model

1059

TosaReference::ModelRunnerImpl runner;

1060

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1061

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1062

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1063

1064

// Execute

1065

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1066

1067

// Extract outputs

1068

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1069

1070

return tosa_status_valid;

1071

}

1072

1073

tosa_status_t tosa_run_pow(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

1074

{

1075

// Create operator attributes

1076

TosaNoneAttribute attr;

1077

1078

// Create tensors

1079

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1080

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1081

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1082

1083

// Create operator

1084

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_POW, tosa::Attribute::Attribute_NONE, &attr,

1085

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1086

1087

// Create a tosa single-op basic block

1088

tosa::TosaSerializationBasicBlock block("pow", { op }, { input1, input2, output },

1089

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1090

1091

// Setup model

1092

TosaReference::ModelRunnerImpl runner;

1093

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1094

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1095

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1096

1097

// Execute

1098

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1099

1100

// Extract outputs

1101

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1102

1103

return tosa_status_valid;

1104

}

1105

1106

tosa_status_t tosa_run_sub(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

1107

{

1108

// Create operator attributes

1109

TosaNoneAttribute attr;

1110

1111

// Create tensors

1112

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1113

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1114

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1115

1116

// Create operator

1117

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SUB, tosa::Attribute::Attribute_NONE, &attr,

1118

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1119

1120

// Create a tosa single-op basic block

1121

tosa::TosaSerializationBasicBlock block("sub", { op }, { input1, input2, output },

1122

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1123

1124

// Setup model

1125

TosaReference::ModelRunnerImpl runner;

1126

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1127

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1128

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1129

1130

// Execute

1131

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1132

1133

// Extract outputs

1134

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1135

1136

return tosa_status_valid;

1137

}

1138

1139

tosa_status_t tosa_run_table(tosa_tensor_t client_input,

1140

const int32_t client_table_len,

1141

const int16_t client_table[],

1142

tosa_tensor_t client_output)

1143

{

1144

// Create operator attributes

1145

const std::vector<int16_t> table(&client_table[0], &client_table[0] + client_table_len);

1146

TosaTableAttribute attr(table);

1147

1148

// Create tensors

1149

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1150

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1151

1152

// Create operator

1153

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TABLE, tosa::Attribute::Attribute_TableAttribute,

1154

&attr, { input->GetName() }, { output->GetName() });

1155

1156

// Create a tosa single-op basic block

1157

tosa::TosaSerializationBasicBlock block("table", { op }, { input, output }, { input->GetName() },

1158

{ output->GetName() });

1159

1160

// Setup model

1161

TosaReference::ModelRunnerImpl runner;

1162

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1163

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1164

1165

// Execute

1166

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1167

1168

// Extract outputs

1169

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1170

1171

return tosa_status_valid;

1172

}

1173

1174

tosa_status_t tosa_run_abs(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1175

{

1176

// Create operator attributes

1177

TosaNoneAttribute attr;

1178

1179

// Create tensors

1180

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1181

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1182

1183

// Create operator

1184

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ABS, tosa::Attribute::Attribute_NONE, &attr,

1185

{ input1->GetName() }, { output->GetName() });

1186

1187

// Create a tosa single-op basic block

1188

tosa::TosaSerializationBasicBlock block("abs", { op }, { input1, output }, { input1->GetName() },

1189

{ output->GetName() });

1190

1191

// Setup model

1192

TosaReference::ModelRunnerImpl runner;

1193

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1194

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1195

1196

// Execute

1197

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1198

1199

// Extract outputs

1200

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1201

1202

return tosa_status_valid;

1203

}

1204

1205

tosa_status_t tosa_run_bitwise_not(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1206

{

1207

// Create operator attributes

1208

TosaNoneAttribute attr;

1209

1210

// Create tensors

1211

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1212

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1213

1214

// Create operator

1215

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_NOT, tosa::Attribute::Attribute_NONE, &attr,

1216

{ input1->GetName() }, { output->GetName() });

1217

1218

// Create a tosa single-op basic block

1219

tosa::TosaSerializationBasicBlock block("bitwise_not", { op }, { input1, output }, { input1->GetName() },

1220

{ output->GetName() });

1221

1222

// Setup model

1223

TosaReference::ModelRunnerImpl runner;

1224

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1225

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1226

1227

// Execute

1228

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1229

1230

// Extract outputs

1231

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1232

1233

return tosa_status_valid;

1234

}

1235

1236

tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1237

{

1238

// Create operator attributes

1239

TosaNoneAttribute attr;

1240

1241

// Create tensors

1242

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1243

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1244

1245

// Create operator

1246

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CEIL, tosa::Attribute::Attribute_NONE, &attr,

1247

{ input1->GetName() }, { output->GetName() });

1248

1249

// Create a tosa single-op basic block

1250

tosa::TosaSerializationBasicBlock block("ceil", { op }, { input1, output }, { input1->GetName() },

1251

{ output->GetName() });

1252

1253

// Setup model

1254

TosaReference::ModelRunnerImpl runner;

1255

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1256

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1257

1258

// Execute

1259

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1260

1261

// Extract outputs

1262

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1263

1264

return tosa_status_valid;

1265

}

1266

1267

tosa_status_t tosa_run_clz(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1268

{

1269

// Create operator attributes

1270

TosaNoneAttribute attr;

1271

1272

// Create tensors

1273

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1274

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1275

1276

// Create operator

1277

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CLZ, tosa::Attribute::Attribute_NONE, &attr,

1278

{ input1->GetName() }, { output->GetName() });

1279

1280

// Create a tosa single-op basic block

1281

tosa::TosaSerializationBasicBlock block("clz", { op }, { input1, output }, { input1->GetName() },

1282

{ output->GetName() });

1283

1284

// Setup model

1285

TosaReference::ModelRunnerImpl runner;

1286

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1287

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1288

1289

// Execute

1290

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1291

1292

// Extract outputs

1293

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1294

1295

return tosa_status_valid;

1296

}

1297

1298

tosa_status_t tosa_run_exp(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1299

{

1300

// Create operator attributes

1301

TosaNoneAttribute attr;

1302

1303

// Create tensors

1304

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1305

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1306

1307

// Create operator

1308

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EXP, tosa::Attribute::Attribute_NONE, &attr,

1309

{ input1->GetName() }, { output->GetName() });

1310

1311

// Create a tosa single-op basic block

1312

tosa::TosaSerializationBasicBlock block("exp", { op }, { input1, output }, { input1->GetName() },

1313

{ output->GetName() });

1314

1315

// Setup model

1316

TosaReference::ModelRunnerImpl runner;

1317

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1318

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1319

1320

// Execute

1321

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1322

1323

// Extract outputs

1324

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1325

1326

return tosa_status_valid;

1327

}

1328

1329

tosa_status_t tosa_run_floor(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1330

{

1331

// Create operator attributes

1332

TosaNoneAttribute attr;

1333

1334

// Create tensors

1335

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1336

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1337

1338

// Create operator

1339

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FLOOR, tosa::Attribute::Attribute_NONE, &attr,

1340

{ input1->GetName() }, { output->GetName() });

1341

1342

// Create a tosa single-op basic block

1343

tosa::TosaSerializationBasicBlock block("floor", { op }, { input1, output }, { input1->GetName() },

1344

{ output->GetName() });

1345

1346

// Setup model

1347

TosaReference::ModelRunnerImpl runner;

1348

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1349

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1350

1351

// Execute

1352

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1353

1354

// Extract outputs

1355

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1356

1357

return tosa_status_valid;

1358

}

1359

1360

tosa_status_t tosa_run_log(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1361

{

1362

// Create operator attributes

1363

TosaNoneAttribute attr;

1364

1365

// Create tensors

1366

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1367

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1368

1369

// Create operator

1370

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOG, tosa::Attribute::Attribute_NONE, &attr,

1371

{ input1->GetName() }, { output->GetName() });

1372

1373

// Create a tosa single-op basic block

1374

tosa::TosaSerializationBasicBlock block("log", { op }, { input1, output }, { input1->GetName() },

1375

{ output->GetName() });

1376

1377

// Setup model

1378

TosaReference::ModelRunnerImpl runner;

1379

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1380

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1381

1382

// Execute

1383

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1384

1385

// Extract outputs

1386

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1387

1388

return tosa_status_valid;

1389

}

1390

1391

tosa_status_t tosa_run_logical_not(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1392

{

1393

// Create operator attributes

1394

TosaNoneAttribute attr;

1395

1396

// Create tensors

1397

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1398

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1399

1400

// Create operator

1401

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_NOT, tosa::Attribute::Attribute_NONE, &attr,

1402

{ input1->GetName() }, { output->GetName() });

1403

1404

// Create a tosa single-op basic block

1405

tosa::TosaSerializationBasicBlock block("logical_not", { op }, { input1, output }, { input1->GetName() },

1406

{ output->GetName() });

1407

1408

// Setup model

1409

TosaReference::ModelRunnerImpl runner;

1410

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1411

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1412

1413

// Execute

1414

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1415

1416

// Extract outputs

1417

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1418

1419

return tosa_status_valid;

1420

}

1421

1422

tosa_status_t tosa_run_negate(tosa_tensor_t client_input1,

1423

const int32_t client_input1_zp,

1424

const int32_t client_output_zp,

1425

tosa_tensor_t client_output)

1426

{

1427

// Create operator attributes

1428

const int32_t input1_zp = client_input1_zp;

1429

const int32_t output_zp = client_output_zp;

1430

TosaNegateAttribute attr(input1_zp, output_zp);

1431

1432

// Create tensors

1433

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1434

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1435

1436

// Create operator

1437

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_NEGATE, tosa::Attribute::Attribute_NegateAttribute,

1438

&attr, { input1->GetName() }, { output->GetName() });

1439

1440

// Create a tosa single-op basic block

1441

tosa::TosaSerializationBasicBlock block("negate", { op }, { input1, output }, { input1->GetName() },

1442

{ output->GetName() });

1443

1444

// Setup model

1445

TosaReference::ModelRunnerImpl runner;

1446

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1447

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1448

1449

// Execute

1450

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1451

1452

// Extract outputs

1453

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1454

1455

return tosa_status_valid;

1456

}

1457

1458

tosa_status_t tosa_run_reciprocal(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1459

{

1460

// Create operator attributes

1461

TosaNoneAttribute attr;

1462

1463

// Create tensors

1464

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1465

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1466

1467

// Create operator

1468

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RECIPROCAL, tosa::Attribute::Attribute_NONE, &attr,

1469

{ input1->GetName() }, { output->GetName() });

1470

1471

// Create a tosa single-op basic block

1472

tosa::TosaSerializationBasicBlock block("reciprocal", { op }, { input1, output }, { input1->GetName() },

1473

{ output->GetName() });

1474

1475

// Setup model

1476

TosaReference::ModelRunnerImpl runner;

1477

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1478

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1479

1480

// Execute

1481

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1482

1483

// Extract outputs

1484

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1485

1486

return tosa_status_valid;

1487

}

1488

1489

tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1, tosa_tensor_t client_output)

1490

{

1491

// Create operator attributes

1492

TosaNoneAttribute attr;

1493

1494

// Create tensors

1495

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1496

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1497

1498

// Create operator

1499

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RSQRT, tosa::Attribute::Attribute_NONE, &attr,

1500

{ input1->GetName() }, { output->GetName() });

1501

1502

// Create a tosa single-op basic block

1503

tosa::TosaSerializationBasicBlock block("rsqrt", { op }, { input1, output }, { input1->GetName() },

1504

{ output->GetName() });

1505

1506

// Setup model

1507

TosaReference::ModelRunnerImpl runner;

1508

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1509

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1510

1511

// Execute

1512

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1513

1514

// Extract outputs

1515

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1516

1517

return tosa_status_valid;

1518

}

1519

1520

tosa_status_t tosa_run_select(tosa_tensor_t client_input1,

1521

tosa_tensor_t client_input2,

1522

tosa_tensor_t client_input3,

1523

tosa_tensor_t client_output)

1524

{

1525

// Create operator attributes

1526

TosaNoneAttribute attr;

1527

1528

// Create tensors

1529

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1530

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1531

tosa::TosaSerializationTensor* input3 = translate_client_tensor(client_input3, "input3");

1532

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1533

1534

// Create operator

1535

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SELECT, tosa::Attribute::Attribute_NONE, &attr,

1536

{ input1->GetName(), input2->GetName(), input3->GetName() },

1537

{ output->GetName() });

1538

1539

// Create a tosa single-op basic block

1540

tosa::TosaSerializationBasicBlock block("select", { op }, { input1, input2, input3, output },

1541

{ input1->GetName(), input2->GetName(), input3->GetName() },

1542

{ output->GetName() });

1543

1544

// Setup model

1545

TosaReference::ModelRunnerImpl runner;

1546

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1547

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1548

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1549

TOSA_RETURN_ON_ERROR(runner.setInput(input3->GetName(), client_input3.data, client_input3.size));

1550

1551

// Execute

1552

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1553

1554

// Extract outputs

1555

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1556

1557

return tosa_status_valid;

1558

}

1559

1560

tosa_status_t tosa_run_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

1561

{

1562

// Create operator attributes

1563

TosaNoneAttribute attr;

1564

1565

// Create tensors

1566

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1567

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1568

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1569

1570

// Create operator

1571

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EQUAL, tosa::Attribute::Attribute_NONE, &attr,

1572

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1573

1574

// Create a tosa single-op basic block

1575

tosa::TosaSerializationBasicBlock block("equal", { op }, { input1, input2, output },

1576

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1577

1578

// Setup model

1579

TosaReference::ModelRunnerImpl runner;

1580

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1581

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1582

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1583

1584

// Execute

1585

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1586

1587

// Extract outputs

1588

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1589

1590

return tosa_status_valid;

}

tosa_status_t

tosa_run_greater(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

1595

{

1596

// Create operator attributes

1597

TosaNoneAttribute attr;

1598

1599

// Create tensors

1600

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1601

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1602

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1603

1604

// Create operator

1605

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER, tosa::Attribute::Attribute_NONE, &attr,

1606

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1607

1608

// Create a tosa single-op basic block

1609

tosa::TosaSerializationBasicBlock block("greater", { op }, { input1, input2, output },

1610

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1611

1612

// Setup model

1613

TosaReference::ModelRunnerImpl runner;

1614

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1615

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1616

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1617

1618

// Execute

1619

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1620

1621

// Extract outputs

1622

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1623

1624

return tosa_status_valid;

}

tosa_status_t

tosa_run_greater_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)

1629

{

1630

// Create operator attributes

1631

TosaNoneAttribute attr;

1632

1633

// Create tensors

1634

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1635

tosa::TosaSerializationTensor* input2 = translate_client_tensor(client_input2, "input2");

1636

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

// Create operator

auto op =

new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER_EQUAL, tosa::Attribute::Attribute_NONE, &attr,

1641

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1642

1643

// Create a tosa single-op basic block

1644

tosa::TosaSerializationBasicBlock block("greater_equal", { op }, { input1, input2, output },

1645

{ input1->GetName(), input2->GetName() }, { output->GetName() });

1646

1647

// Setup model

1648

TosaReference::ModelRunnerImpl runner;

1649

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1650

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1651

TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));

1652

1653

// Execute

1654

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1655

1656

// Extract outputs

1657

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1658

1659

return tosa_status_valid;

}

tosa_status_t

tosa_run_reduce_all(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

1664

{

1665

// Create operator attributes

1666

TosaNoneAttribute attr;

1667

1668

// Create tensors

1669

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1670

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1671

1672

// Create operator

1673

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ALL, tosa::Attribute::Attribute_NONE, &attr,

1674

{ input->GetName() }, { output->GetName() });

1675

1676

// Create a tosa single-op basic block

1677

tosa::TosaSerializationBasicBlock block("reduce_all", { op }, { input, output }, { input->GetName() },

1678

{ output->GetName() });

1679

1680

// Setup model

1681

TosaReference::ModelRunnerImpl runner;

1682

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1683

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1684

1685

// Execute

1686

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1687

1688

// Extract outputs

1689

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1690

1691

return tosa_status_valid;

}

tosa_status_t

tosa_run_reduce_any(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

1696

{

1697

// Create operator attributes

1698

TosaNoneAttribute attr;

1699

1700

// Create tensors

1701

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1702

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1703

1704

// Create operator

1705

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ANY, tosa::Attribute::Attribute_NONE, &attr,

1706

{ input->GetName() }, { output->GetName() });

1707

1708

// Create a tosa single-op basic block

1709

tosa::TosaSerializationBasicBlock block("reduce_any", { op }, { input, output }, { input->GetName() },

1710

{ output->GetName() });

1711

1712

// Setup model

1713

TosaReference::ModelRunnerImpl runner;

1714

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1715

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1716

1717

// Execute

1718

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1719

1720

// Extract outputs

1721

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1722

1723

return tosa_status_valid;

}

tosa_status_t

tosa_run_reduce_max(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

1728

{

1729

// Create operator attributes

1730

TosaNoneAttribute attr;

1731

1732

// Create tensors

1733

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1734

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1735

1736

// Create operator

1737

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MAX, tosa::Attribute::Attribute_NONE, &attr,

1738

{ input->GetName() }, { output->GetName() });

1739

1740

// Create a tosa single-op basic block

1741

tosa::TosaSerializationBasicBlock block("reduce_max", { op }, { input, output }, { input->GetName() },

1742

{ output->GetName() });

1743

1744

// Setup model

1745

TosaReference::ModelRunnerImpl runner;

1746

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1747

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1748

1749

// Execute

1750

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1751

1752

// Extract outputs

1753

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1754

1755

return tosa_status_valid;

}

tosa_status_t

tosa_run_reduce_min(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

1760

{

1761

// Create operator attributes

1762

TosaNoneAttribute attr;

1763

1764

// Create tensors

1765

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1766

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1767

1768

// Create operator

1769

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MIN, tosa::Attribute::Attribute_NONE, &attr,

1770

{ input->GetName() }, { output->GetName() });

1771

1772

// Create a tosa single-op basic block

1773

tosa::TosaSerializationBasicBlock block("reduce_min", { op }, { input, output }, { input->GetName() },

1774

{ output->GetName() });

1775

1776

// Setup model

1777

TosaReference::ModelRunnerImpl runner;

1778

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1779

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1780

1781

// Execute

1782

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1783

1784

// Extract outputs

1785

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1786

1787

return tosa_status_valid;

}

tosa_status_t

tosa_run_reduce_product(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

1792

{

1793

// Create operator attributes

1794

TosaNoneAttribute attr;

1795

1796

// Create tensors

1797

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1798

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1799

1800

// Create operator

1801

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_PRODUCT, tosa::Attribute::Attribute_NONE,

1802

&attr, { input->GetName() }, { output->GetName() });

1803

1804

// Create a tosa single-op basic block

1805

tosa::TosaSerializationBasicBlock block("reduce_product", { op }, { input, output }, { input->GetName() },

1806

{ output->GetName() });

1807

1808

// Setup model

1809

TosaReference::ModelRunnerImpl runner;

1810

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1811

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1812

1813

// Execute

1814

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1815

1816

// Extract outputs

1817

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1818

1819

return tosa_status_valid;

}

tosa_status_t

tosa_run_reduce_sum(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

1824

{

1825

// Create operator attributes

1826

TosaNoneAttribute attr;

1827

1828

// Create tensors

1829

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1830

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1831

1832

// Create operator

1833

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_SUM, tosa::Attribute::Attribute_NONE, &attr,

1834

{ input->GetName() }, { output->GetName() });

1835

1836

// Create a tosa single-op basic block

1837

tosa::TosaSerializationBasicBlock block("reduce_sum", { op }, { input, output }, { input->GetName() },

1838

{ output->GetName() });

1839

1840

// Setup model

1841

TosaReference::ModelRunnerImpl runner;

1842

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1843

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1844

1845

// Execute

1846

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1847

1848

// Extract outputs

1849

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1850

1851

return tosa_status_valid;

1852

}

1853

1854

tosa_status_t tosa_run_concat(tosa_tensor_t client_input1, const int32_t client_axis, tosa_tensor_t client_output)

1855

{

1856

// Create operator attributes

1857

TosaNoneAttribute attr;

1858

1859

// Create tensors

1860

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1861

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1862

1863

// Create operator

1864

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CONCAT, tosa::Attribute::Attribute_NONE, &attr,

1865

{ input1->GetName() }, { output->GetName() });

1866

1867

// Create a tosa single-op basic block

1868

tosa::TosaSerializationBasicBlock block("concat", { op }, { input1, output }, { input1->GetName() },

1869

{ output->GetName() });

1870

1871

// Setup model

1872

TosaReference::ModelRunnerImpl runner;

1873

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1874

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1875

1876

// Execute

1877

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1878

1879

// Extract outputs

1880

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1881

1882

return tosa_status_valid;

1883

}

1884

1885

tosa_status_t tosa_run_pad(tosa_tensor_t client_input1,

1886

const int32_t client_padding_len,

1887

const int32_t client_padding[],

1888

const int32_t client_pad_const_int,

1889

const float client_pad_const_fp,

1890

tosa_tensor_t client_output)

1891

{

1892

// Create operator attributes

1893

const std::vector<int32_t> padding(&client_padding[0], &client_padding[0] + client_padding_len);

1894

const int32_t pad_const_int = client_pad_const_int;

1895

const float pad_const_fp = client_pad_const_fp;

1896

TosaPadAttribute attr(padding, pad_const_int, pad_const_fp);

1897

1898

// Create tensors

1899

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1900

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1901

1902

// Create operator

1903

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_PAD, tosa::Attribute::Attribute_PadAttribute, &attr,

1904

{ input1->GetName() }, { output->GetName() });

1905

1906

// Create a tosa single-op basic block

1907

tosa::TosaSerializationBasicBlock block("pad", { op }, { input1, output }, { input1->GetName() },

1908

{ output->GetName() });

1909

1910

// Setup model

1911

TosaReference::ModelRunnerImpl runner;

1912

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1913

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1914

1915

// Execute

1916

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1917

1918

// Extract outputs

1919

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1920

1921

return tosa_status_valid;

1922

}

1923

1924

tosa_status_t tosa_run_reshape(tosa_tensor_t client_input1,

1925

const int32_t client_new_shape_len,

1926

const int32_t client_new_shape[],

1927

tosa_tensor_t client_output)

1928

{

1929

// Create operator attributes

1930

const std::vector<int32_t> new_shape(&client_new_shape[0], &client_new_shape[0] + client_new_shape_len);

1931

TosaReshapeAttribute attr(new_shape);

1932

1933

// Create tensors

1934

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

1935

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1936

1937

// Create operator

1938

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESHAPE, tosa::Attribute::Attribute_ReshapeAttribute,

1939

&attr, { input1->GetName() }, { output->GetName() });

1940

1941

// Create a tosa single-op basic block

1942

tosa::TosaSerializationBasicBlock block("reshape", { op }, { input1, output }, { input1->GetName() },

1943

{ output->GetName() });

1944

1945

// Setup model

1946

TosaReference::ModelRunnerImpl runner;

1947

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1948

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

1949

1950

// Execute

1951

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1952

1953

// Extract outputs

1954

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1955

1956

return tosa_status_valid;

1957

}

1958

1959

tosa_status_t tosa_run_reverse(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)

1960

{

1961

// Create operator attributes

1962

TosaNoneAttribute attr;

1963

1964

// Create tensors

1965

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

1966

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

1967

1968

// Create operator

1969

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_REVERSE, tosa::Attribute::Attribute_NONE, &attr,

1970

{ input->GetName() }, { output->GetName() });

1971

1972

// Create a tosa single-op basic block

1973

tosa::TosaSerializationBasicBlock block("reverse", { op }, { input, output }, { input->GetName() },

1974

{ output->GetName() });

1975

1976

// Setup model

1977

TosaReference::ModelRunnerImpl runner;

1978

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

1979

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

1980

1981

// Execute

1982

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

1983

1984

// Extract outputs

1985

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

1986

1987

return tosa_status_valid;

1988

}

1989

1990

tosa_status_t tosa_run_slice(tosa_tensor_t client_input1,

1991

const int32_t client_start_len,

1992

const int32_t client_start[],

1993

const int32_t client_size_len,

1994

const int32_t client_size[],

1995

tosa_tensor_t client_output)

1996

{

1997

// Create operator attributes

1998

const std::vector<int32_t> start(&client_start[0], &client_start[0] + client_start_len);

1999

const std::vector<int32_t> size(&client_size[0], &client_size[0] + client_size_len);

2000

TosaSliceAttribute attr(start, size);

2001

2002

// Create tensors

2003

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

2004

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

2005

2006

// Create operator

2007

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SLICE, tosa::Attribute::Attribute_SliceAttribute,

2008

&attr, { input1->GetName() }, { output->GetName() });

2009

2010

// Create a tosa single-op basic block

2011

tosa::TosaSerializationBasicBlock block("slice", { op }, { input1, output }, { input1->GetName() },

2012

{ output->GetName() });

2013

2014

// Setup model

2015

TosaReference::ModelRunnerImpl runner;

2016

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2017

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

2018

2019

// Execute

2020

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2021

2022

// Extract outputs

2023

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2024

2025

return tosa_status_valid;

2026

}

2027

2028

tosa_status_t tosa_run_tile(tosa_tensor_t client_input1,

2029

const int32_t client_multiplies_len,

2030

const int32_t client_multiplies[],

2031

const int32_t client_multiples_len,

2032

const int32_t client_multiples[],

2033

tosa_tensor_t client_output)

2034

{

2035

// Create operator attributes

2036

const std::vector<int32_t> multiples(&client_multiples[0], &client_multiples[0] + client_multiples_len);

2037

TosaTileAttribute attr(multiples);

2038

2039

// Create tensors

2040

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

2041

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

2042

2043

// Create operator

2044

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TILE, tosa::Attribute::Attribute_TileAttribute,

2045

&attr, { input1->GetName() }, { output->GetName() });

2046

2047

// Create a tosa single-op basic block

2048

tosa::TosaSerializationBasicBlock block("tile", { op }, { input1, output }, { input1->GetName() },

2049

{ output->GetName() });

2050

2051

// Setup model

2052

TosaReference::ModelRunnerImpl runner;

2053

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2054

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

2055

2056

// Execute

2057

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2058

2059

// Extract outputs

2060

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2061

2062

return tosa_status_valid;

2063

}

2064

2065

tosa_status_t tosa_run_transpose(tosa_tensor_t client_input1,

2066

const int32_t client_perms_len,

2067

const int32_t client_perms[],

2068

tosa_tensor_t client_output)

2069

{

2070

// Create operator attributes

2071

const std::vector<int32_t> perms(&client_perms[0], &client_perms[0] + client_perms_len);

2072

TosaTransposeAttribute attr(perms);

2073

2074

// Create tensors

2075

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

2076

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

// Create operator

auto op =

new tosa::TosaSerializationOperator(tosa::Op::Op_TRANSPOSE, tosa::Attribute::Attribute_TransposeAttribute,

2081

&attr, { input1->GetName() }, { output->GetName() });

2082

2083

// Create a tosa single-op basic block

2084

tosa::TosaSerializationBasicBlock block("transpose", { op }, { input1, output }, { input1->GetName() },

2085

{ output->GetName() });

2086

2087

// Setup model

2088

TosaReference::ModelRunnerImpl runner;

2089

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2090

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

2091

2092

// Execute

2093

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2094

2095

// Extract outputs

2096

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2097

2098

return tosa_status_valid;

}

tosa_status_t

tosa_run_gather(tosa_tensor_t client_values, tosa_tensor_t client_indices, tosa_tensor_t client_output)

2103

{

2104

// Create operator attributes

2105

TosaNoneAttribute attr;

2106

2107

// Create tensors

2108

tosa::TosaSerializationTensor* values = translate_client_tensor(client_values, "values");

2109

tosa::TosaSerializationTensor* indices = translate_client_tensor(client_indices, "indices");

2110

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

2111

2112

// Create operator

2113

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GATHER, tosa::Attribute::Attribute_NONE, &attr,

2114

{ values->GetName(), indices->GetName() }, { output->GetName() });

2115

2116

// Create a tosa single-op basic block

2117

tosa::TosaSerializationBasicBlock block("gather", { op }, { values, indices, output },

2118

{ values->GetName(), indices->GetName() }, { output->GetName() });

2119

2120

// Setup model

2121

TosaReference::ModelRunnerImpl runner;

2122

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2123

TOSA_RETURN_ON_ERROR(runner.setInput(values->GetName(), client_values.data, client_values.size));

2124

TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));

2125

2126

// Execute

2127

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2128

2129

// Extract outputs

2130

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2131

2132

return tosa_status_valid;

2133

}

2134

2135

tosa_status_t tosa_run_scatter(tosa_tensor_t client_values_in,

2136

tosa_tensor_t client_indices,

2137

tosa_tensor_t client_input,

2138

tosa_tensor_t client_values_out)

2139

{

2140

// Create operator attributes

2141

TosaNoneAttribute attr;

2142

2143

// Create tensors

2144

tosa::TosaSerializationTensor* values_in = translate_client_tensor(client_values_in, "values_in");

2145

tosa::TosaSerializationTensor* indices = translate_client_tensor(client_indices, "indices");

2146

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

2147

tosa::TosaSerializationTensor* values_out = translate_client_tensor(client_values_out, "values_out");

2148

2149

// Create operator

2150

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SCATTER, tosa::Attribute::Attribute_NONE, &attr,

2151

{ values_in->GetName(), indices->GetName(), input->GetName() },

2152

{ values_out->GetName() });

2153

2154

// Create a tosa single-op basic block

2155

tosa::TosaSerializationBasicBlock block("scatter", { op }, { values_in, indices, input, values_out },

2156

{ values_in->GetName(), indices->GetName(), input->GetName() },

2157

{ values_out->GetName() });

2158

2159

// Setup model

2160

TosaReference::ModelRunnerImpl runner;

2161

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2162

TOSA_RETURN_ON_ERROR(runner.setInput(values_in->GetName(), client_values_in.data, client_values_in.size));

2163

TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));

2164

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

2165

2166

// Execute

2167

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2168

2169

// Extract outputs

2170

TOSA_RETURN_ON_ERROR(runner.getOutput(values_out->GetName(), client_values_out.data, client_values_out.size));

2171

2172

return tosa_status_valid;

2173

}

2174

2175

tosa_status_t tosa_run_resize(tosa_tensor_t client_input,

2176

const int16_t client_scale[4],

2177

const int16_t client_offset[2],

2178

const int16_t client_border[2],

2179

const tosa_mode_t client_mode,

2180

tosa_tensor_t client_output)

2181

{

2182

// Create operator attributes

2183

const std::vector<int16_t> scale(&client_scale[0], &client_scale[4]);

2184

const std::vector<int16_t> offset(&client_offset[0], &client_offset[2]);

2185

const std::vector<int16_t> border(&client_border[0], &client_border[2]);

2186

const ResizeMode mode = translate_client_tosa_mode(client_mode);

2187

TosaResizeAttribute attr(scale, offset, border, mode);

2188

2189

// Create tensors

2190

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

2191

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

2192

2193

// Create operator

2194

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESIZE, tosa::Attribute::Attribute_ResizeAttribute,

2195

&attr, { input->GetName() }, { output->GetName() });

2196

2197

// Create a tosa single-op basic block

2198

tosa::TosaSerializationBasicBlock block("resize", { op }, { input, output }, { input->GetName() },

2199

{ output->GetName() });

2200

2201

// Setup model

2202

TosaReference::ModelRunnerImpl runner;

2203

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2204

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

2205

2206

// Execute

2207

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2208

2209

// Extract outputs

2210

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2211

2212

return tosa_status_valid;

2213

}

2214

2215

tosa_status_t tosa_run_cast(tosa_tensor_t client_input, tosa_tensor_t client_output)

2216

{

2217

// Create operator attributes

2218

TosaNoneAttribute attr;

2219

2220

// Create tensors

2221

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

2222

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

2223

2224

// Create operator

2225

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CAST, tosa::Attribute::Attribute_NONE, &attr,

2226

{ input->GetName() }, { output->GetName() });

2227

2228

// Create a tosa single-op basic block

2229

tosa::TosaSerializationBasicBlock block("cast", { op }, { input, output }, { input->GetName() },

2230

{ output->GetName() });

2231

2232

// Setup model

2233

TosaReference::ModelRunnerImpl runner;

2234

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2235

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

2236

2237

// Execute

2238

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2239

2240

// Extract outputs

2241

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2242

2243

return tosa_status_valid;

2244

}

2245

2246

tosa_status_t tosa_run_rescale(tosa_tensor_t client_input,

2247

tosa_tensor_t client_output,

2248

const int32_t client_input_zp,

2249

const int32_t client_output_zp,

2250

const int32_t client_multiplier_len,

2251

const int32_t client_multiplier[],

2252

const int32_t client_shift_len,

2253

const uint8_t client_shift[],

2254

const bool client_scale32,

2255

const bool client_double_round,

2256

const bool client_per_channel)

2257

{

2258

// Create operator attributes

2259

const int32_t input_zp = client_input_zp;

2260

const int32_t output_zp = client_output_zp;

2261

const std::vector<int32_t> multiplier(&client_multiplier[0], &client_multiplier[0] + client_multiplier_len);

2262

const std::vector<int32_t> shift(&client_shift[0], &client_shift[0] + client_shift_len);

2263

const bool scale32 = client_scale32;

2264

const bool double_round = client_double_round;

2265

const bool per_channel = client_per_channel;

2266

TosaRescaleAttribute attr(input_zp, output_zp, multiplier, shift, scale32, double_round, per_channel);

2267

2268

// Create tensors

2269

tosa::TosaSerializationTensor* input = translate_client_tensor(client_input, "input");

2270

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

2271

2272

// Create operator

2273

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RESCALE, tosa::Attribute::Attribute_RescaleAttribute,

2274

&attr, { input->GetName() }, { output->GetName() });

2275

2276

// Create a tosa single-op basic block

2277

tosa::TosaSerializationBasicBlock block("rescale", { op }, { input, output }, { input->GetName() },

2278

{ output->GetName() });

2279

2280

// Setup model

2281

TosaReference::ModelRunnerImpl runner;

2282

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2283

TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));

2284

2285

// Execute

2286

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2287

2288

// Extract outputs

2289

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2290

2291

return tosa_status_valid;

2292

}

2293

2294

tosa_status_t tosa_run_identity(tosa_tensor_t client_input1, tosa_tensor_t client_output)

2295

{

2296

// Create operator attributes

2297

TosaNoneAttribute attr;

2298

2299

// Create tensors

2300

tosa::TosaSerializationTensor* input1 = translate_client_tensor(client_input1, "input1");

2301

tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");

2302

2303

// Create operator

2304

auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_IDENTITY, tosa::Attribute::Attribute_NONE, &attr,

2305

{ input1->GetName() }, { output->GetName() });

2306

2307

// Create a tosa single-op basic block

2308

tosa::TosaSerializationBasicBlock block("identity", { op }, { input1, output }, { input1->GetName() },

2309

{ output->GetName() });

2310

2311

// Setup model

2312

TosaReference::ModelRunnerImpl runner;

2313

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));

2314

TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));

2315

2316

// Execute

2317

TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());

2318

2319

// Extract outputs

2320

TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));

2321

2322

return tosa_status_valid;

2323

}

2324

2325

} // extern "C"