trace.cpp

Go to the documentation of this file.

#include "trace.h"
 
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <memory>
 
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
// /////////////////////////////////////////////// debug /////////////////////////////////////////////// //
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
#define ACTIVATE_TRACE_LIB_TERMINATE_ON_INTERNAL_ERROR
#ifdef ACTIVATE_TRACE_LIB_TERMINATE_ON_INTERNAL_ERROR
#define TerminateIf(...)                                                                           \
    {                                                                                              \
        if (__VA_ARGS__)                                                                           \
        {                                                                                          \
            std::cerr << "TERMINATING!:\n    (" << #__VA_ARGS__ << ") == true\n    "               \
                      << "'" << BOOST_CURRENT_FUNCTION << "' @ " << __LINE__ << " in '"            \
                      << __FILE__ << "'\n    "                                                     \
                      << "Stack Trace:\n";                                                         \
            Trace::PrintStackTrace(std::cerr, "        ");                                         \
            std::cerr << std::flush;                                                               \
            std::terminate();                                                                      \
        }                                                                                          \
    }                                                                                              \
    do                                                                                             \
    {                                                                                              \
    } while (false)
#else
#define TerminateIf(...)                                                                           \
    do                                                                                             \
    {                                                                                              \
    } while (false)
#endif
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
// /////////////////////////////////////////////// types /////////////////////////////////////////////// //
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
namespace armarx::detail
{
    struct ExceptionBacktraceTree
    {
        static void PrintExceptionBacktrace(std::ostream& out, const std::string& pre);
        static void ClearExceptionBacktrace();
 
        static thread_local ExceptionBacktraceTree* Active;
        static thread_local std::deque<ExceptionBacktraceTree> All;
 
        friend class Trace;
 
        ExceptionBacktraceTree(ExceptionBacktraceTree* parent) :
            parent{parent},
            parentEntryOffset{parent ? parent->entries.size() : 0},
            currentStackSize{Trace::GetStackTraceSize()}
        {
        }
 
        ExceptionBacktraceTree* const parent;
        const std::size_t parentEntryOffset;
 
        std::size_t currentStackSize;
        std::deque<ExceptionBacktraceTree> children;
        std::deque<LocationProvider> entries;
 
        void
        addEntry(const Trace* t) noexcept
        {
            entries.emplace_back(t->location);
            --currentStackSize;
        }
 
        void print(std::ostream& out, const std::string& prefix = "", std::size_t levelOffset = 0);
    };
} // namespace armarx::detail
 
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
// //////////////////////////////////////////////// data /////////////////////////////////////////////// //
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
namespace armarx::detail
{
    thread_local const Trace* Trace::Top = nullptr;
    thread_local std::uintmax_t Trace::Size = 0;
    thread_local ExceptionBacktraceTree* ExceptionBacktraceTree::Active = nullptr;
    thread_local std::deque<ExceptionBacktraceTree> ExceptionBacktraceTree::All;
} // namespace armarx::detail
 
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
// ///////////////////////////////////////////// management //////////////////////////////////////////// //
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
namespace armarx::detail
{
    void
    ExceptionBacktraceTree::ClearExceptionBacktrace()
    {
        ExceptionBacktraceTree::All.clear();
        ExceptionBacktraceTree::Active = nullptr;
    }
 
    void
    Trace::ClearExceptionBacktrace()
    {
        ExceptionBacktraceTree::ClearExceptionBacktrace();
    }
 
    Trace::~Trace()
    {
        TerminateIf(Top != this);
        if (exceptional())
        {
            if (ExceptionBacktraceTree::Active)
            {
                if (Size > ExceptionBacktraceTree::Active->currentStackSize)
                {
                    //add subtree
                    ExceptionBacktraceTree::Active->children.emplace_back(
                        ExceptionBacktraceTree::Active);
                    ExceptionBacktraceTree::Active =
                        &(ExceptionBacktraceTree::Active->children.back());
                }
                while (Size == (ExceptionBacktraceTree::Active->parent
                                    ? ExceptionBacktraceTree::Active->parent->currentStackSize
                                    : 0))
                {
                    //go to parent tree
                    ExceptionBacktraceTree::Active = ExceptionBacktraceTree::Active->parent;
                }
            }
            else
            {
                //add new root tree
                ExceptionBacktraceTree::All.emplace_back(nullptr);
                ExceptionBacktraceTree::Active = &ExceptionBacktraceTree::All.back();
            }
            //add entry to curent tree
            ExceptionBacktraceTree::Active->addEntry(this);
            while (ExceptionBacktraceTree::Active &&
                   Size - 1 == (ExceptionBacktraceTree::Active->parent
                                    ? ExceptionBacktraceTree::Active->parent->currentStackSize
                                    : 0))
            {
                //go to parent tree
                ExceptionBacktraceTree::Active = ExceptionBacktraceTree::Active->parent;
            }
        }
        else if (ExceptionBacktraceTree::Active)
        {
            auto p = ExceptionBacktraceTree::Active->parent;
            auto& deque = p ? p->children : ExceptionBacktraceTree::All;
            TerminateIf(&deque.back() != ExceptionBacktraceTree::Active);
            deque.pop_back();
            ExceptionBacktraceTree::Active = p;
        }
        Top = parent;
        --Size;
    }
} // namespace armarx::detail
 
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
// /////////////////////////////////////////////// output ////////////////////////////////////////////// //
// ///////////////////////////////////////////////////////////////////////////////////////////////////// //
namespace armarx::detail
{
    std::ostream&
    operator<<(std::ostream& out, const LocationProvider::Location& l)
    {
        return out << l.file << ":" << l.line << " : " << l.func;
    }
 
    std::ostream&
    operator<<(std::ostream& out, const LocationProvider& t)
    {
        return out << t.location();
    }
 
    std::ostream&
    operator<<(std::ostream& out, const Trace& t)
    {
        return out << t.location;
    }
 
    void
    Trace::PrintStackTrace(std::ostream& out, const std::string& pre)
    {
        const Trace* trace = Top;
 
        const auto numW = Size ? std::log10(Size) + 1 : 1;
 
        for (std::uintmax_t cnt = 0; trace; ++cnt, trace = trace->parent)
        {
            out << pre << std::setw(numW) << cnt << std::setw(0) << ": " << *trace << "\n";
        }
    }
 
    void
    ExceptionBacktraceTree::PrintExceptionBacktrace(std::ostream& out, const std::string& pre)
    {
        const auto numW = ExceptionBacktraceTree::All.size()
                              ? std::log10(ExceptionBacktraceTree::All.size()) + 1
                              : 1;
        for (std::size_t i = 0; i < ExceptionBacktraceTree::All.size(); ++i)
        {
            if (i)
            {
                out << "--------------------------" << std::string(numW, '-') << "\n";
            }
            if (ExceptionBacktraceTree::All.size() > 1)
            {
                out << "Exception Backtrace Tree " << std::setw(numW) << i << std::setw(0) << ":\n";
            }
            ExceptionBacktraceTree::All.at(i).print(out, pre);
            Trace::PrintStackTrace(out, pre + "*  ");
        }
    }
 
    void
    Trace::PrintExceptionBacktrace(std::ostream& out, const std::string& pre)
    {
        ExceptionBacktraceTree::PrintExceptionBacktrace(out, pre);
    }
 
    void
    ExceptionBacktraceTree::print(std::ostream& out,
                                  const std::string& prefix,
                                  std::size_t levelOffset)
    {
        TerminateIf(entries.empty());
        const auto numW = std::log10(entries.size()) + 1;
 
        std::size_t nextChildParentEntryOffset = std::numeric_limits<std::size_t>::max();
 
        std::size_t nextChildIndex = 0;
        auto updateNextChildEntryOffset = [&]
        {
            nextChildParentEntryOffset = std::numeric_limits<std::size_t>::max();
            if (nextChildIndex < children.size())
            {
                nextChildParentEntryOffset = children.at(nextChildIndex).parentEntryOffset;
            }
        };
        updateNextChildEntryOffset();
 
        for (std::size_t entryIdx = 0; entryIdx < entries.size(); ++entryIdx)
        {
            const std::size_t level =
                /*parentEntryOffset +*/ levelOffset + entries.size() - entryIdx;
            while (entryIdx >= nextChildParentEntryOffset && nextChildIndex < children.size())
            {
                children.at(nextChildIndex).print(out, prefix + "| ", level);
                out << prefix << "|/\n";
                ++nextChildIndex;
                updateNextChildEntryOffset();
            }
            out << prefix << "* -" << std::setw(numW) << level << std::setw(0) << ": "
                << entries.at(entryIdx) << "\n";
        }
        //print children after this branch
        for (; nextChildIndex < children.size(); ++nextChildIndex)
        {
            children.at(nextChildIndex).print(out, prefix + "| ");
            out << prefix << "|/\n";
        }
    }
} // namespace armarx::detail