luci::CircleConstNodeBuilder Class Reference

Builder creates CircleConst node from Tensor with buffer. More...

#include <CircleConst.h>

Collaboration diagram for luci::CircleConstNodeBuilder:

Public Member Functions
CircleNode *	build (TensorIndex tensor_index, GraphBuilderContext *ctx) const final
Public Member Functions inherited from luci::TypedNodeBuilder< NodeBuilderType::BUFFER >
NodeBuilderType	builder_type () const final
Public Member Functions inherited from luci::NodeBuilderBase
virtual	~NodeBuilderBase ()=default

Detailed Description

Builder creates CircleConst node from Tensor with buffer.

Definition at line 30 of file CircleConst.h.

Member Function Documentation

build()

CircleNode * luci::CircleConstNodeBuilder::build ( TensorIndex  tensor_index, GraphBuilderContext *  ctx  ) const

finalvirtual

Implements luci::NodeBuilderBase.

Definition at line 147 of file CircleConst.cpp.

{
  assert(tensor_index >= 0);
  LOGGER(l);
 
  auto graph = context->graph();
  auto reader = context->reader();
  const auto tensors = reader->tensors();
  const auto const_tensor = tensors[tensor_index];
  assert(const_tensor != nullptr);
  if (const_tensor->is_variable())
  {
    // Create CircleVariable for variable
    return nullptr;
  }
 
  const auto r_buffers = reader->buffers();
  const auto c_buffer = const_tensor->buffer();
  const auto r_buffer = r_buffers[c_buffer];
  assert(r_buffer != nullptr);
  if (r_buffer->offset() == 1 || r_buffer->size() == 1)
  {
    // NOTE this shouldn't happen
    throw std::runtime_error("CircleConst: Circle file with invalid extended Buffer.");
  }
  // temporary buffer to provide raw data from file
  // must have life time same or longer than 'buffer' variable
  std::vector<uint8_t> temp_buffer;
  luci::VectorWrapper<uint8_t> buffer(nullptr);
  if (r_buffer->offset() > 1)
  {
    if (r_buffer->size() >= std::numeric_limits<uint32_t>::max())
    {
      // NOTE uint32_t limit is to match "uoffset_t flatbuffers::Vector::size()"
      throw std::runtime_error("CircleConst: Circle file with invalid extended Buffer.");
    }
    uint32_t r_size = static_cast<uint32_t>(r_buffer->size());
    // match binary level to flatbuffers::Vector
    temp_buffer.resize(r_size + sizeof(uint32_t));
 
    uint8_t *t_data = temp_buffer.data();
    const uint8_t *f_data = reader->file_data(r_buffer->offset());
    if (f_data == nullptr)
    {
      // NOTE this shouldn't happen
      assert(false);
      return nullptr;
    }
    memcpy(t_data, &r_size, sizeof(r_size));
    t_data = t_data + sizeof(r_size);
    if (r_buffer->offset() + r_buffer->size() > reader->file_size())
    {
      // NOTE this shouldn't happen
      assert(false);
      return nullptr;
    }
    memcpy(t_data, f_data, r_buffer->size());
 
    using fbv_t = flatbuffers::Vector<uint8_t>;
    const fbv_t *v_data = reinterpret_cast<const fbv_t *>(temp_buffer.data());
    buffer = wrap(v_data);
 
    context->ext_buffer(true);
  }
  else
  {
    buffer = wrap(r_buffer->data());
  }
  const auto const_dims = wrap(const_tensor->shape()); // in NHWC
  if (const_dims.size() == 0 && buffer.empty())
  {
    // unknown shape tensor and scalar tensor
    return nullptr;
  }
 
  // if tensor_index is used as output to some other operator, this is not a constant
  auto tensoroutputs = context->tensoroutputs();
  if (tensoroutputs->find(tensor_index))
  {
    // other operator output tensor
    return nullptr;
  }
 
  uint32_t num_elements = 1;
  for (uint32_t r = 0; r < const_dims.size(); ++r)
  {
    num_elements = num_elements * const_dims[r];
  }
 
  if (buffer.empty() && num_elements > 0)
  {
    // normal empty tensor
    return nullptr;
  }
 
  auto const_node = graph->nodes()->create<CircleConst>();
  copy_tensor_attributes(const_tensor, const_node);
  const_node->shape_status(luci::ShapeStatus::VALID);
  INFO(l) << "[luci] NodeFinder const_node(" << tensor_index << ") -> " << const_node << " "
          << const_dims << std::endl;
  if (num_elements > 0)
  {
    switch (luci_datatype(const_tensor->type()))
    {
      case loco::DataType::FLOAT32:
        copy_data<loco::DataType::FLOAT32>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::FLOAT16:
        copy_data<loco::DataType::FLOAT16>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::U4:
        copy_data_4<loco::DataType::U4>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::U8:
        copy_data<loco::DataType::U8>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::S4:
        copy_data_4<loco::DataType::S4>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::S8:
        copy_data<loco::DataType::S8>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::S16:
        copy_data<loco::DataType::S16>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::S32:
        copy_data<loco::DataType::S32>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::S64:
        copy_data<loco::DataType::S64>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::BOOL:
        copy_data<loco::DataType::BOOL>(buffer, num_elements, const_node);
        break;
 
      case loco::DataType::STRING:
        copy_data<loco::DataType::STRING>(buffer, num_elements, const_node);
        break;
 
      default:
        throw oops::UserExn("Unsupported tensor type",
                            circle::EnumNameTensorType(const_tensor->type()));
    }
  }
 
  return const_node;
}

References luci::copy_tensor_attributes(), luci::VectorWrapper< T >::empty(), luci::GraphBuilderContext::ext_buffer(), luci::GraphBuilderContext::graph(), INFO, LOGGER, luci::luci_datatype(), luci::GraphBuilderContext::reader(), luci::CircleNode::shape_status(), luci::GraphBuilderContext::tensoroutputs(), luci::CircleReader::tensors(), luci::VALID, and luci::wrap().

---

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

• compiler/luci/import/include/luci/Import/Nodes/CircleConst.h
• compiler/luci/import/src/Nodes/CircleConst.cpp