stacktrace.cpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//

 
#include "shambase/stacktrace.hpp"
#include "shambase/time.hpp"
#include "sham/format/format.hpp"
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
 
namespace shambase::details {

    struct ChromeProfileEntry {
        std::string name; 
        u64 time_val;     
        bool is_start;    

        std::string format(u32 world_rank);
    };
 
    std::string ChromeProfileEntry::format(u32 world_rank) {
        if (is_start) {
            return sham::format_printf(
                R"({
                "cat": "%s",
                "pid": %d,
                "tid": %d,
                "ts": %zu,
                "ph": "B",
                "name": "%s",
                "args": {
                }
            })",
                name.c_str(),
                world_rank,
                world_rank,
                time_val,
                name.c_str());
 
        } else {
            return sham::format_printf(
                R"({
                "cat": "%s",
                "pid": %d,
                "tid": %d,
                "ts": %zu,
                "ph": "E",
                "name": "%s",
                "args": {
                }
            })",
                name.c_str(),
                world_rank,
                world_rank,
                time_val,
                name.c_str());
        }
    }

    std::vector<ChromeProfileEntry> profile_data_chrome;

     * @param is_start Whether the entry is a start or end entry
     */
    inline void add_entry_chrome(std::source_location loc, f64 time, bool is_start) {
        // Convert time to microseconds
        auto to_prof_time = [](f64 in) {
            return static_cast<u64>(in * 1e6);
        };
        // Add the entry to the storage
        profile_data_chrome.push_back(
            ChromeProfileEntry{
                .name = loc.function_name(), .time_val = to_prof_time(time), .is_start = is_start});
    }

    inline void clear_chrome_entry() { profile_data_chrome.clear(); }
 
    void dump_profilings_chrome(const std::string &process_prefix, u32 world_rank) {
 
        // Open the file for writing
        std::ofstream outfile(process_prefix + std::to_string(world_rank));
        // Write the start of the JSON array
        outfile << "[";
 
        // Write each entry
        u32 len = profile_data_chrome.size();
 
        for (u32 i = 0; i < len; i++) {
            // Write the entry in the JSON format
            outfile << profile_data_chrome[i].format(world_rank);
            // Add a comma if it's not the last entry
            if (i != len - 1) {
                outfile << ",";
            }
        }
 
        // Write the end of the JSON array
        outfile << "]";
        // Close the file
        outfile.close();
    }
 
} // namespace shambase::details
 
namespace shambase::details {

    auto make_timer = []() -> Timer {
        Timer tmp;
        tmp.start();
        return tmp;
    };

    Timer global_timer = make_timer();
 
    // two entry types,
    //  one with start, end
    //  one with start, end as separate envents

    struct ProfileEntry {
        f64 time_start;         
        f64 time_end;           
        std::string entry_name; 

        std::string format() {
            return sham::format_printf(
                R"({"tstart": %f, "tend": %f, "name": "%s"})", time_start, time_end, entry_name);
        }
    };

    std::vector<ProfileEntry> profile_data;

    f64 get_wtime() {
        global_timer.stop();
        return global_timer.elapsed_sec();
    }
 
    void register_profile_entry_start(std::source_location loc, f64 start_time) {
        add_entry_chrome(loc, start_time, true);
    };
 
    void register_profile_entry(std::source_location loc, f64 start_time, f64 end_time) {
        // Add the profile entry to the storage
        profile_data.push_back(
            {.time_start = start_time, .time_end = end_time, .entry_name = loc.function_name()});
        // Add a Chrome profiling entry to the storage
        add_entry_chrome(loc, end_time, false);
    };
 
    void clear_profiling_data() {
        profile_data.clear();
        clear_chrome_entry();
    }
 
    void dump_profilings(const std::string &process_prefix, u32 world_rank) {
        std::ofstream outfile(process_prefix + std::to_string(world_rank));
        outfile << "[";
 
        u32 len = profile_data.size();
 
        for (u32 i = 0; i < len; i++) {
            outfile << profile_data[i].format();
            if (i != len - 1) {
                outfile << ",";
            }
        }
 
        outfile << "]";
        outfile.close();
    }
 
} // namespace shambase::details
 
namespace shambase {
 
    std::string _callstack_process_identifier;
 
    void set_callstack_process_identifier(std::string identifier) {
        _callstack_process_identifier = std::move(identifier);
    }
 
    std::vector<std::function<std::string()>> _callstack_gen_info_generators;
 
    void add_callstack_gen_info_generator(std::string (*generator)()) {
        _callstack_gen_info_generators.push_back(std::move(generator));
    }

    std::string fmt_callstack() {
        std::stack<SourceLocation> cpy = details::call_stack;
 
        std::vector<std::string> lines;
 
        while (!cpy.empty()) {
            SourceLocation l = cpy.top();
            lines.push_back(l.format_one_line_func());
            cpy.pop();
        }
 
        std::reverse(lines.begin(), lines.end());
 
        std::stringstream ss;
 
        if (!_callstack_process_identifier.empty()) {
            ss << "  -> process identifier: " << _callstack_process_identifier << "\n";
        }
 
        for (u32 i = 0; i < lines.size(); i++) {
            ss << sham::format(" {:2} : {}\n", i, lines[i]);
        }
 
        for (auto &generator : _callstack_gen_info_generators) {
            ss << generator() << "\n";
        }
 
        return ss.str();
    }
 
} // namespace shambase