Merge branch 'master' into feature/optimize_yolo

Author: xhuohai

src/Native/include/nncase/runtime/stackvm/op_profile.h

@@ -14,23 +14,38 @@
  */
 #pragma once
 #include "opcode.h"
-#include <chrono>
 #include <iomanip>
-#include <iostream>
-#include <tuple>
 #include <vector>
 
+#if defined(LINUX_RUNTIME)
+#include <chrono>
+#endif
+
 using namespace nncase::runtime::stackvm;
 
+#if defined(NNCASE_BAREMETAL)
 extern "C" {
 double get_ms_time();
 }
+#endif
+
+struct OpInfo {
+    uint8_t type;
+    const char *name;
+    double begin;
+    double end;
+    OpInfo(uint8_t t, const char *n, double s, double e)
+        : type(t), name(n), begin(s), end(e) {}
+};
 
 class op_profile {
   public:
     op_profile(opcode_t opcode, uint8_t enable_profiling = 1)
         : active_(enable_profiling) {
         if (active_) {
+            if (op_timing_.empty()) {
+                op_timing_.reserve(256);
+            }
             op_type_ = (uint8_t)opcode;
             op_name_ = to_string(opcode);
             begin_ = get_time();
@@ -41,6 +56,9 @@ class op_profile {
                uint8_t enable_profiling = 1)
         : active_(enable_profiling) {
         if (active_) {
+            if (op_timing_.empty()) {
+                op_timing_.reserve(256);
+            }
             op_type_ = (uint8_t)opcode;
             op_name_ = to_string(tensor_funct);
             begin_ = get_time();
@@ -50,16 +68,14 @@ class op_profile {
     ~op_profile() {
         if (active_) {
             end_ = get_time();
-            op_timing_.push_back(
-                std::make_tuple(op_name_, op_type_, begin_, end_));
+            op_timing_.emplace_back(op_type_, op_name_, begin_, end_);
         }
     }
 
     static void print();
 
   public:
-    static std::vector<std::tuple<std::string, uint8_t, double, double>>
-        op_timing_;
+    static std::vector<OpInfo> op_timing_;
 
   private:
     double get_time() {
@@ -78,7 +94,7 @@ class op_profile {
   private:
     double begin_;
     double end_;
-    std::string op_name_;
+    const char *op_name_;
     uint8_t op_type_;
     uint8_t active_;
 };

src/Native/include/nncase/runtime/stackvm/opcode.h

@@ -843,7 +843,7 @@ struct tensor_where_op_t {
     bool is_tf_where;
 };
 
-inline std::string to_string(tensor_function_t tensor_funct) {
+inline const char *to_string(tensor_function_t tensor_funct) {
     switch (tensor_funct) {
     case tensor_function_t::batch_normalization:
         return "batch_normalization";
@@ -1039,7 +1039,7 @@ inline std::string to_string(tensor_function_t tensor_funct) {
     return "unknown tensor_function_t";
 }
 
-inline std::string to_string(opcode_t code) {
+inline const char *to_string(opcode_t code) {
     switch (code) {
     case opcode_t::NOP:
         return "NOP";

src/Native/src/runtime/stackvm/op_profile.cpp

@@ -14,17 +14,17 @@
  */
 
 #include <algorithm>
+#include <iostream>
 #include <map>
 #include <nncase/runtime/stackvm/op_profile.h>
 #include <unordered_map>
 #include <vector>
 
-std::vector<std::tuple<std::string, uint8_t, double, double>>
-    op_profile::op_timing_;
+std::vector<OpInfo> op_profile::op_timing_;
 
 void op_profile::print() {
-    std::map<std::string, double> op_timing;
-    std::unordered_map<std::string, size_t> op_count;
+    std::map<const char *, double> op_timing;
+    std::unordered_map<const char *, size_t> op_count;
 
     std::cout << "stack OPs timeline" << std::endl;
     std::cout << "|" << std::setw(24) << std::left << "stackvm tensor op"
@@ -39,7 +39,11 @@ void op_profile::print() {
               << "|" << std::setw(24) << std::left << "---"
               << "|" << std::endl;
     double init_timing = -1;
-    for (auto &&[op_name, op_type, begin, end] : op_timing_) {
+    for (auto op_info : op_timing_) {
+        uint8_t op_type = op_info.type;
+        const char *op_name = op_info.name;
+        double begin = op_info.begin;
+        double end = op_info.end;
         if (init_timing == -1) {
             init_timing = begin;
         }
@@ -61,17 +65,19 @@ void op_profile::print() {
     }
 
     double total = 0.f;
-    std::vector<std::pair<std::string, double>> v;
+    std::vector<std::pair<const char *, double>> v;
+    v.reserve(op_timing.size());
     for (auto e : op_timing) {
         total += e.second;
         v.push_back(e);
     }
     std::cout << std::endl;
 
-    std::sort(
-        v.begin(), v.end(),
-        [=](std::pair<std::string, double> &a,
-            std::pair<std::string, double> &b) { return a.second > b.second; });
+    std::sort(v.begin(), v.end(),
+              [=](std::pair<const char *, double> &a,
+                  std::pair<const char *, double> &b) {
+                  return a.second > b.second;
+              });
 
     std::cout << "stackvm OPs profile" << std::endl;
     std::cout << "|" << std::setw(24) << std::left << "stackvm tensor op"