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

430

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

431

}

return x;

}

template <ComparisonOperation op, typename InputScalarType, typename InputVectorType>

436

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

437

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

438

{

439

int x = window_start_x;

440

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

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

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

444

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

445

}

446

if(x <= window_end_x - 4)

447

{

448

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

449

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

450

{

451

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

}

x = +4;

}

return x;

}

template <ComparisonOperation op>

459

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

460

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

461

int32x4_t voffset_non_broadcast, float32x4_t vscale_non_broadcast,

462

float32x4_t voffseto, float32x4_t invvscaleo, bool reorder)

463

{

464

ARM_COMPUTE_UNUSED(voffseto, invvscaleo);

465

int x = window_start_x;

466

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

467

{

468

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

469

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

470

store_quantized(output_ptr + x, rf);

}

return x;

}

template <typename InputScalarType, typename OutputScalarType, typename InputVectorType>

476

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

477

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

478

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

479

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

giuros01

92fd943

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

[diff] [blame]

480

{

481

// Create input windows

482

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

483

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

484

485

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

486

Window win = window;

487

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

488

Michalis Spyrou

e8c0c43

2019-01-22 11:08:31 +0000

[diff] [blame]

489

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

giuros01

92fd943

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

[diff] [blame]

490

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

491

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

492

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

493

494

if(is_broadcast_across_x)

495

{

giuros01

92fd943

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

[diff] [blame]

496

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

497

Window broadcast_win = is_broadcast_input_2 ? input2_win : input1_win;

498

Window non_broadcast_win = !is_broadcast_input_2 ? input2_win : input1_win;

499

const ITensor *broadcast_tensor = is_broadcast_input_2 ? in2 : in1;

500

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

501

502

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

503

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

504

505

Iterator broadcast_input(broadcast_tensor, broadcast_win);

506

Iterator non_broadcast_input(non_broadcast_tensor, non_broadcast_win);

507

Iterator output(out, win);

508

509

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

510

{

George Wort

d88590f

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

[diff] [blame]

511

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

512

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

513

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

giuros01

92fd943

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

[diff] [blame]

514

George Wort

d88590f

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

[diff] [blame]

515

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]

516

for(; x < window_end_x; ++x)

517

{

518

const auto a = *(non_broadcast_input_ptr + x);

George Wort

d88590f

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

[diff] [blame]

519

*(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]

520

}

521

},

522

broadcast_input, non_broadcast_input, output);

}

else

{

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

527

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

528

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

529

530

Iterator input1(in1, input1_win);

531

Iterator input2(in2, input2_win);

532

Iterator output(out, win);

533

534

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

535

{

George Wort

d88590f

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

[diff] [blame]

536

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

537

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

538

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

giuros01

92fd943

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

[diff] [blame]

539

George Wort

d88590f

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

[diff] [blame]

540

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]

541

for(; x < window_end_x; ++x)

542

{

543

const auto a = *(input1_ptr + x);

544

const auto b = *(input2_ptr + x);

George Wort

d88590f

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

[diff] [blame]

545

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

giuros01

92fd943

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

[diff] [blame]

546

}

giuros01

92fd943

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

[diff] [blame]

547

},

548

input1, input2, output);

}

}

George Wort

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

[diff] [blame]

552

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

553

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

554

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

555

float32x4_t, float32x4_t, const bool),

556

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

557

int32x4_t, int32x4_t, float32x4_t, float32x4_t,

558

float32x4_t, float32x4_t))

giuros01

92fd943

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

[diff] [blame]

559

{

560

// Create input windows

561

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

562

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

563

564

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

565

Window win = window;

566

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

567

568

const int window_step_x = 16;

569

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

570

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

571

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

572

573

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

574

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

575

576

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

577

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

578

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

579

580

if(is_broadcast_across_x)

581

{

582

// Select the broadcast input on the X axis

583

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

584

Window broadcast_win = is_broadcast_input_2 ? input2_win : input1_win;

585

Window non_broadcast_win = !is_broadcast_input_2 ? input2_win : input1_win;

586

const ITensor *broadcast_tensor = is_broadcast_input_2 ? in2 : in1;

587

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

588

589

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

590

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

591

592

const int32x4_t voffset_non_broadcast = vdupq_n_s32(non_broadcast_qinfo.offset);

593

const float32x4_t vscale_non_broadcast = vdupq_n_f32(non_broadcast_qinfo.scale);

594

595

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

596

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

597

598

Iterator broadcast_input(broadcast_tensor, broadcast_win);

599

Iterator non_broadcast_input(non_broadcast_tensor, non_broadcast_win);

600

Iterator output(out, win);

601

602

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

603

{

604

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

605

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

606

607

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

608

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

609

George Wort

d88590f

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

[diff] [blame]

610

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

611

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

giuros01

92fd943

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

[diff] [blame]

612

for(; x < window_end_x; ++x)

613

{

George Wort

d88590f

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

[diff] [blame]

614

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

615

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

616

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

617

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

giuros01

92fd943

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

[diff] [blame]

618

}

619

},

620

broadcast_input, non_broadcast_input, output);

}

else

{

// Input1 quantization info

625

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

626

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

627

628

// Input2 quantization info

629

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

630

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

631

632

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

633

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

634

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

635

636

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

637

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

638

639

Iterator input1(in1, input1_win);

640

Iterator input2(in2, input2_win);

641

Iterator output(out, win);

642

643

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

644

{

645

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

646

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

647

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

648

George Wort

d88590f

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

[diff] [blame]

649

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

650

vscale1, vscale2, voffseto, invvscaleo);

giuros01

92fd943

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

[diff] [blame]

651

for(; x < window_end_x; ++x)

652

{

George Wort

d88590f

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

[diff] [blame]

653

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

654

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

655

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

giuros01

92fd943

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

[diff] [blame]

656

}

657

},

658

input1, input2, output);

}

}

George Wort

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

[diff] [blame]

662

template <ComparisonOperation op, typename InputScalarType, typename InputVectorType>

663

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]

664

{

George Wort

d88590f

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

[diff] [blame]

665

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

666

&elementwise_comp_op_scalar<op, InputScalarType>,

667

&elementwise_comp_op_broadcast_16_loop<op, InputScalarType, InputVectorType>,

668

&elementwise_comp_op_16_loop<op, InputScalarType, InputVectorType>);

669

}

670

671

template <ComparisonOperation op, typename InputScalarType, typename InputVectorType>

672

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

673

{

674

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

675

&elementwise_comp_op_scalar<op, InputScalarType>,

676

&elementwise_comp_op_broadcast_32_loop<op, InputScalarType, InputVectorType>,

677

&elementwise_comp_op_32_loop<op, InputScalarType, InputVectorType>);

678

}

679

680

template <ArithmeticOperation op, typename ScalarType, typename VectorType>

681

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

682

{

683

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

684

&elementwise_arithm_op_scalar<op, ScalarType>,

685

&elementwise_arithm_op_broadcast_loop<op, ScalarType, VectorType>,

686

&elementwise_arithm_op_loop<op, ScalarType, VectorType>);

687

}

688

689

template <ArithmeticOperation op>

690

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

691

{

692

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

693

&elementwise_arithm_op_quantized_broadcast_loop<op>,

694

&elementwise_arithm_op_quantized_loop<op>);

695

}

696

697

template <ComparisonOperation op>

698

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

699

{

700

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

701

&elementwise_comp_op_quantized_broadcast_loop<op>,

702

&elementwise_comp_op_quantized_loop<op>);

703

}

704

705

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

706

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

707

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

708

{

709

std::string function_to_call("op_");

710

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

711

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

712

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

713

714

auto it = map_function.find(function_to_call);

715

716

if(it != map_function.end())

717

{

718

auto func = it->second;

719

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

720

{

721

func(input1, input2, output, window);

};

}

return nullptr;

}

template <ArithmeticOperation op>

728

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

729

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

730

{

731

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

732

{

733

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

734

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

735

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

736

{ "op_QASYMM8_QASYMM8_QASYMM8", &elementwise_arithm_op_quantized<op> }

737

};

738

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

739

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

740

#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */

741

742

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

743

}

744

745

template <ComparisonOperation op>

746

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

747

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

748

{

749

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

750

{

751

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

752

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

753

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

754

{ "op_QASYMM8_QASYMM8_U8", &elementwise_comp_op_quantized<op> }

755

};

756

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

757

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

758

#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */

759

760

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

}

} // namespace

NEElementwiseOperationKernel::NEElementwiseOperationKernel()

765

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

{

}

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

770

{

giuros01

92fd943

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

[diff] [blame]

771

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

772

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]

773

ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(&input1);

giuros01

92fd943

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

[diff] [blame]

774

ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(&input1, &input2);

775

776

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

777

778

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

779

780

// Validate in case of configured output

781

if(output.total_size() > 0)

782

{

giuros01

92fd943

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

[diff] [blame]

783

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

784

"Wrong shape for output");

}

return Status{};

}

giuros01

92fd943

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

[diff] [blame]

789

giuros01

92fd943

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

[diff] [blame]

790

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

791

{

792

ARM_COMPUTE_ERROR_ON_NULLPTR(input1, input2, output);

giuros01

92fd943

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

[diff] [blame]

793

794

// Configure kernel window

795

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

796

const TensorShape &out_shape = broadcast_pair.first;

797

const ValidRegion &valid_region = broadcast_pair.second;

798

799

// Auto initialize output if not initialized

800

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

801

802

Window win = calculate_max_window(valid_region);

803

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]

808

INEKernel::configure(win);

809

}

810

811

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

812

{

George Wort

d88590f

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

[diff] [blame]

813

ARM_COMPUTE_UNUSED(info, window);

giuros01

92fd943

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

[diff] [blame]

814

ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);

815

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

George Wort

d88590f

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

[diff] [blame]

816

ARM_COMPUTE_ERROR_ON(_function == nullptr);

817

_function(_input1, _input2, _output, window);

giuros01

92fd943

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

[diff] [blame]

818

}

819

820

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

821

822

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

823

{

George Wort

d88590f

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

[diff] [blame]

824

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

825

configure_common(input1, input2, output);

giuros01

92fd943

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

[diff] [blame]

826

switch(op)

827

{

828

case ArithmeticOperation::MAX:

George Wort

d88590f

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

[diff] [blame]

829

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

giuros01

92fd943

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

[diff] [blame]

830

break;

831

case ArithmeticOperation::MIN:

George Wort

d88590f

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

[diff] [blame]

832

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

giuros01

92fd943

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

[diff] [blame]

833

break;

834

case ArithmeticOperation::SQUARED_DIFF:

George Wort

d88590f

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

[diff] [blame]

835

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

giuros01

92fd943

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

[diff] [blame]

836

break;

837

default:

838

ARM_COMPUTE_ERROR("NOT_SUPPORTED!");

}

}

George Wort

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

[diff] [blame]

842

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

843

{

844

// Validate in case of configured output

845

if(output.total_size() > 0)

846

{

847

ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(&input1, &output);

848

}

849

return validate_arguments_common(input1, input2, output);

850

}

851

giuros01

92fd943

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

[diff] [blame]

852

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

853

{

854

ARM_COMPUTE_UNUSED(op);

855

ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input1, input2, output);

George Wort

d88590f

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

[diff] [blame]

856

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]

860

/** The division operator */

861

862

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

863

{

864

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

865

configure_common(input1, input2, output);

866

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

867

}

868

869

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

870

{

871

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

872

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

873

}

874

875

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

876

{

877

ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input1, input2, output);

878

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

return Status{};

}

George Wort

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

[diff] [blame]

882

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

883

884

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

giuros01

92fd943

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

[diff] [blame]

885

{

George Wort

d88590f

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

[diff] [blame]

886

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

887

configure_common(input1, input2, output);

888

switch(op)

889

{

890

case ComparisonOperation::Equal:

891

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

892

break;

893

case ComparisonOperation::NotEqual:

894

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

895

break;

896

case ComparisonOperation::Greater:

897

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

898

break;

899

case ComparisonOperation::GreaterEqual:

900

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

901

break;

902

case ComparisonOperation::Less:

903

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

904

break;

905

case ComparisonOperation::LessEqual:

906

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

907

break;

908

default:

909

ARM_COMPUTE_ERROR("NOT_SUPPORTED!");

}

}

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

914

{

915

// Validate in case of configured output

916

if(output.total_size() > 0)

917

{

918

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

919

}

920

return validate_arguments_common(input1, input2, output);

921

}

922

923

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

924

{

925

ARM_COMPUTE_UNUSED(op);

926

ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input1, input2, output);

927

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

928

return Status{};

giuros01

92fd943

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

[diff] [blame]

929

}

930

} // namespace arm_compute