#include <NEHashtableLookupKernel.h>

Collaboration diagram for arm_compute::NEHashtableLookupKernel:

Public Member Functions
const char *	name () const override

	NEHashtableLookupKernel ()

	NEHashtableLookupKernel (const NEHashtableLookupKernel &)=delete

NEHashtableLookupKernel &	operator= (const NEHashtableLookupKernel &)=delete

	NEHashtableLookupKernel (NEHashtableLookupKernel &&)=default

NEHashtableLookupKernel &	operator= (NEHashtableLookupKernel &&)=default

void	configure (const ITensor lookups, const ITensor keys, const ITensor input, ITensor output, ITensor *hits)

void	run (const Window &window, const ThreadInfo &info) override

Static Public Member Functions
static Status	validate (const ITensorInfo lookups, const ITensorInfo keys, const ITensorInfo input, const ITensorInfo output, const ITensorInfo *hits)

Detailed Description

NEON kernel to perform HashtableLookup operation

Definition at line 52 of file NEHashtableLookupKernel.h.

Constructor & Destructor Documentation

◆ NEHashtableLookupKernel() [1/3]

NEHashtableLookupKernel::NEHashtableLookupKernel ( )

Default constructor

Definition at line 62 of file NEHashtableLookupKernel.cpp.

  : _lookups(nullptr), _keys(nullptr), _input(nullptr), _output(nullptr), _hits{nullptr}
{
}

◆ NEHashtableLookupKernel() [2/3]

arm_compute::NEHashtableLookupKernel::NEHashtableLookupKernel ( const NEHashtableLookupKernel & )

delete

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

◆ NEHashtableLookupKernel() [3/3]

arm_compute::NEHashtableLookupKernel::NEHashtableLookupKernel ( NEHashtableLookupKernel && )

default

Allow instances of this class to be moved

Member Function Documentation

◆ configure()

void NEHashtableLookupKernel::configure	(	const ITensor *	lookups,
		const ITensor *	keys,
		const ITensor *	input,
		ITensor *	output,
		ITensor *	hits
	)

Initialize the kernel's inputs, outputs.

Parameters

[in]	lookups	Lookups 1D tensor that values are indices into the first dimension of input. Data types supported: S32
[in]	keys	Keys 1D tensor. keys and input pair represent a map. Data types supported: S32
[in]	input	Source tensor. Data types supported: U8/S8/QASYMM8/U16/S16/U32/S32/F16/F32
[out]	output	Destination tensor. Data types and data layouts supported: Same as `input`.
[out]	hits	Hits 1D tensor. A boolean tensor that indicates whether the lookup hits (True) or not (False). Data types supported: U8/QASYMM8 input.

Definition at line 67 of file NEHashtableLookupKernel.cpp.

{
  ARM_COMPUTE_ERROR_ON_NULLPTR(lookups, keys, input, output, hits);
  ARM_COMPUTE_ERROR_THROW_ON(
    validate(lookups->info(), keys->info(), input->info(), output->info(), hits->info()));
 
  _lookups = lookups;
  _keys = keys;
  _input = input;
  _output = output;
  _hits = hits;
 
  // Auto initialize output if not initialized
  auto out_shape{input->info()->tensor_shape()};
  out_shape.set(out_shape.num_dimensions() - 1, lookups->info()->num_dimensions(), false);
  auto_init_if_empty(*output->info(), out_shape, 1, input->info()->data_type(),
                     input->info()->quantization_info());
 
  // Auto initialize hits if not initialized
  auto_init_if_empty(*hits->info(), lookups->info()->tensor_shape(), 1, DataType::U8);
 
  INEKernel::configure(calculate_max_window(*output->info()));
}

References validate().

◆ name()

const char * arm_compute::NEHashtableLookupKernel::name ( ) const

inlineoverride

Definition at line 55 of file NEHashtableLookupKernel.h.

55{ return "NEHashtableLookupKernel"; }

◆ operator=() [1/2]

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

delete

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

◆ operator=() [2/2]

NEHashtableLookupKernel & arm_compute::NEHashtableLookupKernel::operator= ( NEHashtableLookupKernel && )

default

Allow instances of this class to be moved

References validate().

◆ run()

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

override

Definition at line 132 of file NEHashtableLookupKernel.cpp.

{
  ARM_COMPUTE_UNUSED(info);
  ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
  ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window);
 
  const size_t lookup_dim = _output->info()->num_dimensions() - 1;
  const int const_0 = _output->info()->data_type() == DataType::QASYMM8
                        ? _output->info()->quantization_info().uniform().offset
                        : 0;
 
  std::unordered_map<int32_t, size_t> key_index_map;
  for (size_t n = 0; n < _keys->info()->dimension(0); ++n)
  {
    const int32_t key = *reinterpret_cast<int32_t *>(_keys->ptr_to_element({n}));
    key_index_map[key] = n;
  }
  std::vector<size_t> lookup_indices;
  for (size_t k = 0; k < _lookups->info()->dimension(0); ++k)
  {
    const int32_t key = *reinterpret_cast<int32_t *>(_lookups->ptr_to_element({k}));
    const auto it = key_index_map.find(key);
    if (it == key_index_map.end())
    {
      lookup_indices.emplace_back(NOT_HIT);
      *_hits->ptr_to_element({k}) = 0;
    }
    else
    {
#if defined(ARM_COMPUTE_DEBUG_ENABLED)
      if (it->second >= _keys->info()->dimension(0))
        ARM_COMPUTE_ERROR("HashTable Lookup: Index out of bounds.");
#endif // defined(ARM_COMPUTE_DEBUG_ENABLED)
      lookup_indices.emplace_back(it->second);
      *_hits->ptr_to_element({k}) = 1;
    }
  }
 
  Window output_window{window};
  output_window.set(Window::DimX,
                    Window::Dimension(output_window.x().start(), output_window.x().end(),
                                      _input->info()->dimension(0)));
 
  Window out_slice = output_window.first_slice_window_4D();
  do
  {
    Iterator output_it(_output, out_slice);
 
    execute_window_loop(
      out_slice,
      [&](const Coordinates &id) {
        const auto lookup = lookup_indices.at(id[lookup_dim]);
        if (lookup == NOT_HIT)
        {
          memset(output_it.ptr(), const_0,
                 _output->info()->dimension(0) * _output->info()->element_size());
        }
        else
        {
          Coordinates input_id{id};
          input_id.set(lookup_dim, lookup);
          memcpy(output_it.ptr(), _input->ptr_to_element(input_id),
                 _output->info()->dimension(0) * _output->info()->element_size());
        }
      },
      output_it);
 
  } while (window.slide_window_slice_4D(out_slice));
}

References info.

◆ validate()

Status NEHashtableLookupKernel::validate	(	const ITensorInfo *	lookups,
		const ITensorInfo *	keys,
		const ITensorInfo *	input,
		const ITensorInfo *	output,
		const ITensorInfo *	hits
	)

static

Static function to check if given info will lead to a valid configuration of NEHashtableLookupKernel