alloc_trace.h

/*
 * SPDX-FileCopyrightText: 2023 Intel
 * Copyright 2023-present Intel
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef LIB_ALLOC_TRACE_H_
#define LIB_ALLOC_TRACE_H_
 
#include <map>
#include <ostream>
 
#include "config.h"
#include "exceptions.h"
#include "gc.h"
 
namespace P4 {
 
class AllocTrace {
    struct backtrace {
        void *trace[ALLOC_TRACE_DEPTH];
 
        backtrace(const backtrace &) = default;
        explicit backtrace(void **bt) { memcpy(trace, bt, sizeof(trace)); }
        bool operator<(const backtrace &a) const {
            for (int i = 0; i < ALLOC_TRACE_DEPTH; ++i)
                if (trace[i] != a.trace[i]) return trace[i] < a.trace[i];
            return false;
        }
        bool operator==(const backtrace &a) const {
            for (int i = 0; i < ALLOC_TRACE_DEPTH; ++i)
                if (trace[i] != a.trace[i]) return false;
            return true;
        }
    };
    std::map<backtrace, std::map<size_t, int>> data;
    void count(void **, size_t);
    static void callback(void *t, void **bt, size_t sz) {
        static_cast<AllocTrace *>(t)->count(bt, sz);
    }
 
 public:
    void clear() { data.clear(); }
#if HAVE_LIBGC
    alloc_trace_cb_t start() { return set_alloc_trace(callback, this); }
    void stop(alloc_trace_cb_t old) {
        auto tmp = set_alloc_trace(old);
        BUG_CHECK(tmp.fn == callback && tmp.arg == this, "AllocTrace stopped when not running");
    }
#else
    alloc_trace_cb_t start() {
        BUG("Can't trace allocations without garbage collection");
        return alloc_trace_cb_t{};
    }
    void stop(alloc_trace_cb_t) {}
#endif
    friend std::ostream &operator<<(std::ostream &, const AllocTrace &);
};
 
class PauseTrace {
#if HAVE_LIBGC
    alloc_trace_cb_t hold;
    PauseTrace(const PauseTrace &) = delete;
 
 public:
    PauseTrace() { hold = set_alloc_trace(nullptr, nullptr); }
    ~PauseTrace() { set_alloc_trace(hold); }
#endif
};
 
}  // namespace P4
 
#endif /* LIB_ALLOC_TRACE_H_ */