tri11paragon
/
BLT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: tri11paragon:2a5d6432852b942868e50b6c70043172bd36983a
Branches Tags
tri11paragon:main
tri11paragon:v2
tri11paragon:v1
..
compare: tri11paragon:fd3eb7300827e834e5ffb482d60402fa291fad78
Branches Tags
tri11paragon:main
tri11paragon:v2
tri11paragon:v1

No commits in common. "2a5d6432852b942868e50b6c70043172bd36983a" and "fd3eb7300827e834e5ffb482d60402fa291fad78" have entirely different histories.
2a5d643285 ... fd3eb73008

3 changed files with 16 additions and 99 deletions
Show Stats Expand all files Collapse all files

4
include/blt/profiling/profiler.h
View File

@ -88,8 +88,8 @@ namespace blt::profiling {
#define BLT_START_INTERVAL(profileName, intervalName)
#define BLT_END_INTERVAL(profileName, intervalName)
#define BLT_POINT(profileName, pointName)
#define BLT_PRINT_PROFILE(profileName, ...)
#define BLT_WRITE_PROFILE(stream, profileName)
#define BLT_PRINT_ORDERED(profileName, ...)
#define BLT_WRITE_ORDERED(profileName, ...)
#else
/**
* Starts an interval to be measured, when ended the row will be added to the specified profile.

45
include/blt/profiling/profiler_v2.h
View File

@ -11,6 +11,7 @@
#include <cstdint>
#include <string>
#include <vector>
#include <blt/std/hashmap.h>
#include <blt/std/logging.h>
namespace blt
@ -79,15 +80,8 @@ namespace blt
};
interval_t* createInterval(profile_t& profiler, std::string interval_name);
void startInterval(interval_t* interval);
inline interval_t* startInterval(profile_t& profiler, std::string interval_name){
auto* p = createInterval(profiler, std::move(interval_name));
startInterval(p);
return p;
}
void endInterval(interval_t* interval);
void printProfile(profile_t& profiler, std::uint32_t flags = PRINT_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL,
@ -103,10 +97,9 @@ namespace blt
void endInterval(const std::string& profile_name, const std::string& interval_name);
void printProfile(const std::string& profile_name, std::uint32_t flags = PRINT_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL,
sort_by sort = sort_by::CYCLES, blt::logging::log_level log_level = blt::logging::log_level::NONE);
void printProfile(const std::string& profile_name);
void writeProfile(std::ifstream& stream, const std::string& profile_name);
void writeProfile(const std::string& profile_name);
}
class auto_interval
@ -120,11 +113,6 @@ namespace blt
blt::startInterval(iv);
}
explicit auto_interval(interval_t* iv): iv(iv)
{
blt::startInterval(iv);
}
auto_interval(const auto_interval& i) = delete;
auto_interval& operator=(const auto_interval& i) = delete;
@ -137,31 +125,4 @@ namespace blt
}
#ifdef BLT_DISABLE_PROFILING
#define BLT_START_INTERVAL(profileName, intervalName)
#define BLT_END_INTERVAL(profileName, intervalName)
#define BLT_PRINT_PROFILE(profileName, ...)
#define BLT_WRITE_PROFILE(stream, profileName)
#else
/**
* Starts an interval to be measured, when ended the row will be added to the specified profile.
*/
#define BLT_START_INTERVAL(profileName, intervalName) blt::_internal::startInterval(profileName, intervalName)
/**
* Ends an interval, adds the interval to the profile.
*/
#define BLT_END_INTERVAL(profileName, intervalName) blt::_internal::endInterval(profileName, intervalName)
/**
* Prints the profile order from least time to most time.
* @param profileName the profile to print
* @param loggingLevel blt::logging::LOG_LEVEL to log with (default: BLT_NONE)
* @param averageHistory use the historical collection of interval rows in an average or just the latest? (default: false)
*/
#define BLT_PRINT_PROFILE(profileName, ...) blt::_internal::printProfile(profileName, ##__VA_ARGS__)
/**
* writes the profile to an output stream, ordered from least time to most time, in CSV format.
*/
#define BLT_WRITE_PROFILE(stream, profileName) blt::_internal::writeProfile(stream, profileName)
#endif
#endif //BLT_PROFILER_V2_H

66
src/blt/profiling/profiler_v2.cpp
View File

@ -8,16 +8,10 @@
#include <blt/std/system.h>
#include <blt/std/format.h>
#include <functional>
#include <blt/std/hashmap.h>
namespace blt
{
/**
* General profiler functions
* --------------------------
*/
#define SORT_INTERVALS_FUNC_MACRO(use_history, TYPE_END, TYPE_START, TYPE_TOTAL) \
[&use_history](const interval_t* a, const interval_t* b) -> bool { \
if (use_history){ \
@ -105,12 +99,15 @@ namespace blt
switch (sort)
{
case sort_by::CYCLES:
BLT_DEBUG("Cycles");
sort_func = SORT_INTERVALS_FUNC_MACRO(use_history, cycles_start, cycles_end, cycles_total);
break;
case sort_by::WALL:
BLT_TRACE("WaLL");
sort_func = SORT_INTERVALS_FUNC_MACRO(use_history, wall_start, wall_end, wall_total);
break;
case sort_by::THREAD:
BLT_INFO("Thread!");
sort_func = SORT_INTERVALS_FUNC_MACRO(use_history, thread_start, thread_end, thread_total);
break;
}
@ -130,14 +127,14 @@ namespace blt
// we want to use the largest unit possible to keep the numbers small
// we might run into a case where something took 1000ns but other thing took 100s
// which would be hard to deal with either way. So TODO
if (wall > 1e6 && wall < 1e9 && container.wall == unit::NS)
if (wall > 1e5 && wall <= 1e8 && container.wall == unit::NS)
container.wall = unit::MS;
else if (wall > 1e9)
else if (wall > 1e8)
container.wall = unit::S;
if (thread > 1e6 && thread < 1e9 && container.thread == unit::NS)
if (thread > 1e5 && thread <= 1e8 && container.thread == unit::NS)
container.thread = unit::MS;
else if (thread > 1e9)
else if (thread > 1e8)
container.thread = unit::S;
return container;
}
@ -202,50 +199,9 @@ namespace blt
profile_t::~profile_t()
{
blt::clearProfile(*this);
}
/**
* profiler V1 partial backwards compat
* ----------------------------
*/
HASHMAP<std::string, HASHMAP<std::string, interval_t*>> profiles;
void _internal::startInterval(const std::string& profile_name, const std::string& interval_name)
{
auto& profile = profiles[profile_name];
if (!profile.contains(interval_name))
{
auto interval = new interval_t();
interval->interval_name = interval_name;
profile[interval_name] = interval;
}
blt::startInterval(profile[interval_name]);
}
void _internal::endInterval(const std::string& profile_name, const std::string& interval_name)
{
blt::endInterval(profiles[profile_name].at(interval_name));
}
void _internal::writeProfile(std::ifstream& stream, const std::string& profile_name)
{
auto& pref = profiles[profile_name];
profile_t profile{profile_name};
for (const auto& i : pref)
profile.intervals.push_back(i.second);
blt::writeProfile(stream, profile);
profiles.erase(profile_name);
}
void _internal::printProfile(const std::string& profile_name, std::uint32_t flags, sort_by sort, blt::logging::log_level log_level)
{
auto& pref = profiles[profile_name];
profile_t profile{profile_name};
for (const auto& i : pref)
profile.intervals.push_back(i.second);
blt::printProfile(profile, flags, sort, log_level);
profiles.erase(profile_name);
for (auto* p : intervals)
delete p;
for (auto* p : cycle_intervals)
delete p;
}
}