diff --git a/include/blt/profiling/profiler_v2.h b/include/blt/profiling/profiler_v2.h index 3b62e1c..dd080ec 100644 --- a/include/blt/profiling/profiler_v2.h +++ b/include/blt/profiling/profiler_v2.h @@ -23,41 +23,41 @@ namespace blt static inline constexpr std::uint32_t PRINT_WALL = 0x4; // print out the thread CPU time static inline constexpr std::uint32_t PRINT_THREAD = 0x8; - + enum class sort_by { CYCLES, WALL, THREAD }; - + // 32 bit currently not supported typedef std::int64_t pf_time_t; typedef std::uint64_t pf_cycle_t; - + struct interval_t { pf_time_t wall_start = 0; pf_time_t wall_end = 0; pf_time_t wall_total = 0; - + pf_time_t thread_start = 0; pf_time_t thread_end = 0; pf_time_t thread_total = 0; - + pf_cycle_t cycles_start = 0; pf_cycle_t cycles_end = 0; pf_cycle_t cycles_total = 0; - + std::uint64_t count = 0; std::string interval_name; - + interval_t() = default; - + interval_t(pf_time_t wallStart, pf_time_t wallEnd, pf_time_t wallTotal, pf_time_t threadStart, pf_time_t threadEnd, pf_time_t threadTotal, pf_cycle_t cyclesStart, pf_cycle_t cyclesEnd, pf_cycle_t cyclesTotal, uint64_t count, std::string intervalName); }; - + struct cycle_interval_t { pf_cycle_t cycles_start = 0; @@ -66,81 +66,86 @@ namespace blt std::uint64_t count = 0; std::string interval_name; }; - + struct profile_t { std::vector intervals; std::vector cycle_intervals; std::string name; - + explicit profile_t(std::string name): name(std::move(name)) - {} - + { + } + profile_t(const profile_t& p) = delete; - + profile_t& operator=(const profile_t& p) = delete; - + ~profile_t(); }; - + 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 = AVERAGE_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 writeProfile(std::ifstream& stream, const profile_t& profiler); - + + void writeProfile(std::ostream& stream, profile_t& profiler, + std::uint32_t flags = AVERAGE_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL, + sort_by sort = sort_by::CYCLES); + void clearProfile(profile_t& profiler); - + namespace _internal { void startInterval(const std::string& profile_name, const std::string& interval_name); - + void endInterval(const std::string& profile_name, const std::string& interval_name); - + void printProfile(const std::string& profile_name, std::uint32_t flags = AVERAGE_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 writeProfile(std::ifstream& stream, const std::string& profile_name); + + void writeProfile(std::ostream& stream, const std::string& profile_name, + std::uint32_t flags = AVERAGE_HISTORY | PRINT_CYCLES | PRINT_THREAD | PRINT_WALL, + sort_by sort = sort_by::CYCLES); } - + class auto_interval { - private: - interval_t* iv; - public: - auto_interval(std::string interval_name, profile_t& profiler) - { - iv = blt::createInterval(profiler, std::move(interval_name)); - 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; - - ~auto_interval() - { - blt::endInterval(iv); - } + private: + interval_t* iv; + + public: + auto_interval(std::string interval_name, profile_t& profiler) + { + iv = blt::createInterval(profiler, std::move(interval_name)); + 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; + + ~auto_interval() + { + blt::endInterval(iv); + } }; - } #ifdef BLT_DISABLE_PROFILING @@ -152,22 +157,22 @@ namespace blt /** * 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) +#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) +#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__) +#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) +#define BLT_WRITE_PROFILE(stream, profileName) blt::_internal::writeProfile(stream, profileName) #endif #endif //BLT_PROFILER_V2_H diff --git a/libraries/parallel-hashmap b/libraries/parallel-hashmap index 0bad098..d88c5e1 160000 --- a/libraries/parallel-hashmap +++ b/libraries/parallel-hashmap @@ -1 +1 @@ -Subproject commit 0bad0987f1989294e73cdb1ebf41c75f49cdb0c1 +Subproject commit d88c5e15079047777b418132ece5879e7c9aaa2b diff --git a/src/blt/profiling/profiler_v2.cpp b/src/blt/profiling/profiler_v2.cpp index 593fd2e..00dd5f7 100644 --- a/src/blt/profiling/profiler_v2.cpp +++ b/src/blt/profiling/profiler_v2.cpp @@ -89,11 +89,6 @@ namespace blt profiler.cycle_intervals.clear(); } - void writeProfile(std::ifstream&, const profile_t&) - { - BLT_WARN("Write profile for V2 is currently a TODO"); - } - void sort_intervals(std::vector& intervals, sort_by sort, bool) { std::function sort_func; @@ -136,27 +131,22 @@ namespace blt container.thread = unit::S; return container; } - - inline void println(const std::vector&& lines, logging::log_level level) { - for (const auto& line : lines) - BLT_LOG_STREAM(level) << line << "\n"; - } - - void printProfile(profile_t& profiler, std::uint32_t flags, sort_by sort, blt::logging::log_level log_level) + + void writeProfile(std::ostream& stream, profile_t& profiler, std::uint32_t flags, sort_by sort) { bool printHistory = flags & AVERAGE_HISTORY; bool printCycles = flags & PRINT_CYCLES; bool printThread = flags & PRINT_THREAD; bool printWall = flags & PRINT_WALL; - + sort_intervals(profiler.intervals, sort, printHistory); - + auto units = determine_max_unit(profiler.intervals, printHistory); std::string thread_unit_string = units.thread == unit::MS ? "ms" : units.thread == unit::NS ? "ns" : "s"; std::string wall_unit_string = units.wall == unit::MS ? "ms" : units.wall == unit::NS ? "ns" : "s"; auto thread_unit_divide = units.thread == unit::MS ? 1e6 : units.thread == unit::NS ? 1 : 1e9; auto wall_unit_divide = units.wall == unit::MS ? 1e6 : units.wall == unit::NS ? 1 : 1e9; - + string::TableFormatter formatter{profiler.name}; formatter.addColumn("Order"); if (printHistory) @@ -168,17 +158,17 @@ namespace blt formatter.addColumn("CPU Time (" + thread_unit_string += ")"); if (printWall) formatter.addColumn("Wall Time (" + wall_unit_string += ")"); - + for (size_t i = 0; i < profiler.intervals.size(); i++) { blt::string::TableRow row; auto interval = profiler.intervals[i]; - + if (interval->count == 0) continue; - + INTERVAL_DIFFERENCE_MACRO(printHistory, interval); - + row.rowValues.push_back(std::to_string(i + 1)); if (printHistory) row.rowValues.push_back(std::to_string(interval->count)); @@ -191,8 +181,17 @@ namespace blt row.rowValues.push_back(std::to_string(wall / static_cast(wall_unit_divide))); formatter.addRow(row); } - - println(formatter.createTable(true, true), log_level); + + auto lines = formatter.createTable(true, true); + for (const auto& line : lines) + stream << line << "\n"; + } + + void printProfile(profile_t& profiler, const std::uint32_t flags, sort_by sort, blt::logging::log_level log_level) + { + std::stringstream stream; + writeProfile(stream, profiler, flags, sort); + BLT_LOG_STREAM(log_level) << stream.str(); } profile_t::~profile_t() @@ -226,7 +225,7 @@ namespace blt blt::endInterval(profiles[profile_name].at(interval_name)); } - void _internal::writeProfile(std::ifstream& stream, const std::string& profile_name) + void _internal::writeProfile(std::ostream& stream, const std::string& profile_name, std::uint32_t flags, sort_by sort) { if (profiles.find(profile_name) == profiles.end()) return; @@ -234,7 +233,7 @@ namespace blt profile_t profile{profile_name}; for (const auto& i : pref) profile.intervals.push_back(i.second); - blt::writeProfile(stream, profile); + blt::writeProfile(stream, profile, flags, sort); profiles.erase(profile_name); }