SNPEWriter Class Reference

#include <EventWriter.h>

Collaboration diagram for SNPEWriter:

Public Member Functions
	SNPEWriter (const std::string &filepath)
	~SNPEWriter ()
void	flush (const std::vector< std::unique_ptr< EventRecorder > > &) override
Public Member Functions inherited from EventFormatWriter
	EventFormatWriter (const std::string &filepath)
virtual	~EventFormatWriter ()

Additional Inherited Members
Protected Attributes inherited from EventFormatWriter
std::ofstream	_os

Detailed Description

Definition at line 42 of file EventWriter.h.

Constructor & Destructor Documentation

SNPEWriter()

SNPEWriter::SNPEWriter ( const std::string &  filepath )

inline

Definition at line 45 of file EventWriter.h.

                                        : EventFormatWriter(filepath)
  { /* empty */
  }

~SNPEWriter()

SNPEWriter::~SNPEWriter ( )

inline

Definition at line 48 of file EventWriter.h.

{}

Member Function Documentation

flush()

void SNPEWriter::flush ( const std::vector< std::unique_ptr< EventRecorder > > &  recorders )

overridevirtual

Implements EventFormatWriter.

Definition at line 80 of file SNPEEventWriter.cc.

{
  struct Stat
  {
    uint64_t sum = 0;
    uint64_t count = 0;
    uint64_t max = 0;
    uint64_t min = std::numeric_limits<uint64_t>::max();
 
    void accumulate(uint64_t val)
    {
      sum += val;
      count++;
      max = std::max(max, val);
      min = std::min(min, val);
    }
  };
 
  Json::Value root;
  root["version"] = SNPE_JSON_SCHEMA_VERSION;
 
  auto &exec_data = root["Execution_Data"] = Json::Value{Json::objectValue};
 
  // Memory
  {
    std::unordered_map<std::string, Stat> mem_stats;
    for (const auto &recorder : recorders)
    {
      for (const auto &evt : recorder->counter_events())
      {
        auto &mem_stat = mem_stats[evt.name];
        uint64_t val = std::stoull(evt.values.at("value"));
        mem_stat.accumulate(val);
      }
    }
 
    auto &mem = exec_data["memory"] = Json::Value{Json::objectValue};
    for (const auto &[key, val] : mem_stats)
    {
      mem[key]["Avg_Size"] = val.sum / val.count;
      mem[key]["Max_Size"] = val.max;
      mem[key]["Min_Size"] = val.min;
      mem[key]["Runtime"] = "NA";
    }
  }
 
  // Operation Execution Time
  {
    // NOTE This assumes _duration_events is sorted by "ts" ascending
 
    // TODO: Apply Heterogeneous lookup for unordered containers (transparent hashing) since C++20
    //       to use `std::string_view` with lookup functions in unordered containers
    // 2D keys : stats[tid][name]
    std::unordered_map<std::string, std::unordered_map<std::string, Stat>> stats;
    std::unordered_map<std::string, std::unordered_map<std::string, uint64_t>> begin_timestamps;
    for (const auto &recorder : recorders)
    {
      for (const auto &evt : recorder->duration_events())
      {
        std::string evt_name = getLabel(*evt);
        std::string evt_tid = getBackend(*evt);
 
        auto &stat = stats[evt_tid][evt_name];
        auto &begin_ts = begin_timestamps[evt_tid][evt_name];
        uint64_t timestamp = std::stoull(evt->ts);
        if (evt->ph == "B")
        {
          if (begin_ts != 0)
            throw std::runtime_error{"Invalid Data"};
          begin_ts = timestamp;
        }
        else if (evt->ph == "E")
        {
          if (begin_ts == 0 || timestamp < begin_ts)
            throw std::runtime_error{"Invalid Data"};
          stat.accumulate(timestamp - begin_ts);
          begin_ts = 0;
        }
        else
          throw std::runtime_error{"Invalid Data - invalid value for \"ph\" : \"" + evt->ph + "\""};
      }
    }
 
    for (const auto &kv : begin_timestamps)
      for (const auto &kv2 : kv.second)
        if (kv2.second != 0)
          throw std::runtime_error{"Invalid Data - B and E pair does not match."};
 
    for (const auto &[tid, stat_map] : stats)
    {
      auto &json_tid = exec_data[tid] = Json::Value{Json::objectValue};
      for (const auto &[name, val] : stat_map)
      {
        json_tid[name]["Avg_Time"] = val.sum / val.count;
        json_tid[name]["Max_Time"] = val.max;
        json_tid[name]["Min_Time"] = val.min;
        json_tid[name]["Runtime"] = tid;
      }
    }
  }
 
  _os << root;
}

References EventFormatWriter::_os, and SNPE_JSON_SCHEMA_VERSION.

---

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

• runtime/onert/core/src/util/EventWriter.h
• runtime/onert/core/src/util/SNPEEventWriter.cc