File reorganization

Move the tracer_tool from the 'test' directory to the 'src' directory. Change-Id: I13768b9610cd359f78a66147f0255ab1e4c657e9
2022-05-20 10:36:38 -07:00
@@ -113,7 +113,24 @@ add_custom_command(

 # Build the ROCtracer library

-file(GLOB ROCTRACER_SOURCES "src/core/*.cpp" "src/util/*.cpp")
+file(GLOB ROCTRACER_SOURCES "src/roctracer/*.cpp" "src/util/*.cpp")
+
+set(PUBLIC_HEADERS
+    roctx.h
+    roctracer.h
+    roctracer_ext.h
+    roctracer_hip.h
+    roctracer_hcc.h
+    roctracer_hsa.h
+    roctracer_roctx.h
+    ext/prof_protocol.h
+)
+
+set(GEN_HEADERS
+    hip_ostream_ops.h
+    hsa_prof_str.h
+    hsa_ostream_ops.h
+)

 add_library(roctracer ${LIBRARY_TYPE}
    ${ROCTRACER_SOURCES}
@@ -125,7 +142,7 @@ add_library(roctracer ${LIBRARY_TYPE}
 set_target_properties(roctracer PROPERTIES
    CXX_VISIBILITY_PRESET hidden
    OUTPUT_NAME "roctracer64"
-    LINK_DEPENDS core.exportmap
+    LINK_DEPENDS roctracer.exportmap
    VERSION ${ROCTRACER_VERSION}
    SOVERSION ${ROCTRACER_VERSION_MAJOR}
 )
@@ -144,15 +161,15 @@ target_include_directories(roctracer
    ${HIP_INCLUDE_DIRECTORIES} ${HSA_RUNTIME_INCLUDE_DIRECTORIES}
  PRIVATE
    ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${PROJECT_SOURCE_DIR}/src
-    ${PROJECT_BINARY_DIR}/inc
+    ${PROJECT_SOURCE_DIR}/src/roctracer ${PROJECT_BINARY_DIR}/inc
 )

-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/core/exportmap.in core.exportmap @ONLY)
-target_link_options(roctracer PRIVATE -Wl,--version-script=core.exportmap -Wl,--no-undefined)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/roctracer/exportmap.in roctracer.exportmap @ONLY)
+target_link_options(roctracer PRIVATE -Wl,--version-script=roctracer.exportmap -Wl,--no-undefined)

 target_link_libraries(roctracer PRIVATE hsa-runtime64::hsa-runtime64 Threads::Threads dl)

-install(TARGETS ${ROCTRACER_TARGET} LIBRARY DESTINATION lib)
+install(TARGETS roctracer LIBRARY DESTINATION lib)
 foreach(header ${PUBLIC_HEADERS})
    get_filename_component(header_subdir ${header} DIRECTORY)
    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/inc/${header} DESTINATION include/${ROCTRACER_NAME}/${header_subdir})
@@ -178,7 +195,7 @@ set_target_properties(roctx PROPERTIES
 )

 target_include_directories(roctx PRIVATE
-    ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc
+    ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${PROJECT_SOURCE_DIR}/src/roctracer
    ${PROJECT_SOURCE_DIR}/src
 )

@@ -186,3 +203,33 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/roctx/exportmap.in roctx.exportma
 target_link_options(roctx PRIVATE -Wl,--version-script=roctx.exportmap -Wl,--no-undefined)

 install(TARGETS roctx LIBRARY DESTINATION lib)
+
+## Build the tracer_tool library
+
+if (${LIBRARY_TYPE} STREQUAL SHARED)
+
+file(GLOB TRACER_TOOL_SOURCES "src/tracer_tool/*.cpp" "src/util/*.cpp")
+
+add_library(roctracer_tool SHARED ${TRACER_TOOL_SOURCES})
+
+set_target_properties(roctracer_tool PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+    LINK_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/tracer_tool/exportmap
+)
+
+target_compile_definitions(roctracer_tool PRIVATE
+    HIP_PROF_HIP_API_STRING=1
+    __HIP_PLATFORM_HCC__=1
+)
+
+target_include_directories(roctracer_tool PRIVATE
+    ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${PROJECT_SOURCE_DIR}/src/roctracer
+    ${PROJECT_SOURCE_DIR}/src ${HIP_INCLUDE_DIRECTORIES} ${GEN_INC_DIR}
+)
+
+target_link_libraries(roctracer_tool roctracer hsa-runtime64::hsa-runtime64 Threads::Threads atomic dl)
+target_link_options(roctracer_tool PRIVATE -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/src/tracer_tool/exportmap -Wl,--no-undefined)
+
+install(TARGETS roctracer_tool LIBRARY DESTINATION lib/${ROCTRACER_NAME})
+
+endif()
@@ -21,7 +21,7 @@
 #ifndef CALLBACK_TABLE_H_
 #define CALLBACK_TABLE_H_

-#include <ext/prof_protocol.h>
+#include "ext/prof_protocol.h"

 #include <array>
 #include <atomic>
@@ -18,11 +18,11 @@
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE. */

-#include "inc/roctracer.h"
-#include "inc/roctracer_hip.h"
-#include "inc/roctracer_ext.h"
-#include "inc/roctracer_roctx.h"
-#include "inc/roctracer_hsa.h"
+#include "roctracer.h"
+#include "roctracer_hip.h"
+#include "roctracer_ext.h"
+#include "roctracer_roctx.h"
+#include "roctracer_hsa.h"

 #include <assert.h>
 #include <dirent.h>
@@ -36,10 +36,10 @@
 #include <unordered_map>
 #include <vector>

-#include "core/journal.h"
-#include "core/loader.h"
-#include "core/memory_pool.h"
-#include "core/tracker.h"
+#include "journal.h"
+#include "loader.h"
+#include "memory_pool.h"
+#include "tracker.h"
 #include "util/exception.h"
 #include "util/logger.h"

@@ -18,13 +18,13 @@
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE. */

-#include "inc/roctx.h"
-#include "inc/roctracer_roctx.h"
+#include "roctx.h"
+#include "roctracer_roctx.h"
+#include "ext/prof_protocol.h"

 #include <cassert>

-#include "inc/ext/prof_protocol.h"
-#include "core/callback_table.h"
+#include "callback_table.h"
 #include "util/exception.h"
 #include "util/logger.h"

@@ -0,0 +1,115 @@
+/* Copyright (c) 2018-2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#ifndef EVT_STATS_H_
+#define EVT_STATS_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <set>
+#include <sstream>
+#include <utility>
+
+template <class evt_id_t, class evt_weight_t> class EvtStatsT {
+ public:
+  typedef std::mutex mutex_t;
+  typedef uint64_t evt_count_t;
+  typedef double evt_avr_t;
+  struct evt_record_t {
+    uint64_t count;
+    evt_avr_t avr;
+    evt_record_t() : count(0), avr(0) {}
+  };
+  typedef typename std::map<evt_id_t, evt_record_t> map_t;
+  typedef typename std::map<evt_id_t, const char*> labels_t;
+
+  // Comparison function
+  struct cmpfun {
+    template <typename T> bool operator()(const T& a, const T& b) const {
+      return (a.second.avr != b.second.avr) ? a.second.avr < b.second.avr : a.first < b.first;
+    }
+  };
+
+  inline void add_event(evt_id_t id, evt_weight_t weight) {
+    std::lock_guard<mutex_t> lck(mutex_);
+    // printf("EvtStats %p ::add_event %u %lu\n", this, id, weight); fflush(stdout);
+
+    evt_record_t& rec = map_[id];
+    const evt_count_t prev_count = rec.count;
+    const evt_count_t new_count = prev_count + 1;
+    const evt_avr_t prev_avr = rec.avr;
+    const evt_avr_t new_avr = ((prev_avr * prev_count) + weight) / new_count;
+
+    rec.count = new_count;
+    rec.avr = new_avr;
+  }
+
+  void dump() {
+    std::lock_guard<mutex_t> lck(mutex_);
+    fprintf(stdout, "Dumping %s\n", path_);
+    fflush(stdout);
+
+    typedef typename std::set<std::pair<evt_id_t, evt_record_t>, cmpfun> set_t;
+    set_t s_(map_.begin(), map_.end());
+
+    uint64_t index = 0;
+    for (auto& e : s_) {
+      const evt_id_t id = e.first;
+      const char* label = get_label(id);
+      std::ostringstream oss;
+      oss << index << ",\"" << label << "\"," << e.second.count << "," << (uint64_t)(e.second.avr)
+          << "," << (uint64_t)(e.second.count * e.second.avr);
+      fprintf(fdes_, "%s\n", oss.str().c_str());
+      index += 1;
+    }
+
+    fclose(fdes_);
+  }
+
+  const char* get_label(const uint32_t& id) {
+    auto ret = labels_.insert({id, NULL});
+    const char* label = ret.first->second;
+    return label;
+  }
+  const char* get_label(const char* id) { return id; }
+  const char* get_label(const std::string& id) { return id.c_str(); }
+
+  void set_label(evt_id_t id, const char* label) {
+    // printf("EvtStats %p ::set_label %u %s\n", this, id, label); fflush(stdout);
+    labels_[id] = label;
+  }
+
+  EvtStatsT(FILE* f, const char* path) : fdes_(f), path_(path) {
+    // printf("EvtStats %p ::EvtStatsT()\n", this); fflush(stdout);
+    fprintf(fdes_, "Index,Name,Count,Avr,Total\n");
+  }
+
+ private:
+  mutex_t mutex_;
+  map_t map_;
+  labels_t labels_;
+  FILE* fdes_;
+  const char* path_;
+};
+
+typedef EvtStatsT<uint32_t, uint64_t> EvtStats;
+
+#endif  // EVT_STATS_H_
@@ -0,0 +1 @@
+{ global: OnLoad; OnUnload; local: *; };
@@ -0,0 +1,270 @@
+/* Copyright (c) 2018-2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#ifndef TOOL_TRACE_BUFFER_H_
+#define TOOL_TRACE_BUFFER_H_
+
+#include <atomic>
+#include <cassert>
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <iostream>
+#include <list>
+#include <mutex>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <thread>
+
+namespace roctracer {
+
+class TraceBufferBase {
+ public:
+  static void FlushAll() {
+    std::lock_guard lock(mutex_);
+
+    for (auto* trace_buffer = head_; trace_buffer != nullptr; trace_buffer = trace_buffer->next_)
+      trace_buffer->Flush();
+  }
+
+  static void Push(TraceBufferBase* elem) {
+    std::lock_guard lock(mutex_);
+
+    auto** prev_ptr = &head_;
+    while (*prev_ptr != nullptr && elem->priority_ > (*prev_ptr)->priority_)
+      prev_ptr = &(*prev_ptr)->next_;
+
+    elem->next_ = *prev_ptr;
+    *prev_ptr = elem;
+  }
+
+  TraceBufferBase(std::string name, int priority)
+      : name_(std::move(name)), priority_(priority), next_(nullptr) {}
+
+  TraceBufferBase(const TraceBufferBase&) = delete;
+  TraceBufferBase& operator=(const TraceBufferBase&) = delete;
+
+  virtual void Flush() = 0;
+
+  std::string name() && { return std::move(name_); }
+  const std::string& name() const& { return name_; }
+
+ private:
+  const std::string name_;
+  const int priority_;
+  TraceBufferBase* next_;
+
+  static TraceBufferBase* head_;
+  static std::mutex mutex_;
+};
+
+enum TraceEntryState { TRACE_ENTRY_INVALID = 0, TRACE_ENTRY_INIT = 1, TRACE_ENTRY_COMPLETE = 2 };
+
+template <typename Entry, typename Allocator = std::allocator<Entry>>
+class TraceBuffer : protected TraceBufferBase {
+ public:
+  using callback_t = std::function<void(Entry*)>;
+
+  TraceBuffer(std::string name, uint64_t size, callback_t flush_callback, int priority = 0)
+      : TraceBufferBase(std::move(name), priority),
+        flush_callback_(std::move(flush_callback)),
+        size_(size) {
+    assert(size_ != 0 && "cannot create an empty trace buffer");
+
+    Entry* write_buffer = allocator_.allocate(size_);
+    assert(write_buffer != nullptr);
+    buffer_list_.push_back(write_buffer);
+
+    read_index_ = 0;
+    write_index_ = {0, write_buffer};
+
+    AllocateFreeBuffer();
+
+    // Add this instance to the link list of all trace buffers in the process.
+    TraceBufferBase::Push(this);
+  }
+
+  ~TraceBuffer() {
+    // Flush the remaining records. After flushing, there should not be any records left in the
+    // trace buffer.
+    Flush();
+    assert(read_index_ == write_index_.load().index);
+
+    // Acquire both the writer and worker lock as we are accessing shared variables they protect.
+    std::unique_lock writer_lock(write_mutex_, std::defer_lock);
+    std::unique_lock worker_lock(worker_mutex_, std::defer_lock);
+    std::lock(writer_lock, worker_lock);
+
+    // Deallocate the buffers.
+    allocator_.deallocate(write_index_.load().buffer, size_);
+    allocator_.deallocate(free_buffer_, size_);
+
+    // Stop the worker thread. The worker thread loop checks the 'worker_thread_' std::optional
+    // after waking up, and exits if it does not have a value.
+    if (worker_thread_) {
+      std::thread worker_thread = std::move(worker_thread_.value());
+      {
+        // Tell the worker thread loop to exit.
+        worker_thread_.reset();
+        free_buffer_ = nullptr;
+        worker_cond_.notify_one();
+      }
+      // Release the worker lock to allow the worker thread to exit.
+      worker_lock.unlock();
+      worker_thread.join();
+    }
+  }
+
+  Entry* GetEntry() {
+    auto current = write_index_.load(std::memory_order_relaxed);
+
+    while (true) {
+      // If the pointer is at the end of the current buffer, switch to the available free buffer and
+      // notify the worker thread to allocate a new buffer.
+      if (current.index != 0 && current.index % size_ == 0) {
+        std::lock_guard lock(write_mutex_);
+
+        // If the worker thread wasn't already started, start it now. This avoids starting a new
+        // thread when the trace buffer is created.
+        if (!worker_thread_) {
+          std::promise<void> ready;
+          auto future = ready.get_future();
+          {
+            std::lock_guard worker_lock(worker_mutex_);
+            worker_thread_.emplace(&TraceBuffer::WorkerThreadLoop, this, std::move(ready));
+          }
+          future.wait();
+        }
+
+        // Re-check the pointer overflow under the writer lock, another thread could have beaten us
+        // to it and already bumped the write_index_.
+        current = write_index_.load(std::memory_order_relaxed);
+        if (current.index % size_ == 0) {
+          std::unique_lock worker_lock(worker_mutex_);
+
+          // Wait for the free buffer to become available.
+          worker_cond_.wait(worker_lock, [this]() { return free_buffer_ != nullptr; });
+
+          current.buffer = free_buffer_;
+          buffer_list_.push_back(current.buffer);
+          write_index_.store({current.index + 1, current.buffer}, std::memory_order_relaxed);
+
+          // Tell the worker thread to allocate a new free buffer.
+          free_buffer_ = nullptr;
+          worker_cond_.notify_one();
+
+          // We successfully allocated a new buffer, return the first element.
+          return &current.buffer[0];
+        }
+      }
+
+      if (write_index_.compare_exchange_weak(current, {current.index + 1, current.buffer},
+                                             std::memory_order_relaxed))
+        return &current.buffer[current.index % size_];
+    }
+  }
+
+  // Flush all entries between read_pointer and write_pointer. read_pointer and write_pointer are
+  // monotonically increasing indices, with read_pointer % size always indexing inside the first
+  // buffer in the list. Stop flushing if an incomplete entry is found, it will be flushed with
+  // the next invocation after changing its state to 'complete'.
+  void Flush() override {
+    std::lock_guard lock(write_mutex_);
+    auto write_index = write_index_.load(std::memory_order_relaxed);
+
+    for (auto it = buffer_list_.begin(); it != buffer_list_.end();) {
+      auto end_of_buffer = read_index_ - read_index_ % size_ + size_;
+
+      while (read_index_ < std::min(write_index.index, end_of_buffer)) {
+        Entry* entry = &(*it)[read_index_ % size_];
+
+        // The entry is not yet complete, stop flushing here.
+        if (entry->valid.load(std::memory_order_acquire) != TRACE_ENTRY_COMPLETE) return;
+
+        flush_callback_(entry);
+        ++read_index_;
+      }
+
+      // The buffer is still in use or the read pointer did not reach the end of the buffer.
+      if (*it == write_index.buffer || read_index_ != end_of_buffer) return;
+
+      // All entries in the current buffer are now processed. Destroy the buffer and move onto the
+      // next buffer in the list.
+      allocator_.deallocate(*it, size_);
+      it = buffer_list_.erase(it);
+    }
+  }
+
+ private:
+  void AllocateFreeBuffer() {
+    assert(free_buffer_ == nullptr);
+
+    free_buffer_ = allocator_.allocate(size_);
+    assert(free_buffer_ != nullptr);
+
+    for (size_t i = 0; i < size_; ++i)
+      free_buffer_[i].valid.store(TRACE_ENTRY_INVALID, std::memory_order_relaxed);
+  }
+
+  void WorkerThreadLoop(std::promise<void> ready) {
+    std::unique_lock lock(worker_mutex_);
+
+    // This worker thread is now ready to accept work.
+    ready.set_value();
+
+    while (true) {
+      worker_cond_.wait(lock, [this]() { return free_buffer_ == nullptr; });
+      if (!worker_thread_) break;
+      AllocateFreeBuffer();
+      worker_cond_.notify_one();
+    }
+  }
+
+  // The WriteIndex is used to store both the index and the buffer associated with that index (the
+  // buffer contains the trace buffer records at [index - index % size, index - index % size_t +
+  // size_ - 1]) in a single atomic variable.
+  struct WriteIndex {
+    uint64_t index;
+    Entry* buffer;
+  };
+
+  const callback_t flush_callback_;
+  const uint64_t size_;
+
+  uint64_t read_index_;                  // The index of the next record to flush.
+  std::atomic<WriteIndex> write_index_;  // The index of the next record that could be written.
+  Entry* free_buffer_{nullptr};          // The next available free buffer.
+
+  std::optional<std::thread> worker_thread_;
+  std::mutex worker_mutex_;
+  std::condition_variable worker_cond_;
+
+  std::mutex write_mutex_;
+  std::list<Entry*> buffer_list_;
+  Allocator allocator_;
+};
+}  // namespace roctracer
+
+#define TRACE_BUFFER_INSTANTIATE()                                                                 \
+  roctracer::TraceBufferBase* roctracer::TraceBufferBase::head_ = nullptr;                         \
+  std::mutex roctracer::TraceBufferBase::mutex_;
+
+#endif  // TOOL_TRACE_BUFFER_H_
@@ -0,0 +1,457 @@
+/* Copyright (c) 2018-2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#ifndef TEST_UTIL_XML_H_
+#define TEST_UTIL_XML_H_
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <string>
+#include <vector>
+
+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;
+    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 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::string GetName() { return file_name_; }
+
+  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(const std::string& global_tag) { return (*map_)[global_tag]; }
+
+  template <class F> F ForEach(const F& f_i) {
+    F f = f_i;
+    if (map_) {
+      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;
+    if (map_) {
+      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 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),
+        map_(NULL) {
+    if (obj != NULL) {
+      map_ = obj->map_;
+      level_ = obj->level_;
+      included_ = true;
+    }
+  }
+
+  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((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;
+    char buf[kBufSize];
+    bool error = false;
+
+    while (1) {
+      const uint32_t pos = lseek(fd_, 0, SEEK_CUR);
+      uint32_t size = read(fd_, buf, kBufSize);
+      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 %zu\n", kBufSize);
+          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();
+
+      //      token_t token1 = token;
+      //      token1.push_back('\0');
+      //      std::cout << "> " << &token1[0] << std::endl;
+
+      // End of file
+      if (token.size() == 0) break;
+
+      switch (state_) {
+        case BODY_STATE:
+          if (token[0] == '<') {
+            bool node_begin = true;
+            unsigned ind = 1;
+            if (token[1] == '/') {
+              node_begin = false;
+              ++ind;
+            }
+
+            unsigned i = ind;
+            while (i < token.size()) {
+              if (token[i] == '>') break;
+              ++i;
+            }
+            for (unsigned j = i + 1; j < token.size(); ++j) remainder.push_back(token[j]);
+
+            if (i == token.size()) {
+              if (node_begin)
+                state_ = DECL_STATE;
+              else
+                BadFormat(token);
+              token.push_back('\0');
+            } else {
+              token[i] = '\0';
+            }
+
+            const char* tag = &token[ind];
+            if (node_begin) {
+              AddLevel(tag);
+            } else {
+              if (strncmp(CurrentLevel().c_str(), tag, strlen(tag)) != 0) {
+                token.back() = '>';
+                BadFormat(token);
+              }
+              UpLevel();
+            }
+          } else {
+            BadFormat(token);
+          }
+          break;
+        case DECL_STATE:
+          if (token[0] == '>') {
+            state_ = BODY_STATE;
+            for (unsigned j = 1; j < token.size(); ++j) remainder.push_back(token[j]);
+            continue;
+          } else {
+            token.push_back('\0');
+            unsigned j = 0;
+            for (j = 0; j < token.size(); ++j)
+              if (token[j] == '=') break;
+            if (j == token.size()) BadFormat(token);
+            token[j] = '\0';
+            const char* key = &token[0];
+            const char* value = &token[j + 1];
+            AddOption(key, value);
+          }
+          break;
+        default:
+          std::cout << "XML parser error: wrong state: " << state_ << std::endl;
+          exit(1);
+      }
+    }
+  }
+
+  bool SpaceCheck() const {
+    bool cond = ((buffer_[index_] == ' ') || (buffer_[index_] == '\t'));
+    return cond;
+  }
+
+  bool LineEndCheck() {
+    bool found = false;
+    if (buffer_[index_] == '\n') {
+      buffer_[index_] = ' ';
+      ++file_line_;
+      found = true;
+      comment_ = false;
+    } else if (comment_ || (buffer_[index_] == '#')) {
+      found = true;
+      comment_ = true;
+    }
+    return found;
+  }
+
+  token_t NextToken() {
+    token_t token;
+    bool in_string = false;
+    bool special_symb = false;
+
+    while (1) {
+      if (data_size_ == 0) {
+        data_size_ = read(fd_, buffer_, kBufSize);
+        if (data_size_ <= 0) break;
+      }
+
+      if (token.empty()) {
+        while ((index_ < data_size_) && (SpaceCheck() || LineEndCheck())) {
+          ++index_;
+        }
+      }
+      while ((index_ < data_size_) && (in_string || !(SpaceCheck() || LineEndCheck()))) {
+        const char symb = buffer_[index_];
+        bool skip_symb = false;
+
+        switch (symb) {
+          case '\\':
+            if (special_symb) {
+              special_symb = false;
+            } else {
+              special_symb = true;
+              skip_symb = true;
+            }
+            break;
+          case '"':
+            if (special_symb) {
+              special_symb = false;
+            } else {
+              in_string = !in_string;
+              if (!in_string) {
+                buffer_[index_] = ' ';
+                --index_;
+              }
+              skip_symb = true;
+            }
+            break;
+        }
+
+        if (!skip_symb) token.push_back(symb);
+        ++index_;
+      }
+
+      if (index_ == data_size_) {
+        index_ = 0;
+        data_size_ = 0;
+      } else {
+        if (special_symb || in_string) BadFormat(token);
+        break;
+      }
+    }
+
+    return token;
+  }
+
+  void BadFormat(token_t token) {
+    token.push_back('\0');
+    std::cout << "Error: " << file_name_ << ", line " << file_line_ << ", bad XML token '"
+              << &token[0] << "'" << std::endl;
+    exit(1);
+  }
+
+  void AddLevel(const std::string& tag) {
+    level_t* level = new level_t;
+    level->tag = tag;
+    if (level_) {
+      level_->nodes.push_back(level);
+      stack_.push_back(level_);
+    }
+    level_ = level;
+
+    std::string global_tag;
+    for (level_t* level : stack_) {
+      global_tag += level->tag + ".";
+    }
+    global_tag += tag;
+    (*map_)[global_tag].push_back(level_);
+  }
+
+  void UpLevel() {
+    level_ = stack_.back();
+    stack_.pop_back();
+  }
+
+  std::string CurrentLevel() const { return level_->tag; }
+
+  void AddOption(const std::string& key, const std::string& value) { level_->opts[key] = value; }
+
+  const std::string file_name_;
+  unsigned file_line_;
+  int fd_;
+
+  static const size_t kBufSize = 256;
+  char buffer_[kBufSize];
+
+  unsigned data_size_;
+  unsigned index_;
+  unsigned state_;
+  bool comment_;
+  std::vector<level_t*> stack_;
+  bool included_;
+  level_t* level_;
+  map_t* map_;
+};
+
+}  // namespace xml
+
+#endif  // TEST_UTIL_XML_H_