stacktrace.hpp

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
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambase/SourceLocation.hpp"
#include "shambase/aliases_float.hpp"
#include "shambase/aliases_int.hpp"
#include "shambase/profiling/profiling.hpp"
#include "shambase/string.hpp"
#include "shambase/unique_name_macro.hpp"
#include <stack>
 
namespace shambase::details {

    f64 get_wtime();
 
#ifdef SHAMROCK_USE_PROFILING

    void register_profile_entry_start(std::source_location loc, f64 start_time);

    void register_profile_entry(std::source_location loc, f64 start_time, f64 end_time);

    void dump_profilings(const std::string &process_prefix, u32 world_rank);

    void dump_profilings_chrome(const std::string &process_prefix, u32 world_rank);

    void clear_profiling_data();
 
#endif

    inline std::stack<SourceLocation> call_stack;

    struct CallStackEntry {
        inline CallStackEntry(SourceLocation &loc) {
            // Push the source location to the call stack
            call_stack.emplace(loc);
        }
 
        // This class is not safe if copied or moved
 
        CallStackEntry(const CallStackEntry &)            = delete;
        CallStackEntry &operator=(const CallStackEntry &) = delete;
        CallStackEntry(CallStackEntry &&)                 = delete;
        CallStackEntry &operator=(CallStackEntry &&)      = delete;
 
        inline ~CallStackEntry() {
            // Pop the source location from the call stack
            call_stack.pop();
        }
    };
 
    struct BasicStackEntry {
        SourceLocation loc; 
        bool do_timer;      
 
#ifdef SHAMROCK_USE_PROFILING
        f64 wtime_start; 
#endif
 
        CallStackEntry scoped_callstack_entry; 

        inline BasicStackEntry(bool do_timer = true, SourceLocation &&loc = SourceLocation{})
            : loc(loc), do_timer(do_timer), scoped_callstack_entry(loc) {
#ifdef SHAMROCK_USE_PROFILING
            if (do_timer) {
                wtime_start = get_wtime();
                shambase::profiling::stack_entry_start(loc, wtime_start);
            } else {
                shambase::profiling::stack_entry_start_no_time(loc);
            }
#endif
        }

        inline BasicStackEntry(
            SourceLocation &callsite, bool do_timer = true, SourceLocation &&loc = SourceLocation{})
            : loc(loc), do_timer(do_timer), scoped_callstack_entry(callsite) {
#ifdef SHAMROCK_USE_PROFILING
            if (do_timer) {
                wtime_start = get_wtime();
                shambase::profiling::stack_entry_start(loc, wtime_start);
            } else {
                shambase::profiling::stack_entry_start_no_time(loc);
            }
#endif
        }

        inline ~BasicStackEntry() {
#ifdef SHAMROCK_USE_PROFILING
            if (do_timer) {
                f64 wtime_end = get_wtime();
                shambase::profiling::stack_entry_end(loc, wtime_start, wtime_end);
            } else {
                shambase::profiling::stack_entry_end_no_time(loc);
            }
#endif
        }
    };
 
    struct NamedBasicStackEntry {
        SourceLocation loc; 
        bool do_timer;      
        std::string name;   
 
#ifdef SHAMROCK_USE_PROFILING
        f64 wtime_start; 
#endif
 
        CallStackEntry scoped_callstack_entry; 

        inline NamedBasicStackEntry(
            std::string name, bool do_timer = true, SourceLocation &&loc = SourceLocation{})
            : name(name), loc(loc), do_timer(do_timer), scoped_callstack_entry(loc) {
#ifdef SHAMROCK_USE_PROFILING
            if (do_timer) {
                wtime_start = get_wtime();
                shambase::profiling::stack_entry_start(loc, wtime_start, name);
            } else {
                shambase::profiling::stack_entry_start_no_time(loc, name);
            }
#endif
        }

        inline ~NamedBasicStackEntry() {
#ifdef SHAMROCK_USE_PROFILING
            if (do_timer) {
                f64 wtime_end = get_wtime();
                shambase::profiling::stack_entry_end(loc, wtime_start, wtime_end, name);
            } else {
                shambase::profiling::stack_entry_end_no_time(loc);
            }
#endif
        }
    };
 
} // namespace shambase::details
 
namespace shambase {

    std::string fmt_callstack();
 
    void set_callstack_process_identifier(std::string identifier);
 
    void add_callstack_gen_info_generator(std::string (*generator)());
 
} // namespace shambase

using StackEntry = shambase::details::BasicStackEntry;

using NamedStackEntry = shambase::details::NamedBasicStackEntry;

#define __shamrock_stack_entry()                                                                   \
    [[maybe_unused]] StackEntry __shamrock_unique_name(stack_loc_) {}

#define __shamrock_log_callsite(callsite)                                                          \
    [[maybe_unused]] shambase::details::CallStackEntry __shamrock_unique_name(call_site_loc) {     \
        callsite                                                                                   \
    }

#define __shamrock_stack_entry_with_callsite(callsite)                                             \
    [[maybe_unused]] StackEntry __shamrock_unique_name(stack_loc_) { callsite }