entry.cpp File Reference

#include <nncc/core/ADT/tensor/Shape.h>
#include <nncc/core/ADT/tensor/LexicalLayout.h>
#include <nncc/core/ADT/tensor/IndexEnumerator.h>
#include <H5Cpp.h>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>

Go to the source code of this file.

Functions
int	entry (int argc, char **argv)
	Dump IR for given arguments.

Function Documentation

entry()

int entry	(	int	argc,
		char **	argv
	)

Dump IR for given arguments.

Call example: $ ./build/compiler/encodump/encodump \ –frontend build/compiler/enco/frontend/caffe/libenco_caffe_frontend.so \ –frontend-arg build/compiler/enco/test/caffe/Convolution_003.prototxt \ –frontend-arg build/compiler/enco/test/caffe/Convolution_003.caffemodel

HDF5 layout is like below

GROUP "/" ㄴGROUP "name" ㄴATTRIBUTE "0" ㄴDATA (0): "input_01:0" ㄴATTRIBUTE "1" ㄴDATA (0): "input_02:0" ㄴGROUP "value" ㄴDATASET "0" ㄴDATA ... ㄴDATASET "1" ㄴDATA ...

Definition at line 193 of file entry.cpp.

{
  // The current implementation works only for command-line of the following form:
  //
  //   i5diff -d 0.001 /path/to/left.h5 /path/to/right.h5
  //
  // TODO Support more options
  assert(argc == 5);
  assert(std::string(argv[1]) == "-d");
  assert(std::string(argv[2]) == "0.001");
 
  H5::H5File lhs{argv[3], H5F_ACC_RDONLY};
  H5::H5File rhs{argv[4], H5F_ACC_RDONLY};
 
  ExitcodeTracker exitcode_tracker;
 
  Mux mux;
  mux.attach(&exitcode_tracker);
 
  // Compare values
  do
  {
    // NOTE The name of value group SHOULD BE aligned with nnkit HDF5 actions
    const std::string value_grpname{"value"};
 
    H5::Group lhs_value_grp = lhs.openGroup(value_grpname);
    H5::Group rhs_value_grp = rhs.openGroup(value_grpname);
 
    // Compare value count
    int64_t value_count = -1;
    {
      uint32_t lhs_value_count = static_cast<uint32_t>(lhs_value_grp.getNumObjs());
      uint32_t rhs_value_count = static_cast<uint32_t>(rhs_value_grp.getNumObjs());
 
      if (lhs_value_count != rhs_value_count)
      {
        ErrorDetail<ErrorCode::CountMismatch> error{};
        mux.notify(error);
        break;
      }
 
      value_count = std::max<int64_t>(lhs_value_count, rhs_value_count);
    }
    assert(value_count >= 0);
 
    // Compare each dataset
    for (int64_t n = 0; n < value_count; ++n)
    {
      // NOTE The name of dataset SHOULD BE aligned with nnkit HDF5 actions
      const std::string dataset_name = std::to_string(n);
 
      auto lhs_dataset = lhs_value_grp.openDataSet(dataset_name);
      auto rhs_dataset = rhs_value_grp.openDataSet(dataset_name);
 
      auto lhs_dtype = to_internal_dtype(lhs_dataset.getDataType());
      auto rhs_dtype = to_internal_dtype(rhs_dataset.getDataType());
 
      // TODO Support other data types
      assert(rhs_dtype == DataType::FLOAT32);
      assert(lhs_dtype == DataType::FLOAT32);
 
      if (lhs_dtype != rhs_dtype)
      {
        ErrorDetail<ErrorCode::TypeMismatch> error{};
        mux.notify(error);
        continue;
      }
 
      auto lhs_shape = to_internal_shape(lhs_dataset.getSpace());
      auto rhs_shape = to_internal_shape(rhs_dataset.getSpace());
 
      if (!(lhs_shape == rhs_shape))
      {
        ErrorDetail<ErrorCode::ShapeMismatch> error{};
        mux.notify(error);
        continue;
      }
 
      assert(lhs_shape == rhs_shape);
      assert(lhs_dtype == rhs_dtype);
      const auto &shape = lhs_shape;
      const auto &dtype = lhs_dtype;
 
      switch (dtype)
      {
        case DataType::FLOAT32:
        {
          auto lhs_vector = as_float_vector(lhs_dataset);
          auto rhs_vector = as_float_vector(rhs_dataset);
 
          assert(lhs_vector.size() == rhs_vector.size());
 
          LexicalLayout layout;
 
          for (TensorIndexEnumerator e{shape}; e.valid(); e.advance())
          {
            const auto &ind = e.current();
            auto lhs_value = lhs_vector.at(layout.offset(shape, ind));
            auto rhs_value = rhs_vector.at(layout.offset(shape, ind));
 
            // TODO Abstract equality criterion
            if (std::abs(lhs_value - rhs_value) >= 0.001f)
            {
              ErrorDetail<ErrorCode::ValueMismatch> error{};
              mux.notify(error);
              continue;
            }
          }
 
          break;
        }
        default:
          throw std::runtime_error{"Not supported, yet"};
      };
    }
  } while (false);
 
  // TODO Compare names (if requested)
 
  return exitcode_tracker.exitcode();
}

References value_grpname().