AI/rocm-systems
2
0
Fork 0
Código Incidencias Pull Requests Acciones Paquetes Proyectos Lanzamientos Wiki Actividad

Convert counter def format to YAML (#976)

Explorar el Código 
* Convert counter def format to YAML

Converts counter definition format to YAML with the
following structure:

```yaml
COUNTER_NAME:
 architectures:
  gfxXX: // Can be more than one, / deliminated if they share idential data
    block: <Optional>
    event: <Optional>
    expression: <optional>
    description: <Optional> // In case per arch notes are needed
  gfxYY:
    ...
 description: General counter desctiption
```

All counters (derived and hardware) are now defined
in the same file for ease of future additions/subtractions.

Removes existing XML parser. Keeps the existing XML
definitions for now (since other tools still rely on
its presence).
Este commit está contenido en:
Benjamin Welton
2024-07-12 16:20:33 -07:00
cometido por GitHub
padre 2be3543c7b
commit 34897d318f
Se han modificado 13 ficheros con 4202 adiciones y 734 borrados
Descargar archivo de parche Descargar archivo de diferencias Expandir todos los archivos Contraer todos los archivos
.gitmodules
+3
Ver fichero
@@ -25,3 +25,6 @@
[submodule "external/elfio"]
path = external/elfio
url = https://github.com/serge1/ELFIO.git
[submodule "external/yaml-cpp"]
path = external/yaml-cpp
url = https://github.com/jbeder/yaml-cpp.git
cmake/rocprofiler_interfaces.cmake
+1
Ver fichero
@@ -54,6 +54,7 @@ rocprofiler_add_interface_library(rocprofiler-elf "ElfUtils elf library" INTERNA
rocprofiler_add_interface_library(rocprofiler-dw "ElfUtils dw library" INTERNAL)
rocprofiler_add_interface_library(rocprofiler-elfio "ELFIO header-only C++ library"
INTERNAL)
rocprofiler_add_interface_library(rocprofiler-yaml-cpp "YAML CPP Parser" INTERNAL)
#
# interface for libraries (ROCm-specific)
external/CMakeLists.txt
vendido
+15
Ver fichero
@@ -126,6 +126,21 @@ if(NOT TARGET PTL::ptl-static)
add_subdirectory(ptl EXCLUDE_FROM_ALL)
endif()
rocprofiler_checkout_git_submodule(
RECURSIVE
RELATIVE_PATH external/yaml-cpp
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
REPO_URL https://github.com/jbeder/yaml-cpp.git
REPO_BRANCH "master")
add_subdirectory(yaml-cpp EXCLUDE_FROM_ALL)
target_link_libraries(rocprofiler-yaml-cpp
INTERFACE $<BUILD_INTERFACE:yaml-cpp::yaml-cpp>)
target_include_directories(
rocprofiler-yaml-cpp
INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/external/yaml-cpp/include>)
# checkout submodule if not already checked out or clone repo if no .gitmodules file
rocprofiler_checkout_git_submodule(
RECURSIVE
external/yaml-cpp
vendido Submódulo
+1
Submodule external/yaml-cpp added at 1d8ca1f35e
source/lib/common/CMakeLists.txt
+3 -3
Ver fichero
@@ -4,7 +4,7 @@
rocprofiler_activate_clang_tidy()
set(common_sources demangle.cpp elf_utils.cpp environment.cpp logging.cpp
static_object.cpp utility.cpp xml.cpp)
static_object.cpp utility.cpp)
set(common_headers
abi.hpp
defines.hpp
@@ -19,8 +19,7 @@ set(common_headers
stringize_arg.hpp
synchronized.hpp
units.hpp
utility.hpp
xml.hpp)
utility.hpp)
add_library(rocprofiler-common-library STATIC)
add_library(rocprofiler-sdk::rocprofiler-common-library ALIAS rocprofiler-common-library)
@@ -41,6 +40,7 @@ target_link_libraries(
$<BUILD_INTERFACE:rocprofiler-sdk::rocprofiler-cxx-filesystem>
$<BUILD_INTERFACE:rocprofiler-sdk::rocprofiler-glog>
$<BUILD_INTERFACE:rocprofiler-sdk::rocprofiler-fmt>
$<BUILD_INTERFACE:rocprofiler-sdk::rocprofiler-yaml-cpp>
$<BUILD_INTERFACE:rocprofiler-sdk::rocprofiler-dl>
$<BUILD_INTERFACE:rocprofiler-sdk::rocprofiler-ptl>
$<BUILD_INTERFACE:rocprofiler-sdk::rocprofiler-atomic>
source/lib/common/xml.cpp
-531
Ver fichero
@@ -1,531 +0,0 @@
// MIT License
//
// Copyright (c) 2023 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 "lib/common/xml.hpp"
#include "lib/common/logging.hpp"
namespace rocprofiler
{
namespace common
{
Xml::Xml(std::string file_name, const Xml* obj)
: file_name_(std::move(file_name))
, state_(BODY_STATE)
{
if(obj != nullptr)
{
map_ = obj->map_;
level_ = obj->level_;
included_ = true;
}
}
Xml::~Xml()
{
for(auto& x : stack_)
{
x->nodes.clear();
x->copy.reset();
}
if(!map_) return;
for(auto& [_, nodes] : *map_)
{
(void) _;
for(auto& node : nodes)
{
node->nodes.clear();
node->copy.reset();
}
}
}
std::shared_ptr<Xml>
Xml::Create(const std::string& file_name, const Xml* obj)
{
auto xml = std::make_shared<Xml>(file_name, obj);
if(xml != nullptr)
{
if(xml->Init() != false)
{
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(const auto& node : xml->GetNodes("top.include"))
{
if(node->opts.find("touch") == node->opts.end())
{
node->opts["touch"] = "";
incl_nodes.push_back(node);
}
}
for(const auto& incl : incl_nodes)
{
const std::string& incl_name = path + incl->opts["file"];
auto ixml = Create(incl_name, xml.get());
if(!ixml)
{
xml.reset();
break;
}
}
if(xml)
{
xml->Process();
}
}
}
return xml;
}
void
Xml::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);
auto level = std::make_shared<level_t>();
(*map_)[full_tag].push_back(level);
level->tag = level_tag;
level->opts["name"] = name;
level->opts["expr"] = expr;
}
void
Xml::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());
}
bool
Xml::print_func::operator()(const std::string& global_tag, const std::shared_ptr<level_t>& node)
{
std::cout << global_tag << ":\n";
for(auto& opt : node->opts)
{
std::cout << global_tag << "." << opt.first << " = " << opt.second << "\n";
}
return true;
}
void
Xml::Print() const
{
std::cout << "XML file '" << file_name_ << "':\n";
ForEach(print_func{});
}
bool
Xml::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_ == nullptr)
{
map_ = std::make_unique<map_t>();
AddLevel("top");
}
return true;
}
void
Xml::PreProcess()
{
uint32_t ind = 0;
char buf[kBufSize];
bool error = false;
while(true)
{
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)
{
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);
abort();
}
lseek(fd_, 0, SEEK_SET);
}
void
Xml::Process()
{
token_t remainder;
while(true)
{
token_t token = (!remainder.empty()) ? remainder : NextToken();
remainder.clear();
// token_t token1 = token;
// token1.push_back('\0');
// std::cout << ">>> " << &token1[0] << std::endl;
// End of file
if(token.empty()) 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
{
Inherit(GetOption("base"));
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 std::string key = token.data();
const std::string value = &token[j + 1];
AddOption(key, value);
}
break;
default:
{
ROCP_ERROR << "XML parser error: wrong state: " << state_;
abort();
}
}
}
}
bool
Xml::SpaceCheck() const
{
bool cond = ((buffer_[index_] == ' ') || (buffer_[index_] == '\t'));
return cond;
}
bool
Xml::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;
}
Xml::token_t
Xml::NextToken()
{
token_t token;
bool in_string = false;
bool special_symb = false;
while(true)
{
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
Xml::BadFormat(token_t token)
{
token.push_back('\0');
ROCP_ERROR << "Error: " << file_name_ << ", line " << file_line_ << ", bad XML token '"
<< token.data() << "'";
abort();
}
void
Xml::AddLevel(const std::string& tag)
{
auto level = std::make_shared<level_t>();
level->tag = tag;
if(level_)
{
level_->nodes.push_back(level);
stack_.push_back(level_);
}
level_ = level;
std::string global_tag = GlobalTag(tag);
(*map_)[global_tag].push_back(level_);
}
void
Xml::UpLevel()
{
level_ = stack_.back();
stack_.pop_back();
}
void
Xml::Copy(const std::shared_ptr<level_t>& from, const std::shared_ptr<level_t>& to)
{
auto level = to;
if(level == nullptr)
{
AddLevel(from->tag);
level = level_;
}
level->copy = from;
level->opts = from->opts;
for(const auto& node : from->nodes)
{
bool found = false;
const std::string name = GetOption("name", node);
const std::string global_tag = GlobalTag(level->tag) + "." + node->tag;
for(const auto& item : (*map_)[global_tag])
{
if((name == GetOption("name", item)) || (node == item->copy))
{
found = true;
break;
}
}
if(found == false) Copy(node, nullptr);
}
if(to == nullptr) UpLevel();
}
void
Xml::Inherit(const std::string& tag)
{
if(!tag.empty())
{
const std::string global_tag = GlobalTag(tag);
auto it = map_->find(global_tag);
if(it == map_->end())
{
fprintf(
stderr, "Node \"%s\": Base not found \"%s\"\n", level_->tag.c_str(), tag.c_str());
abort();
}
for(const auto& node : it->second)
{
Copy(node, level_);
}
}
}
std::string
Xml::CurrentLevel() const
{
return level_->tag;
}
std::string
Xml::GlobalTag(const std::string& tag) const
{
std::string global_tag;
for(const auto& level : stack_)
{
global_tag += level->tag + ".";
}
global_tag += tag;
return global_tag;
}
void
Xml::AddOption(const std::string& key, const std::string& value)
{
level_->opts[key] = value;
}
std::string
Xml::GetOption(const std::string& key, std::shared_ptr<const level_t> level)
{
level = (level != nullptr) ? level : level_;
auto it = level->opts.find(key);
return (it != level->opts.end()) ? it->second : "";
}
} // namespace common
} // namespace rocprofiler
source/lib/common/xml.hpp
-147
Ver fichero
@@ -1,147 +0,0 @@
// MIT License
//
// Copyright (c) 2023 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.
#pragma once
#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 <list>
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
namespace rocprofiler
{
namespace common
{
class Xml
{
public:
using token_t = std::vector<char>;
struct level_t;
using node_vect_t = std::vector<std::shared_ptr<level_t>>;
using node_list_t = std::list<std::shared_ptr<level_t>>;
using nodes_t = node_vect_t;
using opts_t = std::map<std::string, std::string>;
struct level_t
{
std::string tag;
nodes_t nodes;
opts_t opts;
std::shared_ptr<const level_t> copy;
};
using nodes_vec_t = std::vector<std::shared_ptr<level_t>>;
using map_t = std::map<std::string, nodes_vec_t>;
enum
{
DECL_STATE,
BODY_STATE
};
static std::shared_ptr<Xml> Create(const std::string& file_name, const Xml* obj = nullptr);
std::string GetName() { return file_name_; }
void AddExpr(const std::string& full_tag, const std::string& name, const std::string& expr);
void AddConst(const std::string& full_tag, const std::string& name, const uint64_t& val);
nodes_t GetNodes(const std::string& global_tag) { return (*map_)[global_tag]; }
const map_t& GetAllNodes() { return (*map_); }
template <typename Tp>
Tp ForEach(const Tp& v_i) const;
struct print_func
{
bool operator()(const std::string& global_tag, const std::shared_ptr<level_t>& node);
};
void Print() const;
Xml(std::string file_name, const Xml* obj);
~Xml();
private:
bool Init();
void PreProcess();
void Process();
bool SpaceCheck() const;
bool LineEndCheck();
token_t NextToken();
void BadFormat(token_t token);
void AddLevel(const std::string& tag);
void UpLevel();
void Copy(const std::shared_ptr<level_t>& from, const std::shared_ptr<level_t>& to);
void Inherit(const std::string& tag);
std::string CurrentLevel() const;
std::string GlobalTag(const std::string& tag) const;
void AddOption(const std::string& key, const std::string& value);
std::string GetOption(const std::string& key, std::shared_ptr<const level_t> level = nullptr);
const std::string file_name_;
unsigned file_line_{0};
int fd_;
static const size_t kBufSize = 256;
char buffer_[kBufSize];
unsigned data_size_{0};
unsigned index_{0};
unsigned state_{0};
bool comment_{false};
std::vector<std::shared_ptr<level_t>> stack_;
bool included_{false};
std::shared_ptr<level_t> level_;
std::shared_ptr<map_t> map_;
};
template <typename Tp>
Tp
Xml::ForEach(const Tp& v_i) const
{
Tp v = v_i;
if(map_)
{
for(auto& entry : *map_)
{
for(const auto& node : entry.second)
{
if(Tp{}(entry.first, node) == false) break;
}
}
}
return v;
}
} // namespace common
} // namespace rocprofiler
source/lib/rocprofiler-sdk/counters/CMakeLists.txt
+1
Ver fichero
@@ -9,6 +9,7 @@ target_sources(rocprofiler-object-library PRIVATE ${ROCPROFILER_LIB_COUNTERS_SOU
add_subdirectory(xml)
add_subdirectory(parser)
add_subdirectory(yaml)
if(ROCPROFILER_BUILD_TESTS)
add_subdirectory(tests)
source/lib/rocprofiler-sdk/counters/metrics.cpp
+72 -43
Ver fichero
@@ -27,11 +27,19 @@
#include "lib/common/filesystem.hpp"
#include "lib/common/static_object.hpp"
#include "lib/common/utility.hpp"
#include "lib/common/xml.hpp"
#include "lib/rocprofiler-sdk/agent.hpp"
#include "glog/logging.h"
#include "yaml-cpp/exceptions.h"
#include "yaml-cpp/node/convert.h"
#include "yaml-cpp/node/detail/impl.h"
#include "yaml-cpp/node/impl.h"
#include "yaml-cpp/node/iterator.h"
#include "yaml-cpp/node/node.h"
#include "yaml-cpp/node/parse.h"
#include "yaml-cpp/parser.h"
#include <dlfcn.h> // for dladdr
#include <cstdint>
#include <cstdlib>
@@ -79,55 +87,76 @@ get_constants()
}
return constants;
}
// Future TODO: inheritance? does it work for derived_counters.xml?
/**
* Expected YAML Format:
* COUNTER_NAME:
* architectures:
* gfxXX: // Can be more than one, / deliminated if they share idential data
* block: <Optional>
* event: <Optional>
* expression: <optional>
* description: <Optional>
* gfxYY:
* ...
* description: General counter desctiption
*/
MetricMap
loadXml(const std::string& filename, bool load_constants = false)
loadYAML(const std::string& filename, bool load_constants = false, bool load_derived = false)
{
MetricMap ret;
ROCP_INFO << "Loading Counter Config: " << filename;
// todo: return unique_ptr....
auto xml = common::Xml::Create(filename);
ROCP_FATAL_IF(!xml)
<< "Could not open XML Counter Config File (set env ROCPROFILER_METRICS_PATH)";
auto yaml = YAML::LoadFile(filename);
const auto& constant_metrics = get_constants();
for(const auto& [gfx_name, nodes] : xml->GetAllNodes())
for(auto it = yaml.begin(); it != yaml.end(); ++it)
{
/**
* "top." is used to designate the root encapsulation of all contained XML subroots (in our
* case "gfxX"). This is inserted by the parser so it will always be present. .metric
* denotes XML tags that are contained in the subroots. This will not change unless we
* respec the XML (which we should...).
*/
if(gfx_name.find("metric") == std::string::npos ||
gfx_name.find("top.") == std::string::npos || gfx_name.find("gfx") == std::string::npos)
continue;
auto counter_name = it->first.as<std::string>();
auto counter_def = it->second;
auto def_iterator = counter_def["architectures"];
auto& metricVec =
ret.emplace(gfx_name.substr(strlen("top."),
gfx_name.size() - strlen("top.") - strlen(".metric")),
std::vector<Metric>())
.first->second;
for(const auto& node : nodes)
for(auto def_it = def_iterator.begin(); def_it != def_iterator.end(); ++def_it)
{
metricVec.emplace_back(gfx_name,
node->opts["name"],
node->opts["block"],
node->opts["event"],
node->opts["descr"],
node->opts["expr"],
node->opts["special"],
current_id());
current_id()++;
}
auto archs = def_it->first.as<std::string>();
auto def = def_it->second;
// To save space in the YAML file, we combine architectures with the same
// definition into a single entry. Split these out into separate entries.
// architectures:
// gfx10/gfx1010/gfx1030/gfx1031/.....9:
// expression: 400*SQ_WAIT_INST_LDS/SQ_WAVES/GRBM_GUI_ACTIVE
std::vector<std::string> result;
std::stringstream ss(archs);
std::string arch_name;
if(load_constants)
{
metricVec.insert(metricVec.end(), constant_metrics.begin(), constant_metrics.end());
while(std::getline(ss, arch_name, '/'))
{
auto& metricVec = ret.emplace(arch_name, std::vector<Metric>()).first->second;
if(metricVec.empty() && load_constants)
{
metricVec.insert(
metricVec.end(), get_constants().begin(), get_constants().end());
}
if((def["expression"] && load_derived) || (!load_derived && !def["expression"]))
{
std::string description;
if(def["description"])
description = def["description"].as<std::string>();
else if(counter_def["description"])
description = counter_def["description"].as<std::string>();
metricVec.emplace_back(
arch_name,
counter_name,
(def["block"] ? def["block"].as<std::string>() : ""),
(def["event"] ? def["event"].as<std::string>() : ""),
description,
(def["expression"] ? def["expression"].as<std::string>() : ""),
"",
current_id());
current_id()++;
ROCP_TRACE << fmt::format("Inserted info {}: {}", arch_name, metricVec.back());
}
}
}
}
ROCP_FATAL_IF(current_id() > 65536)
<< "Counter count exceeds 16 bits, which may break counter id output";
return ret;
@@ -163,19 +192,19 @@ findViaEnvironment(const std::string& filename)
MetricMap
getDerivedHardwareMetrics()
{
auto counters_path = findViaEnvironment("derived_counters.xml");
auto counters_path = findViaEnvironment("counter_defs.yaml");
ROCP_FATAL_IF(!common::filesystem::exists(counters_path))
<< "metric xml file '" << counters_path << "' does not exist";
return loadXml(counters_path);
return loadYAML(counters_path, false, true);
}
MetricMap
getBaseHardwareMetrics()
{
auto counters_path = findViaEnvironment("basic_counters.xml");
auto counters_path = findViaEnvironment("counter_defs.yaml");
ROCP_FATAL_IF(!common::filesystem::exists(counters_path))
<< "metric xml file '" << counters_path << "' does not exist";
return loadXml(counters_path, true);
return loadYAML(counters_path, true, false);
}
const MetricIdMap*
source/lib/rocprofiler-sdk/counters/tests/core.cpp
+1
Ver fichero
@@ -208,6 +208,7 @@ TEST(core, check_packet_generation)
*/
rocprofiler_profile_config_id_t cfg_id = {};
rocprofiler_counter_id_t id = {.handle = metric.id()};
ROCP_ERROR << fmt::format("Generating packet for {}", metric);
ROCPROFILER_CALL(
rocprofiler_create_profile_config(agent.get_rocp_agent()->id, &id, 1, &cfg_id),
"Unable to create profile");
source/lib/rocprofiler-sdk/counters/tests/metrics_test.h
+10 -10
Ver fichero
@@ -31,11 +31,7 @@
// Layout is: {name, block, event, expression, description}.
static const std::unordered_map<std::string, std::vector<std::vector<std::string>>> basic_gfx908 = {
{"gfx908",
{{"MAX_WAVE_SIZE", "", "", "1", "Max wave size constant"},
{"SE_NUM", "", "", "1", "SE_NUM"},
{"SIMD_NUM", "", "", "1", "SIMD Number"},
{"CU_NUM", "", "", "1", "CU_NUM"},
{"SQ_INSTS_VMEM_WR",
{{"SQ_INSTS_VMEM_WR",
"SQ",
"28",
"<None>",
@@ -86,14 +82,14 @@ static const std::unordered_map<std::string, std::vector<std::vector<std::string
"SQ",
"72",
"<None>",
"regspec 71? Number of cycles the SQ instruction arbiter is working on a VALU instruction. "
"(per-simd, nondeterministic). Units in quad-cycles(4 cycles)"},
"Number of cycles the SQ instruction arbiter is working on a VALU instruction. "
"(per-simd, emulated). Units in quad-cycles(4 cycles)"},
{"SQ_INST_CYCLES_SALU",
"SQ",
"85",
"<None>",
"Number of cycles needed to execute non-memory read scalar operations. (per-simd, "
"emulated)"},
"emulated). Units in quad-cycles(4 cycles)"},
{"SQ_THREAD_CYCLES_VALU",
"SQ",
"86",
@@ -166,7 +162,11 @@ static const std::unordered_map<std::string, std::vector<std::vector<std::string
static const std::unordered_map<std::string, std::vector<std::vector<std::string>>> derived_gfx908 =
{{"gfx908",
{{"GPUBusy",
{{"MAX_WAVE_SIZE", "", "", "wave_front_size", "Max wave size constant"},
{"SE_NUM", "", "", "array_count/simd_arrays_per_engine", "SE_NUM"},
{"SIMD_NUM", "", "", "simd_per_cu/CU_NUM", "SIMD Number"},
{"CU_NUM", "", "", "cu_per_simd_array*array_count", "CU_NUM"},
{"GPUBusy",
"",
"",
"100*GRBM_GUI_ACTIVE/GRBM_COUNT",
@@ -231,7 +231,7 @@ static const std::unordered_map<std::string, std::vector<std::vector<std::string
"",
"",
"reduce(TCC_MISS,sum)",
"Number of cache misses. Sum over TCC instances."},
"Number of cache misses. UC reads count as misses. Sum over TCC instances."},
{"TCC_EA_RDREQ_32B_sum",
"",
"",
source/lib/rocprofiler-sdk/counters/yaml/CMakeLists.txt
+6
Ver fichero
@@ -0,0 +1,6 @@
configure_file(counter_defs.yaml
${PROJECT_BINARY_DIR}/share/rocprofiler-sdk/counter_defs.yaml COPYONLY)
install(
FILES ${PROJECT_BINARY_DIR}/share/rocprofiler-sdk/counter_defs.yaml
DESTINATION share/rocprofiler-sdk
COMPONENT core)
source/lib/rocprofiler-sdk/counters/yaml/counter_defs.yaml
+4089
Ver fichero
La diferencia del archivo ha sido suprimido porque es demasiado grande Cargar Diff