Add 'projects/aqlprofile/' from commit '6f236ffb5f1bd128e11ba0bf09e3c0a52b6527e4'

git-subtree-dir: projects/aqlprofile
git-subtree-mainline: 9011821e05
git-subtree-split: 6f236ffb5f

projects/aqlprofile/test/util/helper_funcs.h

@@ -0,0 +1,90 @@
+// MIT License
+//
+// Copyright (c) 2017-2025 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_HELPER_FUNCS_H_
+#define TEST_UTIL_HELPER_FUNCS_H_
+
+#include <time.h>
+
+#include <cmath>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+static inline void Error(std::string error_msg) {
+  std::cerr << "Error: " << error_msg << std::endl;
+}
+
+template <typename T>
+void PrintArray(const std::string header, const T* data, const int width, const int height) {
+  std::clog << header << " :\n";
+  for (int i = 0; i < height; i++) {
+    std::clog << "> ";
+    for (int j = 0; j < width; j++) {
+      std::clog << data[i * width + j] << " ";
+    }
+    std::clog << "\n";
+  }
+}
+
+template <typename T>
+bool FillRandom(T* array_ptr, const int width, const int height, const T range_min,
+                const T range_max, unsigned int seed = 123) {
+  if (!array_ptr) {
+    Error("Cannot fill array. NULL pointer.");
+    return false;
+  }
+
+  if (!seed) seed = (unsigned int)time(NULL);
+
+  srand(seed);
+  double range = double(range_max - range_min) + 1.0;
+
+  /* random initialisation of input */
+  for (int i = 0; i < height; i++)
+    for (int j = 0; j < width; j++) {
+      int index = i * width + j;
+      array_ptr[index] = range_min + T(range * rand() / (RAND_MAX + 1.0));
+    }
+
+  return true;
+}
+
+template <typename T>
+T RoundToPowerOf2(T val) {
+  int bytes = sizeof(T);
+
+  val--;
+  for (int i = 0; i < bytes; i++) val |= val >> (1 << i);
+  val++;
+
+  return val;
+}
+
+template <typename T>
+bool IsPowerOf2(T val) {
+  long long long_val = val;
+  return (((long_val & (-long_val)) - long_val == 0) && (long_val != 0));
+}
+
+#endif  // TEST_UTIL_HELPER_FUNCS_H_

projects/aqlprofile/test/util/hsa_rsrc_factory.cpp

@@ -0,0 +1 @@
+../../src/util/hsa_rsrc_factory.cpp

projects/aqlprofile/test/util/hsa_rsrc_factory.h

@@ -0,0 +1 @@
+../../src/util/hsa_rsrc_factory.h

projects/aqlprofile/test/util/perf_timer.cpp

@@ -0,0 +1,177 @@
+// MIT License
+//
+// Copyright (c) 2017-2025 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.
+
+
+#include "util/perf_timer.h"
+
+PerfTimer::PerfTimer() { freq_in_100mhz_ = MeasureTSCFreqHz(); }
+
+PerfTimer::~PerfTimer() {
+  while (!timers_.empty()) {
+    Timer* temp = timers_.back();
+    timers_.pop_back();
+    delete temp;
+  }
+}
+
+// New cretaed timer instantance index will be returned
+int PerfTimer::CreateTimer() {
+  Timer* newTimer = new Timer;
+  newTimer->start = 0;
+  newTimer->clocks = 0;
+
+#ifdef _WIN32
+  QueryPerformanceFrequency((LARGE_INTEGER*)&newTimer->freq);
+#else
+  newTimer->freq = (long long)1.0E3;
+#endif
+
+  /* Push back the address of new Timer instance created */
+  timers_.push_back(newTimer);
+  return (int)(timers_.size() - 1);
+}
+
+int PerfTimer::StartTimer(int index) {
+  if (index >= (int)timers_.size()) {
+    Error("Cannot reset timer. Invalid handle.");
+    return FAILURE;
+  }
+
+#ifdef _WIN32
+// General Windows timing method
+#ifndef _AMD
+  long long tmpStart;
+  QueryPerformanceCounter((LARGE_INTEGER*)&(tmpStart));
+  timers_[index]->start = (double)tmpStart;
+#else
+// AMD Windows timing method
+#endif
+#else
+// General Linux timing method
+#ifndef _AMD
+  struct timeval s;
+  gettimeofday(&s, 0);
+  timers_[index]->start = s.tv_sec * 1.0E3 + ((double)(s.tv_usec / 1.0E3));
+#else
+  // AMD timing method
+  unsigned int unused;
+  timers_[index]->start = __rdtscp(&unused);
+#endif
+#endif
+
+  return SUCCESS;
+}
+
+int PerfTimer::StopTimer(int index) {
+  double n = 0;
+  if (index >= (int)timers_.size()) {
+    Error("Cannot reset timer. Invalid handle.");
+    return FAILURE;
+  }
+#ifdef _WIN32
+#ifndef _AMD
+  long long n1;
+  QueryPerformanceCounter((LARGE_INTEGER*)&(n1));
+  n = (double)n1;
+#else
+// AMD Window Timing
+#endif
+
+#else
+// General Linux timing method
+#ifndef _AMD
+  struct timeval s;
+  gettimeofday(&s, 0);
+  n = s.tv_sec * 1.0E3 + (double)(s.tv_usec / 1.0E3);
+#else
+  // AMD Linux timing
+  unsigned int unused;
+  n = __rdtscp(&unused);
+#endif
+#endif
+
+  n -= timers_[index]->start;
+  timers_[index]->start = 0;
+
+#ifndef _AMD
+  timers_[index]->clocks += n;
+#else
+  // timers_[index]->clocks += 10 * n / freq_in_100mhz_; // unit is ns
+  timers_[index]->clocks += 1.0E-6 * 10 * n / freq_in_100mhz_;  // convert to ms
+#endif
+
+  return SUCCESS;
+}
+
+void PerfTimer::Error(std::string str) { std::cout << str << std::endl; }
+
+double PerfTimer::ReadTimer(int index) {
+  if (index >= (int)timers_.size()) {
+    Error("Cannot read timer. Invalid handle.");
+    return FAILURE;
+  }
+
+  double reading = double(timers_[index]->clocks);
+
+  reading = double(reading / timers_[index]->freq);
+
+  return reading;
+}
+
+uint64_t PerfTimer::CoarseTimestampUs() {
+#ifdef _WIN32
+  uint64_t freqHz, ticks;
+  QueryPerformanceFrequency((LARGE_INTEGER*)&freqHz);
+  QueryPerformanceCounter((LARGE_INTEGER*)&ticks);
+
+  // Scale numerator and divisor until (ticks * 1000000) fits in uint64_t.
+  while (ticks > (1ULL << 44)) {
+    ticks /= 16;
+    freqHz /= 16;
+  }
+
+  return (ticks * 1000000) / freqHz;
+#else
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+  return uint64_t(ts.tv_sec) * 1000000 + ts.tv_nsec / 1000;
+#endif
+}
+
+uint64_t PerfTimer::MeasureTSCFreqHz() {
+  // Make a coarse interval measurement of TSC ticks for 1 gigacycles.
+  unsigned int unused;
+  uint64_t tscTicksEnd;
+
+  uint64_t coarseBeginUs = CoarseTimestampUs();
+  uint64_t tscTicksBegin = __rdtscp(&unused);
+  do {
+    tscTicksEnd = __rdtscp(&unused);
+  } while (tscTicksEnd - tscTicksBegin < 1000000000);
+
+  uint64_t coarseEndUs = CoarseTimestampUs();
+
+  // Compute the TSC frequency and round to nearest 100MHz.
+  uint64_t coarseIntervalNs = (coarseEndUs - coarseBeginUs) * 1000;
+  uint64_t tscIntervalTicks = tscTicksEnd - tscTicksBegin;
+  return (tscIntervalTicks * 10 + (coarseIntervalNs / 2)) / coarseIntervalNs;
+}

projects/aqlprofile/test/util/perf_timer.h

@@ -0,0 +1,84 @@
+// MIT License
+//
+// Copyright (c) 2017-2025 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_PERF_TIMER_H_
+#define TEST_UTIL_PERF_TIMER_H_
+
+// Will use AMD timer or general Linux timer based on compilation flag
+// Need to consider platform is Windows or Linux
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#include <time.h>
+#include <windows.h>
+#else
+#if defined(__GNUC__)
+#include <sys/time.h>
+#include <x86intrin.h>
+#endif  // __GNUC__
+#endif  // _MSC_VER
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+class PerfTimer {
+ public:
+  enum { SUCCESS = 0, FAILURE = 1 };
+
+  PerfTimer();
+  ~PerfTimer();
+
+  // General Linux timing method
+  int CreateTimer();
+  int StartTimer(int index);
+  int StopTimer(int index);
+
+  // retrieve time
+  double ReadTimer(int index);
+  // write into a file
+  double WriteTimer(int index);
+
+ private:
+  struct Timer {
+    std::string name; /* name of time object */
+    long long freq;   /* frequency */
+    double clocks;    /* number of ticks at end */
+    double start;     /* start point ticks */
+  };
+
+  std::vector<Timer*> timers_; /* vector to Timer objects */
+  double freq_in_100mhz_;
+
+  // AMD timing method
+  uint64_t CoarseTimestampUs();
+  uint64_t MeasureTSCFreqHz();
+
+  void Error(std::string str);
+};
+
+#endif  // TEST_UTIL_PERF_TIMER_H_

projects/aqlprofile/test/util/reg_offsets.h

@@ -0,0 +1 @@
+../../src/util/reg_offsets.h

projects/aqlprofile/test/util/test_assert.h

@@ -0,0 +1,47 @@
+// MIT License
+//
+// Copyright (c) 2017-2025 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_CTRL_TEST_ASSERT_H_
+#define TEST_CTRL_TEST_ASSERT_H_
+
+#define TEST_ASSERT(cond)                                                                    \
+  {                                                                                          \
+    if (!(cond)) {                                                                           \
+      std::cerr << "Assert failed(" << #cond << ") at " << __FILE__ << ", line " << __LINE__ \
+                << std::endl;                                                                \
+      exit(-1);                                                                              \
+    }                                                                                        \
+  }
+
+#define TEST_STATUS(cond)                                                              \
+  {                                                                                    \
+    if (!(cond)) {                                                                     \
+      std::cerr << "Test error at " << __FILE__ << ", line " << __LINE__ << std::endl; \
+      const char* message;                                                             \
+      rocprofiler_error_string(&message);                                              \
+      std::cerr << "ERROR: " << message << std::endl;                                  \
+      exit(-1);                                                                        \
+    }                                                                                  \
+  }
+
+#endif  // TEST_CTRL_TEST_ASSERT_H_

projects/aqlprofile/test/util/xml.h

@@ -0,0 +1,461 @@
+// MIT License
+//
+// Copyright (c) 2017-2025 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_