Blame - src/core/NEON/kernels/NEElementwiseOperationKernel.cpp - ml/ComputeLibrary

const auto a = elementwise_comp_op_broadcast<op, InputScalarType, InputVectorType, uint16x8_t>(wrapper::vloadq((non_broadcast_input_ptr + x)), broadcast_value, reorder);

424

wrapper::vstore(output_ptr + x, wrapper::vmovn(a));

425

}

return x;

}

template <ComparisonOperation op, typename InputScalarType, typename InputVectorType>

430

inline int elementwise_comp_op_broadcast_32_loop(int window_start_x, int window_end_x, int window_step_x,

431

const InputScalarType *non_broadcast_input_ptr, const InputScalarType &broadcast_value, uint8_t *output_ptr, const bool reorder)

432

{

433

int x = window_start_x;

434

for(; x <= (window_end_x - window_step_x); x += window_step_x)

435

{

436

const auto a = elementwise_comp_op_broadcast<op, InputScalarType, InputVectorType, uint32x4_t>(wrapper::vloadq(non_broadcast_input_ptr + x), broadcast_value, reorder);

437

const auto b = elementwise_comp_op_broadcast<op, InputScalarType, InputVectorType, uint32x4_t>(wrapper::vloadq(non_broadcast_input_ptr + x + 4), broadcast_value, reorder);

438

wrapper::vstore(output_ptr + x, wrapper::vmovn(wrapper::vcombine(wrapper::vmovn(a), wrapper::vmovn(b))));

439

}

440

if(x <= window_end_x - 4)

441

{

442

const auto a = elementwise_comp_op_broadcast<op, InputScalarType, InputVectorType, uint32x4_t>(wrapper::vloadq((non_broadcast_input_ptr + x)), broadcast_value, reorder);

443

for(int i = 0; i < 4; i++)

444

{

445

*(output_ptr + x + i) = wrapper::vgetlane(a, i);

}

x = +4;

}

return x;

}

template <ComparisonOperation op>

453

inline int elementwise_comp_op_quantized_broadcast_loop(int window_start_x, int window_end_x, int window_step_x,

454

const uint8_t *non_broadcast_input_ptr, float32x4x4_t broadcast_vector, uint8_t *output_ptr,

455

int32x4_t voffset_non_broadcast, float32x4_t vscale_non_broadcast,

456

float32x4_t voffseto, float32x4_t invvscaleo, bool reorder)

457

{

458

ARM_COMPUTE_UNUSED(voffseto, invvscaleo);

459

int x = window_start_x;

460

for(; x <= (window_end_x - window_step_x); x += window_step_x)

461

{

462

const float32x4x4_t af = load_quantized(non_broadcast_input_ptr + x, voffset_non_broadcast, vscale_non_broadcast);

463

const uint32x4x4_t rf = elementwise_comp_op<op>(reorder ? broadcast_vector : af, reorder ? af : broadcast_vector);

464

store_quantized(output_ptr + x, rf);

}

return x;

}

template <typename InputScalarType, typename OutputScalarType, typename InputVectorType>

470

void elementwise_op(const ITensor *in1, const ITensor *in2, ITensor *out, const Window &window,

471

OutputScalarType (*scalar_func)(const InputScalarType &, const InputScalarType &),

472

int (*broadcast_func)(int, int, int, const InputScalarType *, const InputScalarType &, OutputScalarType *, const bool),

473

int (*neon_func)(int, int, int, const InputScalarType *, const InputScalarType *, OutputScalarType *))

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

474

{

475

// Create input windows

476

Window input1_win = window.broadcast_if_dimension_le_one(in1->info()->tensor_shape());

477

Window input2_win = window.broadcast_if_dimension_le_one(in2->info()->tensor_shape());

478

479

// Clear X Dimension on execution window as we handle manually

480

Window win = window;

481

win.set(Window::DimX, Window::Dimension(0, 1, 1));

482

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

483

const int window_step_x = std::min(16 / static_cast<int32_t>(sizeof(OutputScalarType)), 8);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

484

const auto window_start_x = static_cast<int>(window.x().start());

485

const auto window_end_x = static_cast<int>(window.x().end());

486

const bool is_broadcast_across_x = (input1_win.x().step() == 0) || (input2_win.x().step() == 0);

487

488

if(is_broadcast_across_x)

489

{

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

490

const bool is_broadcast_input_2 = input2_win.x().step() == 0;

491

Window broadcast_win = is_broadcast_input_2 ? input2_win : input1_win;

492

Window non_broadcast_win = !is_broadcast_input_2 ? input2_win : input1_win;

493

const ITensor *broadcast_tensor = is_broadcast_input_2 ? in2 : in1;

494

const ITensor *non_broadcast_tensor = !is_broadcast_input_2 ? in2 : in1;

495

496

// Clear X Dimension on execution window as we handle manually

497

non_broadcast_win.set(Window::DimX, Window::Dimension(0, 1, 1));

498

499

Iterator broadcast_input(broadcast_tensor, broadcast_win);

500

Iterator non_broadcast_input(non_broadcast_tensor, non_broadcast_win);

501

Iterator output(out, win);

502

503

execute_window_loop(win, [&](const Coordinates & id)

504

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

505

auto output_ptr = reinterpret_cast<OutputScalarType *>(output.ptr());

506

const auto non_broadcast_input_ptr = reinterpret_cast<const InputScalarType *>(non_broadcast_input.ptr());

507

const InputScalarType broadcast_value = *reinterpret_cast<const InputScalarType *>(broadcast_input.ptr());

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

508

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

509

int x = (*broadcast_func)(window_start_x, window_end_x, window_step_x, non_broadcast_input_ptr, broadcast_value, output_ptr, !is_broadcast_input_2);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

510

for(; x < window_end_x; ++x)

511

{

512

const auto a = *(non_broadcast_input_ptr + x);

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

513

*(output_ptr + x) = (*scalar_func)(!is_broadcast_input_2 ? broadcast_value : a, !is_broadcast_input_2 ? a : broadcast_value);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

514

}

515

},

516

broadcast_input, non_broadcast_input, output);

}

else

{

// Clear X Dimension on execution window as we handle manually

521

input1_win.set(Window::DimX, Window::Dimension(0, 1, 1));

522

input2_win.set(Window::DimX, Window::Dimension(0, 1, 1));

523

524

Iterator input1(in1, input1_win);

525

Iterator input2(in2, input2_win);

526

Iterator output(out, win);

527

528

execute_window_loop(win, [&](const Coordinates & id)

529

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

530

auto output_ptr = reinterpret_cast<OutputScalarType *>(output.ptr());

531

const auto input1_ptr = reinterpret_cast<const InputScalarType *>(input1.ptr());

532

const auto input2_ptr = reinterpret_cast<const InputScalarType *>(input2.ptr());

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

533

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

534

int x = (*neon_func)(window_start_x, window_end_x, window_step_x, input1_ptr, input2_ptr, output_ptr);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

535

for(; x < window_end_x; ++x)

536

{

537

const auto a = *(input1_ptr + x);

538

const auto b = *(input2_ptr + x);

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

539

*(output_ptr + x) = (*scalar_func)(a, b);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

540

}

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

541

},

542

input1, input2, output);

}

}

George Wort

2018-12-12 17:39:58 +0000

[diff] [blame]

546

void elementwise_op_quantized(const ITensor *in1, const ITensor *in2, ITensor *out, const Window &window,

547

uint8_t (*scalar_func)(const float &, const float &, QuantizationInfo),

548

int (*broadcast_func)(int, int, int, const uint8_t *, float32x4x4_t, uint8_t *, int32x4_t, float32x4_t,

549

float32x4_t, float32x4_t, const bool),

550

int (*neon_func)(int, int, int, const uint8_t *, const uint8_t *, uint8_t *,

551

int32x4_t, int32x4_t, float32x4_t, float32x4_t,

552

float32x4_t, float32x4_t))

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

553

{

554

// Create input windows

555

Window input1_win = window.broadcast_if_dimension_le_one(in1->info()->tensor_shape());

556

Window input2_win = window.broadcast_if_dimension_le_one(in2->info()->tensor_shape());

557

558

// Clear X Dimension on execution window as we handle manually

559

Window win = window;

560

win.set(Window::DimX, Window::Dimension(0, 1, 1));

561

562

const int window_step_x = 16;

563

const auto window_start_x = static_cast<int>(window.x().start());

564

const auto window_end_x = static_cast<int>(window.x().end());

565

const bool is_broadcast_across_x = (input1_win.x().step() == 0) || (input2_win.x().step() == 0);

566

567

const float output_scale = out->info()->quantization_info().scale;

568

const int output_offset = out->info()->quantization_info().offset;

569

570

// Output quantization info (add 0.5 to round toward the nearest integer - 0.5 rounds away from zero)

571

const float32x4_t voffseto = vdupq_n_f32(output_offset + 0.5f);

572

const float32x4_t invvscaleo = vdupq_n_f32(1.f / output_scale);

573

574

if(is_broadcast_across_x)

575

{

576

// Select the broadcast input on the X axis

577

const bool is_broadcast_input_2 = input2_win.x().step() == 0;

578

Window broadcast_win = is_broadcast_input_2 ? input2_win : input1_win;

579

Window non_broadcast_win = !is_broadcast_input_2 ? input2_win : input1_win;

580

const ITensor *broadcast_tensor = is_broadcast_input_2 ? in2 : in1;

581

const ITensor *non_broadcast_tensor = !is_broadcast_input_2 ? in2 : in1;

582

583

const QuantizationInfo broadcast_qinfo = broadcast_tensor->info()->quantization_info();

584

const QuantizationInfo non_broadcast_qinfo = non_broadcast_tensor->info()->quantization_info();

585

586

const int32x4_t voffset_non_broadcast = vdupq_n_s32(non_broadcast_qinfo.offset);

587

const float32x4_t vscale_non_broadcast = vdupq_n_f32(non_broadcast_qinfo.scale);

588

589

// Clear X Dimension on execution window as we handle manually

590

non_broadcast_win.set(Window::DimX, Window::Dimension(0, 1, 1));

591

592

Iterator broadcast_input(broadcast_tensor, broadcast_win);

593

Iterator non_broadcast_input(non_broadcast_tensor, non_broadcast_win);

594

Iterator output(out, win);

595

596

execute_window_loop(win, [&](const Coordinates & id)

597

{

598

const auto non_broadcast_input_ptr = reinterpret_cast<const uint8_t *>(non_broadcast_input.ptr());

599

const auto output_ptr = reinterpret_cast<uint8_t *>(output.ptr());

600

601

const uint8_t broadcast_value = *reinterpret_cast<const uint8_t *>(broadcast_input.ptr());

602

const float32x4x4_t broadcast_vector = dup_quantized(broadcast_value, broadcast_qinfo.offset, broadcast_qinfo.scale);

603

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

604

int x = (*broadcast_func)(window_start_x, window_end_x, window_step_x, non_broadcast_input_ptr, broadcast_vector, output_ptr,

605

voffset_non_broadcast, vscale_non_broadcast, voffseto, invvscaleo, !is_broadcast_input_2);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

606

for(; x < window_end_x; ++x)

607

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

608

const float afs = scvt_f32_qasymm8(*(non_broadcast_input_ptr + x), non_broadcast_qinfo.scale, non_broadcast_qinfo.offset);

609

const float bfs = scvt_f32_qasymm8(broadcast_value, broadcast_qinfo.scale, broadcast_qinfo.offset);

610

*(output_ptr + x) = (*scalar_func)(!is_broadcast_input_2 ? bfs : afs, !is_broadcast_input_2 ? afs : bfs,

611

out->info()->quantization_info());

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

612

}

613

},

614

broadcast_input, non_broadcast_input, output);

}

else

{

// Input1 quantization info

619

const int32x4_t voffset1 = vdupq_n_s32(in1->info()->quantization_info().offset);

620

const float32x4_t vscale1 = vdupq_n_f32(in1->info()->quantization_info().scale);

621

622

// Input2 quantization info

623

const int32x4_t voffset2 = vdupq_n_s32(in2->info()->quantization_info().offset);

624

const float32x4_t vscale2 = vdupq_n_f32(in2->info()->quantization_info().scale);

625

626

// Clear X Dimension on execution window as we handle manually

627

input1_win.set(Window::DimX, Window::Dimension(0, 1, 1));

628

input2_win.set(Window::DimX, Window::Dimension(0, 1, 1));

629

630

const QuantizationInfo input1_qinfo = in1->info()->quantization_info();

631

const QuantizationInfo input2_qinfo = in2->info()->quantization_info();

632

633

Iterator input1(in1, input1_win);

634

Iterator input2(in2, input2_win);

635

Iterator output(out, win);

636

637

execute_window_loop(win, [&](const Coordinates & id)

638

{

639

const auto input1_ptr = reinterpret_cast<const uint8_t *>(input1.ptr());

640

const auto input2_ptr = reinterpret_cast<const uint8_t *>(input2.ptr());

641

const auto output_ptr = reinterpret_cast<uint8_t *>(output.ptr());

642

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

643

int x = (*neon_func)(window_start_x, window_end_x, window_step_x, input1_ptr, input2_ptr, output_ptr, voffset1, voffset2,

644

vscale1, vscale2, voffseto, invvscaleo);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

645

for(; x < window_end_x; ++x)

646

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

647

const float afs = scvt_f32_qasymm8(*(input1_ptr + x), input1_qinfo.scale, input1_qinfo.offset);

648

const float bfs = scvt_f32_qasymm8(*(input2_ptr + x), input2_qinfo.scale, input2_qinfo.offset);

649

*(output_ptr + x) = (*scalar_func)(afs, bfs, out->info()->quantization_info());

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

650

}

651

},

652

input1, input2, output);

}

}

George Wort

2018-12-12 17:39:58 +0000

[diff] [blame]

656

template <ComparisonOperation op, typename InputScalarType, typename InputVectorType>

657

void elementwise_comp_op_16(const ITensor *in1, const ITensor *in2, ITensor *out, const Window &window)

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

658

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

659

elementwise_op<InputScalarType, uint8_t, InputVectorType>(in1, in2, out, window,

660

&elementwise_comp_op_scalar<op, InputScalarType>,

661

&elementwise_comp_op_broadcast_16_loop<op, InputScalarType, InputVectorType>,

662

&elementwise_comp_op_16_loop<op, InputScalarType, InputVectorType>);

663

}

664

665

template <ComparisonOperation op, typename InputScalarType, typename InputVectorType>

666

void elementwise_comp_op_32(const ITensor *in1, const ITensor *in2, ITensor *out, const Window &window)

667

{

668

elementwise_op<InputScalarType, uint8_t, InputVectorType>(in1, in2, out, window,

669

&elementwise_comp_op_scalar<op, InputScalarType>,

670

&elementwise_comp_op_broadcast_32_loop<op, InputScalarType, InputVectorType>,

671

&elementwise_comp_op_32_loop<op, InputScalarType, InputVectorType>);

672

}

673

674

template <ArithmeticOperation op, typename ScalarType, typename VectorType>

675

void elementwise_arithm_op(const ITensor *in1, const ITensor *in2, ITensor *out, const Window &window)

676

{

677

elementwise_op<ScalarType, ScalarType, VectorType>(in1, in2, out, window,

678

&elementwise_arithm_op_scalar<op, ScalarType>,

679

&elementwise_arithm_op_broadcast_loop<op, ScalarType, VectorType>,

680

&elementwise_arithm_op_loop<op, ScalarType, VectorType>);

681

}

682

683

template <ArithmeticOperation op>

684

void elementwise_arithm_op_quantized(const ITensor *in1, const ITensor *in2, ITensor *out, const Window &window)

685

{

686

elementwise_op_quantized(in1, in2, out, window, &elementwise_arithm_op_quantized_scalar<op>,

687

&elementwise_arithm_op_quantized_broadcast_loop<op>,

688

&elementwise_arithm_op_quantized_loop<op>);

689

}

690

691

template <ComparisonOperation op>

692

void elementwise_comp_op_quantized(const ITensor *in1, const ITensor *in2, ITensor *out, const Window &window)

693

{

694

elementwise_op_quantized(in1, in2, out, window, &elementwise_comp_op_quantized_scalar<op>,

695

&elementwise_comp_op_quantized_broadcast_loop<op>,

696

&elementwise_comp_op_quantized_loop<op>);

697

}

698

699

std::function<void(const ITensor *, const ITensor *, ITensor *, const Window &)>

700

configure_func(const ITensor *input1, const ITensor *input2, ITensor *output,

701

std::map<std::string, NEElementwiseOperationKernel::ElementwiseFunction *> map_function)

702

{

703

std::string function_to_call("op_");

704

function_to_call += string_from_data_type(input1->info()->data_type()) + "_";

705

function_to_call += string_from_data_type(input2->info()->data_type()) + "_";

706

function_to_call += string_from_data_type(output->info()->data_type());

707

708

auto it = map_function.find(function_to_call);

709

710

if(it != map_function.end())

711

{

712

auto func = it->second;

713

return [func](const ITensor * input1, const ITensor * input2, ITensor * output, const Window & window)

714

{

715

func(input1, input2, output, window);

};

}

return nullptr;

}

template <ArithmeticOperation op>

722

std::function<void(const ITensor *, const ITensor *, ITensor *, const Window &)>

723

configure_arithm_func(const ITensor *input1, const ITensor *input2, ITensor *output)

724

{

725

static std::map<std::string, NEElementwiseOperationKernel::ElementwiseFunction *> map_function =

726

{

727

{ "op_F32_F32_F32", &elementwise_arithm_op<op, float, float32x4_t> },

728

{ "op_S16_S16_S16", &elementwise_arithm_op<op, int16_t, int16x8_t> },

729

{ "op_S32_S32_S32", &elementwise_arithm_op<op, int32_t, int32x4_t> },

730

{ "op_QASYMM8_QASYMM8_QASYMM8", &elementwise_arithm_op_quantized<op> }

731

};

732

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

733

map_function["op_F16_F16_F16"] = &elementwise_arithm_op<op, float16_t, float16x8_t>;

734

#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */

735

736

return configure_func(input1, input2, output, map_function);

737

}

738

739

template <ComparisonOperation op>

740

std::function<void(const ITensor *input1, const ITensor *input2, ITensor *output, const Window &window)>

741

configure_comp_func(const ITensor *input1, const ITensor *input2, ITensor *output)

742

{

743

static std::map<std::string, NEElementwiseOperationKernel::ElementwiseFunction *> map_function =

744

{

745

{ "op_F32_F32_U8", &elementwise_comp_op_32<op, float, float32x4_t> },

746

{ "op_S16_S16_U8", &elementwise_comp_op_16<op, int16_t, int16x8_t> },

747

{ "op_S32_S32_U8", &elementwise_comp_op_32<op, int32_t, int32x4_t> },

748

{ "op_QASYMM8_QASYMM8_U8", &elementwise_comp_op_quantized<op> }

749

};

750

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

751

map_function["op_F16_F16_U8"] = &elementwise_comp_op_16<op, float16_t, float16x8_t>;

752

#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */

753

754

return configure_func(input1, input2, output, map_function);

}

} // namespace

NEElementwiseOperationKernel::NEElementwiseOperationKernel()

759

: _function(nullptr), _input1(nullptr), _input2(nullptr), _output(nullptr)

{

}

Status NEElementwiseOperationKernel::validate_arguments_common(const ITensorInfo &input1, const ITensorInfo &input2, const ITensorInfo &output)

764

{

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

765

ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input1, 1, DataType::QASYMM8, DataType::S16, DataType::F16, DataType::S32, DataType::F32);

766

ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input2, 1, DataType::QASYMM8, DataType::S16, DataType::F16, DataType::S32, DataType::F32);

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

767

ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(&input1);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

768

ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(&input1, &input2);

769

770

const TensorShape out_shape = TensorShape::broadcast_shape(input1.tensor_shape(), input2.tensor_shape());

771

772

ARM_COMPUTE_RETURN_ERROR_ON_MSG(out_shape.total_size() == 0, "Inputs are not broadcast compatible");

773

774

// Validate in case of configured output

775

if(output.total_size() > 0)

776

{

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

777

ARM_COMPUTE_RETURN_ERROR_ON_MSG(detail::have_different_dimensions(out_shape, output.tensor_shape(), 0),

778

"Wrong shape for output");

}

return Status{};

}

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

783

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

784

void NEElementwiseOperationKernel::configure_common(const ITensor *input1, const ITensor *input2, ITensor *output)

785

{

786

ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

787

788

// Configure kernel window

789

const std::pair<TensorShape, ValidRegion> broadcast_pair = ITensorInfo::broadcast_shape_and_valid_region(*input1->info(), *input2->info());

790

const TensorShape &out_shape = broadcast_pair.first;

791

const ValidRegion &valid_region = broadcast_pair.second;

792

793

// Auto initialize output if not initialized

794

auto_init_if_empty(*output->info(), out_shape, 1, input1->info()->data_type());

795

796

Window win = calculate_max_window(valid_region);

797

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

_input1 = input1;

_input2 = input2;

_output = output;

giuros01

2018-12-03 17:30:00 +0000

[diff] [blame]

802

INEKernel::configure(win);

803

}

804

805

void NEElementwiseOperationKernel::run(const Window &window, const ThreadInfo &info)

806

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

807

ARM_COMPUTE_UNUSED(info, window);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

808

ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);

809

ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window);

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

810

ARM_COMPUTE_ERROR_ON(_function == nullptr);

811

_function(_input1, _input2, _output, window);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

812

}

813

814

/** Arithmetic operators (min, max, squared_diff) */

815

816

void NEArithmeticOperationKernel::configure(ArithmeticOperation op, const ITensor *input1, const ITensor *input2, ITensor *output)

817

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

818

ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(*input1->info(), *input2->info(), *output->info()));

819

configure_common(input1, input2, output);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

820

switch(op)

821

{

822

case ArithmeticOperation::MAX:

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

823

_function = configure_arithm_func<ArithmeticOperation::MAX>(input1, input2, output);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

824

break;

825

case ArithmeticOperation::MIN:

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

826

_function = configure_arithm_func<ArithmeticOperation::MIN>(input1, input2, output);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

827

break;

828

case ArithmeticOperation::SQUARED_DIFF:

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

829

_function = configure_arithm_func<ArithmeticOperation::SQUARED_DIFF>(input1, input2, output);

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

830

break;

831

default:

832

ARM_COMPUTE_ERROR("NOT_SUPPORTED!");

}

}

George Wort

2018-12-12 17:39:58 +0000

[diff] [blame]

836

Status NEArithmeticOperationKernel::validate_arguments(const ITensorInfo &input1, const ITensorInfo &input2, const ITensorInfo &output)

837

{

838

// Validate in case of configured output

839

if(output.total_size() > 0)

840

{

841

ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(&input1, &output);

842

}

843

return validate_arguments_common(input1, input2, output);

844

}

845

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

846

Status NEArithmeticOperationKernel::validate(ArithmeticOperation op, const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output)

847

{

848

ARM_COMPUTE_UNUSED(op);

849

ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input1, input2, output);

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

850

ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(*input1, *input2, *output));

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

return Status{};

}

George Wort

2019-01-15 11:00:29 +0000

[diff] [blame]

854

/** The division operator */

855

856

void NEDivisionOperationKernel::configure(const ITensor *input1, const ITensor *input2, ITensor *output)

857

{

858

ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(*input1->info(), *input2->info(), *output->info()));

859

configure_common(input1, input2, output);

860

_function = configure_arithm_func<ArithmeticOperation::DIV>(input1, input2, output);

861

}

862

863

Status NEDivisionOperationKernel::validate_arguments(const ITensorInfo &input1, const ITensorInfo &input2, const ITensorInfo &output)

864

{

865

ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input1, 1, DataType::F16, DataType::F32);

866

return NEArithmeticOperationKernel::validate_arguments(input1, input2, output);

867

}

868

869

Status NEDivisionOperationKernel::validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output)

870

{

871

ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input1, input2, output);

872

ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(*input1, *input2, *output));

return Status{};

}

George Wort

2018-12-12 17:39:58 +0000

[diff] [blame]

876

/** Comparison operators (equal, not equal, less than, greater than, less than or equal, greater than or equal) */

877

878

void NEComparisonOperationKernel::configure(ComparisonOperation op, const ITensor *input1, const ITensor *input2, ITensor *output)

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

879

{

George Wort

d88590f

2018-12-12 17:39:58 +0000

[diff] [blame]

880

ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(*input1->info(), *input2->info(), *output->info()));

881

configure_common(input1, input2, output);

882

switch(op)

883

{

884

case ComparisonOperation::Equal:

885

_function = configure_comp_func<ComparisonOperation::Equal>(input1, input2, output);

886

break;

887

case ComparisonOperation::NotEqual:

888

_function = configure_comp_func<ComparisonOperation::NotEqual>(input1, input2, output);

889

break;

890

case ComparisonOperation::Greater:

891

_function = configure_comp_func<ComparisonOperation::Greater>(input1, input2, output);

892

break;

893

case ComparisonOperation::GreaterEqual:

894

_function = configure_comp_func<ComparisonOperation::GreaterEqual>(input1, input2, output);

895

break;

896

case ComparisonOperation::Less:

897

_function = configure_comp_func<ComparisonOperation::Less>(input1, input2, output);

898

break;

899

case ComparisonOperation::LessEqual:

900

_function = configure_comp_func<ComparisonOperation::LessEqual>(input1, input2, output);

901

break;

902

default:

903

ARM_COMPUTE_ERROR("NOT_SUPPORTED!");

}

}

Status NEComparisonOperationKernel::validate_arguments(const ITensorInfo &input1, const ITensorInfo &input2, const ITensorInfo &output)

908

{

909

// Validate in case of configured output

910

if(output.total_size() > 0)

911

{

912

ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&output, 1, DataType::U8);

913

}

914

return validate_arguments_common(input1, input2, output);

915

}

916

917

Status NEComparisonOperationKernel::validate(ComparisonOperation op, const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output)

918

{

919

ARM_COMPUTE_UNUSED(op);

920

ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input1, input2, output);

921

ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(*input1, *input2, *output));

922

return Status{};

giuros01

92fd943

2018-12-03 17:30:00 +0000

[diff] [blame]

923

}

924

} // namespace arm_compute