arm_compute::CLBinaryLogicalOpKernel Class Reference

#include <CLBinaryLogicalOpKernel.h>

Collaboration diagram for arm_compute::CLBinaryLogicalOpKernel:

Public Member Functions
	CLBinaryLogicalOpKernel ()
	CLBinaryLogicalOpKernel (const CLBinaryLogicalOpKernel &)=delete
CLBinaryLogicalOpKernel &	operator= (const CLBinaryLogicalOpKernel &)=delete
	CLBinaryLogicalOpKernel (CLBinaryLogicalOpKernel &&)=default
CLBinaryLogicalOpKernel &	operator= (CLBinaryLogicalOpKernel &&)=default
void	configure (const ICLTensor *input1, const ICLTensor *input2, ICLTensor *output, BinaryLogicalOperation op)
void	run (const Window &window, cl::CommandQueue &queue) override
BorderSize	border_size () const override

Detailed Description

OpenCL kernel to return truth values of two input tensors for Binary Logical Op

Definition at line 52 of file CLBinaryLogicalOpKernel.h.

Constructor & Destructor Documentation

CLBinaryLogicalOpKernel() [1/3]

CLBinaryLogicalOpKernel::CLBinaryLogicalOpKernel

(

)

Default constructor

Definition at line 80 of file CLBinaryLogicalOpKernel.cpp.

  : _input1(nullptr), _input2(nullptr), _output(nullptr)
{
}

CLBinaryLogicalOpKernel() [2/3]

arm_compute::CLBinaryLogicalOpKernel::CLBinaryLogicalOpKernel ( const CLBinaryLogicalOpKernel &  )

delete

Prevent instances of this class from being copied (As this class contains pointers).

CLBinaryLogicalOpKernel() [3/3]

arm_compute::CLBinaryLogicalOpKernel::CLBinaryLogicalOpKernel ( CLBinaryLogicalOpKernel &&  )

default

Allow instances of this class to be moved

Member Function Documentation

border_size()

BorderSize CLBinaryLogicalOpKernel::border_size ( ) const

override

Definition at line 191 of file CLBinaryLogicalOpKernel.cpp.

{
  const unsigned int replicateSize =
    _output->info()->dimension(0) -
    std::min(_input1->info()->dimension(0), _input2->info()->dimension(0));
  const unsigned int border =
    std::min<unsigned int>(num_elems_processed_per_iteration - 1U, replicateSize);
  return BorderSize(0, border, 0, 0);
}

configure()

void CLBinaryLogicalOpKernel::configure	(	const ICLTensor *	input1,
		const ICLTensor *	input2,
		ICLTensor *	output,
		BinaryLogicalOperation	op
	)

Initialize the kernel's input, output.

Parameters

[in]	input1	Source tensor1.
[in]	input2	Source tensor2.
[out]	output	Output tensor.

Definition at line 85 of file CLBinaryLogicalOpKernel.cpp.

{
  ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input1, input2);
  ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input1, output);
  ARM_COMPUTE_ERROR_THROW_ON(validate_parameters(input1->info(), input2->info(), output->info()));
 
  _input1 = input1;
  _input2 = input2;
  _output = output;
 
  // Create kernel
  std::string kernel_name = "binary_logical_op";
  std::set<std::string> build_opts;
  build_opts.emplace(("-DDATA_TYPE=" + get_cl_type_from_data_type(input1->info()->data_type())));
 
  int op_code = 0;
  switch (op)
  {
    case BinaryLogicalOperation::AND:
      op_code = 1;
      break;
    case BinaryLogicalOperation::OR:
      op_code = 2;
      break;
    default:
      throw std::runtime_error("Operation not supported, yet");
  }
 
  build_opts.emplace(("-DOP_CODE=" + support::cpp11::to_string(op_code)));
  build_opts.emplace(
    ("-DVEC_SIZE=" + support::cpp11::to_string(num_elems_processed_per_iteration)));
 
  _kernel =
    static_cast<cl::Kernel>(CLKernelLibraryEx::get().create_kernel(kernel_name, build_opts));
 
  const std::pair<TensorShape, ValidRegion> broadcast_pair =
    ITensorInfo::broadcast_shape_and_valid_region(*input1->info(), *input2->info());
 
  const ValidRegion &valid_region = broadcast_pair.second;
 
  Window win = calculate_max_window(valid_region, Steps(num_elems_processed_per_iteration));
  Window win_input1 = win.broadcast_if_dimension_le_one(*input1->info());
  Window win_input2 = win.broadcast_if_dimension_le_one(*input2->info());
 
  AccessWindowHorizontal input1_access(input1->info(), 0, num_elems_processed_per_iteration);
  AccessWindowHorizontal input2_access(input2->info(), 0, num_elems_processed_per_iteration);
  AccessWindowHorizontal output_access(output->info(), 0, num_elems_processed_per_iteration);
 
  update_window_and_padding(win_input1, input1_access) ||
    update_window_and_padding(win_input2, input2_access) ||
    update_window_and_padding(win, output_access);
 
  output_access.set_valid_region(win, valid_region);
 
  ICLKernel::configure_internal(win);
}

References arm_compute::AND, arm_compute::CLKernelLibraryEx::create_kernel(), arm_compute::CLKernelLibraryEx::get(), and arm_compute::OR.

operator=() [1/2]

CLBinaryLogicalOpKernel & arm_compute::CLBinaryLogicalOpKernel::operator= ( CLBinaryLogicalOpKernel &&  )

default

Allow instances of this class to be moved

operator=() [2/2]

CLBinaryLogicalOpKernel & arm_compute::CLBinaryLogicalOpKernel::operator= ( const CLBinaryLogicalOpKernel &  )

delete

Prevent instances of this class from being copied (As this class contains pointers).

run()

void CLBinaryLogicalOpKernel::run ( const Window &  window, cl::CommandQueue &  queue  )

override

Definition at line 143 of file CLBinaryLogicalOpKernel.cpp.

{
  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICLKernel::window(), window);
 
  const TensorShape &in_shape1 = _input1->info()->tensor_shape();
  const TensorShape &in_shape2 = _input2->info()->tensor_shape();
  const TensorShape &out_shape = _output->info()->tensor_shape();
 
  bool can_collapse = true;
  if (std::min(in_shape1.total_size(), in_shape2.total_size()) > 1)
  {
    can_collapse =
      (std::min(in_shape1.num_dimensions(), in_shape2.num_dimensions()) > Window::DimZ);
    for (size_t d = Window::DimZ; can_collapse && (d < out_shape.num_dimensions()); d++)
    {
      can_collapse = (in_shape1[d] == in_shape2[d]);
    }
  }
 
  bool has_collapsed = false;
  Window collapsed =
    can_collapse ? window.collapse_if_possible(ICLKernel::window(), Window::DimZ, &has_collapsed)
                 : window;
 
  const TensorShape &in_shape1_collapsed =
    has_collapsed ? in_shape1.collapsed_from(Window::DimZ) : in_shape1;
  const TensorShape &in_shape2_collapsed =
    has_collapsed ? in_shape2.collapsed_from(Window::DimZ) : in_shape2;
 
  Window slice = collapsed.first_slice_window_3D();
  Window slice_input1 = slice.broadcast_if_dimension_le_one(in_shape1_collapsed);
  Window slice_input2 = slice.broadcast_if_dimension_le_one(in_shape2_collapsed);
 
  do
  {
    unsigned int idx = 0;
    add_3D_tensor_argument(idx, _input1, slice_input1);
    add_3D_tensor_argument(idx, _input2, slice_input2);
    add_3D_tensor_argument(idx, _output, slice);
 
    enqueue(queue, *this, slice);
 
    collapsed.slide_window_slice_3D(slice_input1);
    collapsed.slide_window_slice_3D(slice_input2);
  } while (collapsed.slide_window_slice_3D(slice));
}

Referenced by package.infer.session::inference().

---

The documentation for this class was generated from the following files:

• compute/ARMComputeEx/arm_compute/core/CL/kernels/CLBinaryLogicalOpKernel.h
• compute/ARMComputeEx/src/core/CL/kernels/CLBinaryLogicalOpKernel.cpp