update

[ROCm/rocprofiler commit: 0b0ce2d931]

projects/rocprofiler/src/core/intercept_queue.h

@@ -95,10 +95,11 @@ class InterceptQueue {
         rocprofiler_group_t group = {};
         const hsa_kernel_dispatch_packet_t* dispatch_packet =
             reinterpret_cast<const hsa_kernel_dispatch_packet_t*>(packet);
+        const char* kernel_name = GetKernelName(dispatch_packet);
         rocprofiler_callback_data_t data = {obj->agent_info_->dev_id, user_que_idx,
-                                            dispatch_packet->kernel_object,
-                                            GetKernelName(dispatch_packet)};
+                                            dispatch_packet->kernel_object, kernel_name};
         hsa_status_t status = on_dispatch_cb_(&data, on_dispatch_cb_data_, &group);
+        free(const_cast<char*>(kernel_name));
         if ((status == HSA_STATUS_SUCCESS) && (group.context != NULL)) {
           Context* context = reinterpret_cast<Context*>(group.context);
           const pkt_vector_t& start_vector = context->StartPackets(group.index);
@@ -151,7 +152,7 @@ class InterceptQueue {
     return (*header >> HSA_PACKET_HEADER_TYPE) & header_type_mask;
   }
 
-  static const char* GetKernelName(const hsa_kernel_dispatch_packet_t* dispatch_packet) {
+  static char* GetKernelName(const hsa_kernel_dispatch_packet_t* dispatch_packet) {
     const amd_kernel_code_t* kernel_code = NULL;
     hsa_status_t status =
         util::HsaRsrcFactory::Instance().LoaderApi()->hsa_ven_amd_loader_query_host_address(

projects/rocprofiler/src/core/metrics.h

@@ -55,6 +55,7 @@ class ExprMetric : public Metric {
  public:
   ExprMetric(const std::string& name, const counters_vec_t& counters, const xml::Expr* expr)
       : Metric(name), counters_(counters), expr_(expr) {}
+  ~ExprMetric() { delete expr_; }
   void GetCounters(counters_vec_t& vec) const {
     vec.insert(vec.end(), counters_.begin(), counters_.end());
   }

projects/rocprofiler/src/xml/expr.h

@@ -45,6 +45,10 @@ class bin_expr_t {
 
   bin_expr_t() : arg1_(NULL), arg2_(NULL) {}
   bin_expr_t(const bin_expr_t* arg1, const bin_expr_t* arg2) : arg1_(arg1), arg2_(arg2) {}
+  virtual ~bin_expr_t() {
+    if (arg1_) delete arg1_;
+    if (arg2_) delete arg2_;
+  }
 
   virtual args_t Eval(const args_cache_t& args) const = 0;
   virtual std::string Symbol() const = 0;
@@ -66,7 +70,8 @@ class bin_expr_t {
 class Expr {
  public:
   explicit Expr(const std::string& expr, const expr_cache_t* cache)
-      : expr_(expr), pos_(0), sub_count_(0), cache_(cache) {
+      : expr_(expr), pos_(0), sub_count_(0), cache_(cache), is_sub_expr_(false)
+  {
     sub_vec_ = new std::vector<const Expr*>;
     var_vec_ = new std::vector<std::string>;
     tree_ = ParseExpr();
@@ -78,17 +83,22 @@ class Expr {
         sub_count_(0),
         cache_(obj->cache_),
         sub_vec_(obj->sub_vec_),
-        var_vec_(obj->var_vec_) {
+        var_vec_(obj->var_vec_),
+        is_sub_expr_(true)
+  {
     sub_vec_->push_back(this);
     tree_ = ParseExpr();
     if (!SubCheck()) throw exception_t("expr '" + expr_ + "', bad parenthesis count");
   }
 
   ~Expr() {
-    delete cache_;
-    for (auto it : *sub_vec_) delete it;
-    delete sub_vec_;
-    delete var_vec_;
+    if (!is_sub_expr_) {
+      delete cache_;
+      for (auto it : *sub_vec_) delete it;
+      delete sub_vec_;
+      delete var_vec_;
+      delete tree_;
+    }
   }
 
   std::string GetStr() const { return expr_; }
@@ -204,6 +214,8 @@ class Expr {
     return str;
   }
 
+  static const bool div_zero_exc_on = false;
+
   const std::string expr_;
   unsigned pos_;
   unsigned sub_count_;
@@ -211,7 +223,7 @@ class Expr {
   const expr_cache_t* const cache_;
   std::vector<const Expr*>* sub_vec_;
   std::vector<std::string>* var_vec_;
-  static const bool div_zero_exc_on = false;
+  const bool is_sub_expr_;
 };
 
 class add_expr_t : public bin_expr_t {

projects/rocprofiler/src/xml/xml.h

@@ -33,7 +33,7 @@ class Xml {
   enum { DECL_STATE, BODY_STATE };
 
   static Xml* Create(const std::string& file_name, const Xml* obj = NULL) {
-    Xml* xml = new Xml(file_name.c_str(), obj);
+    Xml* xml = new Xml(file_name, obj);
     if (xml != NULL) {
       if (xml->Init() == false) {
         delete xml;
@@ -91,23 +91,45 @@ class Xml {
 
   nodes_t GetNodes(std::string global_tag) { return (*map_)[global_tag]; }
 
-  void Print() const {
-    std::cout << "XML file '" << file_name_ << "':" << std::endl;
-    for (auto& elem : *map_) {
-      for (auto node : elem.second) {
-        if (node->opts.size()) {
-          std::cout << elem.first << ":" << std::endl;
-          for (auto& opt : node->opts) {
-            std::cout << "  " << opt.first << " = " << opt.second << std::endl;
-          }
-        }
+  template <class F>
+  F ForEach(const F& f_i) {
+    F f = f_i;
+    for (auto& entry : *map_) {
+      for (auto node : entry.second) {
+        if (f.fun(entry.first, node) == false) break;
       }
     }
+    return f;
+  }
+
+  template <class F>
+  F ForEach(const F& f_i) const {
+    F f = f_i;
+    for (auto& entry : *map_) {
+      for (auto node : entry.second) {
+        if (f.fun(entry.first, node) == false) break;
+      }
+    }
+    return f;
+  }
+
+  struct print_func {
+    bool fun(const std::string& global_tag, level_t* node) {
+      for (auto& opt : node->opts) {
+        std::cout << global_tag << "." << opt.first << " = " << opt.second << std::endl;
+      }
+      return true;
+    }
+  };
+
+  void Print() const {
+    std::cout << "XML file '" << file_name_ << "':" << std::endl;
+    ForEach(print_func());
   }
 
  private:
-  Xml(const char* file_name, const Xml* obj)
-      : file_name_(strdup(file_name)),
+  Xml(const std::string& file_name, const Xml* obj)
+      : file_name_(file_name),
         file_line_(0),
         data_size_(0),
         index_(0),
@@ -124,12 +146,22 @@ class Xml {
     }
   }
 
+  struct delete_func {
+    bool fun(const std::string&, level_t* node) {
+      delete node;
+      return true;
+    }
+  };
+
   ~Xml() {
-    if (included_ == false) delete map_;
+    if (included_ == false) {
+      ForEach(delete_func());
+      delete map_;
+    }
   }
 
   bool Init() {
-    fd_ = open(file_name_, O_RDONLY);
+    fd_ = open(file_name_.c_str(), O_RDONLY);
     if (fd_ == -1) {
       perror((std::string("open XML file ") + file_name_).c_str());
       return false;
@@ -228,11 +260,11 @@ class Xml {
             } else
               token[i] = '\0';
 
-            const char* tag = strdup(&token[ind]);
+            const char* tag = &token[ind];
             if (node_begin) {
               AddLevel(tag);
             } else {
-              if (strncmp(CurrentLevel().c_str(), tag, strlen(tag))) {
+              if (strncmp(CurrentLevel().c_str(), tag, strlen(tag)) != 0) {
                 token.back() = '>';
                 BadFormat(token);
               }
@@ -373,7 +405,7 @@ class Xml {
 
   void AddOption(const std::string& key, const std::string& value) { level_->opts[key] = value; }
 
-  const char* file_name_;
+  const std::string file_name_;
   unsigned file_line_;
   int fd_;
 

projects/rocprofiler/test/ctrl/tool.cpp

@@ -47,6 +47,8 @@ struct context_entry_t {
 
 // Dispatch callbacks and context handlers synchronization
 pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+// Dispatch callback data
+dispatch_data_t* dispatch_data = NULL;
 // Stored contexts array
 typedef std::map<uint32_t, context_entry_t> context_array_t;
 context_array_t* context_array = NULL;
@@ -238,6 +240,7 @@ void dump_context(context_entry_t* entry) {
     std::ostringstream oss;
     oss << index << "__" << entry->data.kernel_name;
     output_results(file_handle, features, feature_count, group.context, oss.str().substr(0, KERNEL_NAME_LEN_MAX).c_str());
+    free(const_cast<char*>(entry->data.kernel_name));
   
     // Finishing cleanup
     // Deleting profiling context will delete all allocated resources
@@ -316,6 +319,7 @@ hsa_status_t dispatch_callback(const rocprofiler_callback_data_t* callback_data,
   entry->features = tool_data->features;
   entry->feature_count = tool_data->feature_count;
   entry->data = *callback_data;
+  entry->data.kernel_name = strdup(callback_data->kernel_name);
   entry->file_handle = tool_data->file_handle;
   entry->valid = 1;
 
@@ -471,13 +475,15 @@ CONSTRUCTOR_API void constructor()
 
   // Adding dispatch observer
   if (feature_count) {
-    dispatch_data_t* dispatch_data = new dispatch_data_t{};
+    dispatch_data = new dispatch_data_t{};
     dispatch_data->features = features;
     dispatch_data->feature_count = feature_count;
     dispatch_data->group_index = 0;
     dispatch_data->file_handle = result_file_handle;
     rocprofiler_set_dispatch_callback(dispatch_callback, dispatch_data);
   }
+
+  xml::Xml::Destroy(xml);
 }
 
 // Tool destructor
@@ -491,6 +497,13 @@ DESTRUCTOR_API void destructor() {
   // Dump stored profiling output data
   dump_context_array();
 
+  // Unregister dispatch callback and free callback data
+  rocprofiler_remove_dispatch_callback();
+  if (dispatch_data != NULL) {
+    delete[] dispatch_data->features;
+    delete dispatch_data;
+  }
+
   // Close output file
   if (result_file_opened) fclose(result_file_handle);
 }

projects/rocprofiler/test/util/xml.h

@@ -1,5 +1,5 @@
-#ifndef TEST_UTIL_XML_H_
-#define TEST_UTIL_XML_H_
+#ifndef SRC_XML_XML_H_
+#define SRC_XML_XML_H_
 
 #include <fcntl.h>
 #include <stdio.h>
@@ -18,60 +18,211 @@ namespace xml {
 class Xml {
  public:
   typedef std::vector<char> token_t;
+
+  struct level_t;
+  typedef std::vector<level_t*> nodes_t;
+  typedef std::map<std::string, std::string> opts_t;
   struct level_t {
     std::string tag;
-    std::vector<level_t*> nodes;
-    std::map<std::string, std::string> opts;
+    nodes_t nodes;
+    opts_t opts;
   };
   typedef std::vector<level_t*> nodes_vec_t;
+  typedef std::map<std::string, nodes_vec_t> map_t;
 
   enum { DECL_STATE, BODY_STATE };
 
-  static Xml* Create(const char* file_name) {
-    Xml* xml = new Xml(file_name);
-    if (xml->fd_ == -1) {
-      delete xml;
-      xml = NULL;
+  static Xml* Create(const std::string& file_name, const Xml* obj = NULL) {
+    Xml* xml = new Xml(file_name, obj);
+    if (xml != NULL) {
+      if (xml->Init() == false) {
+        delete xml;
+        xml = NULL;
+      } else {
+        const std::size_t pos = file_name.rfind('/');
+        const std::string path = (pos != std::string::npos) ? file_name.substr(0, pos + 1) : "";
+
+        xml->PreProcess();
+        nodes_t incl_nodes;
+        for (auto* node : xml->GetNodes("top.include")) {
+          if (node->opts.find("touch") == node->opts.end()) {
+            node->opts["touch"] = "";
+            incl_nodes.push_back(node);
+          }
+        }
+        for (auto* incl : incl_nodes) {
+          const std::string& incl_name = path + incl->opts["file"];
+          Xml *ixml = Create(incl_name, xml);
+          if (ixml == NULL) {
+            delete xml;
+            xml = NULL;
+            break;
+          } else {
+            delete(ixml);
+          }
+        }
+        if (xml) {
+          xml->Process();
+        }
+      }
     }
+
     return xml;
   }
 
   static void Destroy(Xml *xml) { delete xml; }
 
-  std::vector<level_t*> GetNodes(std::string global_tag) { return map_[global_tag]; }
+  void AddExpr(const std::string& full_tag, const std::string& name, const std::string& expr) {
+    const std::size_t pos = full_tag.rfind('.');
+    const std::size_t pos1 = (pos == std::string::npos) ? 0 : pos + 1;
+    const std::string level_tag = full_tag.substr(pos1);
+    level_t* level = new level_t;
+    (*map_)[full_tag].push_back(level);
+    level->tag = level_tag;
+    level->opts["name"] = name;
+    level->opts["expr"] = expr;
+  }
+
+  void AddConst(const std::string& full_tag, const std::string& name, const uint64_t& val) {
+    std::ostringstream oss;
+    oss << val;
+    AddExpr(full_tag, name, oss.str());
+  }
+
+  nodes_t GetNodes(std::string global_tag) { return (*map_)[global_tag]; }
+
+  template <class F>
+  F ForEach(const F& f_i) {
+    F f = f_i;
+    for (auto& entry : *map_) {
+      for (auto node : entry.second) {
+        if (f.fun(entry.first, node) == false) break;
+      }
+    }
+    return f;
+  }
+
+  template <class F>
+  F ForEach(const F& f_i) const {
+    F f = f_i;
+    for (auto& entry : *map_) {
+      for (auto node : entry.second) {
+        if (f.fun(entry.first, node) == false) break;
+      }
+    }
+    return f;
+  }
+
+  struct print_func {
+    bool fun(const std::string& global_tag, level_t* node) {
+      for (auto& opt : node->opts) {
+        std::cout << global_tag << "." << opt.first << " = " << opt.second << std::endl;
+      }
+      return true;
+    }
+  };
 
   void Print() const {
     std::cout << "XML file '" << file_name_ << "':" << std::endl;
-    for (auto& elem : map_) {
-      for (auto node : elem.second) {
-        if (node->opts.size()) {
-          std::cout << elem.first << ":" << std::endl;
-          for (auto& opt : node->opts) {
-            std::cout << "  " << opt.first << " = " << opt.second << std::endl;
-          }
-        }
-      }
-    }
+    ForEach(print_func());
   }
 
  private:
-  Xml(const char* file_name)
+  Xml(const std::string& file_name, const Xml* obj)
       : file_name_(file_name),
         file_line_(0),
         data_size_(0),
         index_(0),
         state_(BODY_STATE),
+        comment_(false),
+        included_(false),
         level_(NULL),
-        comment_(false) {
-    AddLevel("top");
+        map_(NULL)
+  {
+    if (obj != NULL) {
+      map_ = obj->map_;
+      level_ = obj->level_;
+      included_ = true;
+    }
+  }
 
-    fd_ = open(file_name, O_RDONLY);
+  struct delete_func {
+    bool fun(const std::string&, level_t* node) {
+      delete node;
+      return true;
+    }
+  };
+
+  ~Xml() {
+    if (included_ == false) {
+      ForEach(delete_func());
+      delete map_;
+    }
+  }
+
+  bool Init() {
+    fd_ = open(file_name_.c_str(), O_RDONLY);
     if (fd_ == -1) {
-      perror("open XML file");
-      return;
+      perror((std::string("open XML file ") + file_name_).c_str());
+      return false;
     }
 
+    if (map_ == NULL) {
+      map_ = new map_t;
+      if (map_ == NULL) return false;
+      AddLevel("top");
+    }
+
+    return true;
+  }
+
+  void PreProcess() {
+    uint32_t ind = 0;
+    const uint32_t buf_size = 128;
+    char buf[buf_size];
+    bool error = false;
+
+    while (1) {
+      const uint32_t pos = lseek(fd_, 0, SEEK_CUR);
+      uint32_t size = read(fd_, buf, buf_size);
+      if (size <= 0) break;
+      buf[size - 1] = '\0';
+
+      if (strncmp(buf, "#include \"", 10) == 0) {
+        for (ind = 0; (ind < size) && (buf[ind] != '\n'); ++ind);
+        if (ind == size) {
+          fprintf(stderr, "XML PreProcess failed, line size limit %d\n", (int)buf_size);
+          error = true;
+          break;
+        }
+        buf[ind] = '\0';
+        size = ind;
+        lseek(fd_, pos + ind + 1, SEEK_SET);
+
+        for (ind = 10; (ind < size) && (buf[ind] != '"'); ++ind);
+        if (ind == size) {
+          error = true;
+          break;
+        }
+        buf[ind] = '\0';
+
+        AddLevel("include");
+        AddOption("file", &buf[10]);
+        UpLevel();
+      }
+    }
+
+    if (error) {
+      fprintf(stderr, "XML PreProcess failed, line '%s'\n", buf);
+      exit(1);
+    }
+
+    lseek(fd_, 0, SEEK_SET);
+  }
+
+  void Process() {
     token_t remainder;
+
     while (1) {
       token_t token = (remainder.size()) ? remainder : NextToken();
       remainder.clear();
@@ -109,11 +260,11 @@ class Xml {
             } else
               token[i] = '\0';
 
-            const char* tag = strdup(&token[ind]);
+            const char* tag = &token[ind];
             if (node_begin) {
               AddLevel(tag);
             } else {
-              if (strncmp(CurrentLevel().c_str(), tag, strlen(tag))) {
+              if (strncmp(CurrentLevel().c_str(), tag, strlen(tag)) != 0) {
                 token.back() = '>';
                 BadFormat(token);
               }
@@ -140,14 +291,12 @@ class Xml {
           }
           break;
         default:
-          std::cout << "Wrong state: " << state_ << std::endl;
+          std::cout << "XML parser error: wrong state: " << state_ << std::endl;
           exit(1);
       }
     }
   }
 
-  ~Xml() {}
-
   bool SpaceCheck() const {
     bool cond = ((buffer_[index_] == ' ') || (buffer_[index_] == '	'));
     return cond;
@@ -244,7 +393,7 @@ class Xml {
       global_tag += level->tag + ".";
     }
     global_tag += tag;
-    map_[global_tag].push_back(level_);
+    (*map_)[global_tag].push_back(level_);
   }
 
   void UpLevel() {
@@ -256,20 +405,23 @@ class Xml {
 
   void AddOption(const std::string& key, const std::string& value) { level_->opts[key] = value; }
 
-  const char* file_name_;
+  const std::string file_name_;
   unsigned file_line_;
   int fd_;
+
   static const unsigned buf_size_ = 256;
   char buffer_[buf_size_];
+
   unsigned data_size_;
   unsigned index_;
   unsigned state_;
-  level_t* level_;
-  std::vector<level_t*> stack_;
-  std::map<std::string, nodes_vec_t> map_;
   bool comment_;
+  std::vector<level_t*> stack_;
+  bool included_;
+  level_t* level_;
+  map_t* map_;
 };
 
 }  // namespace xml
 
-#endif  // TEST_UTIL_XML_H_
+#endif  // SRC_XML_XML_H_