record_minmax::RandomIterator Class Reference

#include <RandomIterator.h>

Collaboration diagram for record_minmax::RandomIterator:

Public Member Functions
	RandomIterator (luci::Module *module)
bool	hasNext () const override
std::vector< DataBuffer >	next () override
bool	check_type_shape () const override
Public Member Functions inherited from record_minmax::DataSetIterator
virtual	~DataSetIterator ()=default

Detailed Description

Definition at line 32 of file RandomIterator.h.

Constructor & Destructor Documentation

RandomIterator()

record_minmax::RandomIterator::RandomIterator

(

luci::Module *

module

)

Definition at line 64 of file RandomIterator.cpp.

{
  assert(module); // FIX_CALLER_UNLESS
 
  std::random_device rd;
  std::mt19937 _gen(rd());
 
  auto input_nodes = loco::input_nodes(module->graph());
  for (auto input_node : input_nodes)
  {
    const auto cnode = loco::must_cast<const luci::CircleInput *>(input_node);
    _input_nodes.emplace_back(cnode);
  }
 
  // Hardcoded
  _num_data = 3;
}

References loco::input_nodes(), and loco::must_cast().

Member Function Documentation

check_type_shape()

bool record_minmax::RandomIterator::check_type_shape ( ) const

overridevirtual

Implements record_minmax::DataSetIterator.

Definition at line 143 of file RandomIterator.cpp.

{ return false; }

hasNext()

bool record_minmax::RandomIterator::hasNext ( ) const

overridevirtual

Implements record_minmax::DataSetIterator.

Definition at line 82 of file RandomIterator.cpp.

{ return _curr_idx < _num_data; }

next()

std::vector< DataBuffer > record_minmax::RandomIterator::next ( )

overridevirtual

Implements record_minmax::DataSetIterator.

Definition at line 84 of file RandomIterator.cpp.

{
  std::vector<DataBuffer> res;
 
  for (auto input_node : _input_nodes)
  {
    DataBuffer buf;
 
    const auto dtype = input_node->dtype();
    const auto num_elements = numElements(input_node);
 
    buf.data.resize(getTensorSize(input_node));
 
    switch (dtype)
    {
      case loco::DataType::FLOAT32:
      {
        const auto input_data = genRandomData(_gen, num_elements, -5, 5);
        const auto data_size = input_data.size() * sizeof(float);
        assert(buf.data.size() == data_size);
        memcpy(buf.data.data(), input_data.data(), data_size);
        break;
      }
      case loco::DataType::S32:
      {
        const auto input_data = genRandomIntData<int32_t>(_gen, num_elements, 0, 100);
        const auto data_size = input_data.size() * sizeof(int32_t);
        assert(buf.data.size() == data_size);
        memcpy(buf.data.data(), input_data.data(), data_size);
        break;
      }
      case loco::DataType::S64:
      {
        const auto input_data = genRandomIntData<int64_t>(_gen, num_elements, 0, 100);
        const auto data_size = input_data.size() * sizeof(int64_t);
        assert(buf.data.size() == data_size);
        memcpy(buf.data.data(), input_data.data(), data_size);
        break;
      }
      case loco::DataType::BOOL:
      {
        const auto input_data = genRandomIntData<uint8_t>(_gen, num_elements, 0, 1);
        const auto data_size = input_data.size() * sizeof(uint8_t);
        assert(buf.data.size() == data_size);
        memcpy(buf.data.data(), input_data.data(), data_size);
        break;
      }
      default:
        throw std::runtime_error("Unsupported datatype");
    }
 
    res.emplace_back(buf);
  }
 
  _curr_idx++; // move to the next index
 
  return res;
}

References record_minmax::getTensorSize(), and record_minmax::numElements().

---

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

• compiler/record-minmax/include/RandomIterator.h
• compiler/record-minmax/src/RandomIterator.cpp