easy_profiler

Use macros to instrument your code. EASY_FUNCTION profiles an entire function, while EASY_BLOCK profiles a specific scope. Blocks can be colored using profiler::colors or custom ARGB values. Scoped blocks (using EASY_BLOCK without a manual EASY_END_BLOCK) are automatically closed when the scope ends via destructor.

#include <easy/profiler.h>

void foo() {
    EASY_FUNCTION(profiler::colors::Magenta); // Magenta block with name "foo"

    EASY_BLOCK("Calculating sum"); // Begin block with default color == Amber100
    int sum = 0;
    for (int i = 0; i < 10; ++i) {
        EASY_BLOCK("Addition", profiler::colors::Red); // Scoped red block (no EASY_END_BLOCK needed)
        sum += i;
    }
    EASY_END_BLOCK; // End of "Calculating sum" block

    EASY_BLOCK("Calculating multiplication", profiler::colors::Blue500); // Blue block
    int mul = 1;
    for (int i = 1; i < 11; ++i)
        mul *= i;
    //EASY_END_BLOCK; // This is not needed because all blocks are ended on destructor when closing braces met
}

void bar() {
    EASY_FUNCTION(0xfff080aa); // Function block with custom ARGB color
}

void baz() {
    EASY_FUNCTION(); // Function block with default color == Amber100
}

You can capture variable values and arrays during profiling using EASY_VALUE and EASY_ARRAY. These are defined in <easy/arbitrary_value.h>. To ensure a variable's identity remains consistent even if its address changes (e.g., a local variable in a loop), use the EASY_VIN macro.

#include <easy/profiler.h>
#include <easy/arbitrary_value.h> // EASY_VALUE, EASY_ARRAY are defined here

class Object {
    Vector3 m_position; // Let's suppose Vector3 is a struct { float x, y, z; };
    unsigned int  m_id;
public:
    void act() {
        EASY_FUNCTION(profiler::colors::Cyan);

        // Dump variables values
        constexpr auto Size = sizeof(Vector3) / sizeof(float);
        EASY_VALUE("id", m_id);
        EASY_ARRAY("position", &m_position.x, Size, profiler::color::Red);

        // Do something ...
    }

    void loop(uint32_t N) {
        EASY_FUNCTION();
        EASY_VALUE("N", N, EASY_VIN("N")); /* EASY_VIN is used here to ensure
                                            that this value id will always be
                                            the same, because the address of N
                                            can change */
        for (uint32_t i = 0; i < N; ++i) {
            // Do something
        }
    }
};

The fillTreesFromFile function is used to parse a profiling file and populate various data structures representing the collected profiling information, including blocks, descriptors, and bookmarks.

Parameters:

• filename: C-string path to the input file.
• beginEndTime: profiler::BeginEndTime object to store start/end timestamps.
• serialized_blocks: profiler::SerializedData for serialized block data.
• serialized_descriptors: profiler::SerializedData for serialized descriptor data.
• descriptors: profiler::descriptors_list_t to be populated with descriptors.
• blocks: profiler::blocks_t to be populated with blocks.
• threaded_trees: profiler::thread_blocks_tree_t to be populated with the hierarchical tree structure of blocks per thread.
• bookmarks: profiler::bookmarks_t to be populated with bookmarks.
• descriptorsNumberInFile: Pointer/reference to uint32_t to store the count of descriptors found.
• version: Pointer/reference to uint32_t to store the file version.
• pid: Pointer/reference to profiler::processid_t to store the process ID.
• is_verbose: Boolean flag for verbosity.
• errorMessage: std::stringstream to capture error details if reading fails.

Returns:

• The number of blocks successfully read (as a uint32_t). If this returns 0, the operation failed, and the reason is available in errorMessage.