Method runAnalysisWithRandomInput

compiler/dalgona/src/Dalgona.cpp:184–261

}

void Dalgona::runAnalysisWithRandomInput(const std::string &analysis_path,
                                         const std::string &analysis_args)
{
  py::object scope = py::module::import("__main__").attr("__dict__");
  _hooks->importAnalysis(analysis_path, scope, analysis_args);

  const auto input_nodes = loco::input_nodes(_module->graph());
  const auto num_inputs = input_nodes.size();

  for (uint32_t input_idx = 0; input_idx < num_inputs; input_idx++)
  {
    const auto *input_node = loco::must_cast<const luci::CircleInput *>(input_nodes[input_idx]);
    assert(input_node->index() == input_idx);
    checkInputDimension(input_node);

    uint32_t num_elems = numElements(input_node);
    switch (input_node->dtype())
    {
      case DataType::FLOAT32:
      {
        // Synced with record-minmax (-5,5)
        auto input_data = genRandomFloatData(num_elems, -5, 5);
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(float));
        break;
      }
      case DataType::U8:
      {
        auto input_data = genRandomIntData<uint8_t>(num_elems, std::numeric_limits<uint8_t>::min(),
                                                    std::numeric_limits<uint8_t>::max());
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(uint8_t));
        break;
      }
      case DataType::S16:
      {
        auto input_data = genRandomIntData<int16_t>(num_elems, std::numeric_limits<int16_t>::min(),
                                                    std::numeric_limits<int16_t>::max());
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(int16_t));
        break;
      }
      case DataType::S32:
      {
        // Synced with record-minmax (0, 100)
        auto input_data = genRandomIntData<int32_t>(num_elems, 0, 100);
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(int32_t));
        break;
      }
      case DataType::S64:
      {
        // Synced with record-minmax (0, 100)
        auto input_data = genRandomIntData<int64_t>(num_elems, 0, 100);
        _interpreter->writeInputTensor(input_node, input_data.data(),
                                       input_data.size() * sizeof(int64_t));
        break;
      }