library.cpp File Reference

#include "timemory/compat/library.h"
#include "timemory/config.hpp"
#include "timemory/library.h"
#include "timemory/runtime/configure.hpp"
#include "timemory/timemory.hpp"
#include "timemory/trace.hpp"
#include <cstdarg>
#include <deque>
#include <iostream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>

Include dependency graph for library.cpp:

Go to the source code of this file.

Macros
#define	TIMEMORY_LIBRARY_SOURCE   1

Typedefs
using	string_t = std::string
using	library_toolset_t = TIMEMORY_LIBRARY_TYPE
using	toolset_t = typename library_toolset_t::component_type
using	region_map_t = std::unordered_map< std::string, std::stack< uint64_t > >
using	record_map_t = std::unordered_map< uint64_t, toolset_t >
using	component_enum_t = std::vector< TIMEMORY_COMPONENT >
using	components_stack_t = std::deque< component_enum_t >

Functions
std::string &	get_default_components ()
component_enum_t &	get_current_components ()
std::array< bool, 2 > &	get_library_state ()
uint64_t	timemory_get_unique_id (void)
	Returns a unique integer for a thread. More...
void	timemory_create_record (const char *name, uint64_t *id, int n, int *ctypes)
void	timemory_delete_record (uint64_t id)
	Deletes the record created by timemory_create_record. More...
bool	timemory_library_is_initialized (void)
	Returns whether the library is initialized or not. More...
void	timemory_named_init_library (char *name)
void	timemory_init_library (int argc, char **argv)
	Initializes timemory. Not strictly necessary but highly recommended. More...
void	timemory_finalize_library (void)
	Finalizes timemory. Output will be generated. Any attempt to store data within timemory storage is undefined after this point and will likely cause errors. More...
void	timemory_pause (void)
	Turn off timemory collection. More...
void	timemory_resume (void)
	Turn on timemory collection. More...
void	timemory_set_default (const char *_component_string)
	Pass in a default set of components to use. Will be overridden by TIMEMORY_COMPONENTS environment variable. More...
void	timemory_set_environ (const char *evar, const char *eval, int over, int parse)
void	timemory_add_components (const char *_component_string)
	Add some components to the current set of components being collected Any components which are currently being collected are ignored. More...
void	timemory_remove_components (const char *_component_string)
	Remove some components to the current set of components being collected. Any components which are not currently being collected are ignored. More...
void	timemory_push_components (const char *_component_string)
	Replace the current set of components with a new set of components. More...
void	timemory_push_components_enum (int types,...)
	Replace the current set of components with a new set of components with the set of enumerations provided to the function. First argument should be the number of new components. More...
void	timemory_pop_components (void)
	Inverse of the last timemory_push_components or timemory_push_components_enum call. Popping all components will restore to set the configured as the default. More...
void	timemory_begin_record (const char *name, uint64_t *id)
void	timemory_begin_record_types (const char *name, uint64_t *id, const char *ctypes)
	Similar to timemory_begin_record but accepts a specific set of components as a string. More...
void	timemory_begin_record_enum (const char *name, uint64_t *id,...)
	Similar to timemory_begin_record but accepts a specific enumerated set of components, which is terminated by TIMEMORY_COMPONENTS_END. More...
uint64_t	timemory_get_begin_record (const char *name)
	Variant to timemory_begin_record which returns a unique integer. More...
uint64_t	timemory_get_begin_record_types (const char *name, const char *ctypes)
	Variant to timemory_begin_record_types which returns a unique integer. More...
uint64_t	timemory_get_begin_record_enum (const char *name,...)
	Variant to timemory_begin_record_enum which returns a unique integer. More...
void	timemory_end_record (uint64_t id)
void	timemory_push_region (const char *name)
void	timemory_pop_region (const char *name)
void	timemory_create_record_ (const char *name, uint64_t *id, int n, int *ct)
void	timemory_delete_record_ (uint64_t id)
void	timemory_init_library_ (int argc, char **argv)
void	timemory_finalize_library_ (void)
void	timemory_set_default_ (const char *components)
void	timemory_push_components_ (const char *components)
void	timemory_pop_components_ (void)
void	timemory_begin_record_ (const char *name, uint64_t *id)
void	timemory_begin_record_types_ (const char *name, uint64_t *id, const char *ctypes)
uint64_t	timemory_get_begin_record_ (const char *name)
uint64_t	timemory_get_begin_record_types_ (const char *name, const char *ctypes)
void	timemory_end_record_ (uint64_t id)
void	timemory_push_region_ (const char *name)
void	timemory_pop_region_ (const char *name)

Variables
timemory_create_func_t	timemory_create_function = nullptr
	The function pointer to set to customize which components are used by library interface. More...
timemory_delete_func_t	timemory_delete_function = nullptr
	The function pointer to set which deletes an entry created by timemory_create_function. More...

Macro Definition Documentation

TIMEMORY_LIBRARY_SOURCE

#define TIMEMORY_LIBRARY_SOURCE   1

Definition at line 26 of file library.cpp.

Typedef Documentation

component_enum_t

using component_enum_t = std::vector<TIMEMORY_COMPONENT>

Definition at line 62 of file library.cpp.

components_stack_t

using components_stack_t = std::deque<component_enum_t>

Definition at line 63 of file library.cpp.

library_toolset_t

using library_toolset_t = TIMEMORY_LIBRARY_TYPE

Definition at line 58 of file library.cpp.

record_map_t

using record_map_t = std::unordered_map<uint64_t, toolset_t>

Definition at line 61 of file library.cpp.

region_map_t

using region_map_t = std::unordered_map<std::string, std::stack<uint64_t> >

Definition at line 60 of file library.cpp.

string_t

using string_t = std::string

Definition at line 57 of file library.cpp.

toolset_t

using toolset_t = typename library_toolset_t::component_type

Definition at line 59 of file library.cpp.

Function Documentation

get_current_components()

component_enum_t & get_current_components ( )

inline

Definition at line 113 of file library.cpp.

{
    auto& _stack = get_components_stack();
    if(_stack.empty())
    {
        _stack.push_back(
            tim::enumerate_components(get_default_components(), "TIMEMORY_COMPONENTS"));
    }
    return _stack.back();
}

Referenced by timemory_add_components(), timemory_begin_record(), timemory_get_begin_record(), and timemory_remove_components().

get_default_components()

std::string & get_default_components ( )

inline

Definition at line 102 of file library.cpp.

{
    static std::string _instance =
        tim::get_env<std::string>("TIMEMORY_GLOBAL_COMPONENTS", "wall_clock");
    return _instance;
}

Referenced by timemory_set_default().

get_library_state()

std::array< bool, 2 > & get_library_state

(

)

Definition at line 127 of file library.cpp.

{
    static auto _instance = std::array<bool, 2>({ { false, false } });
    return _instance;
}

Referenced by timemory_finalize_library(), timemory_init_library(), timemory_library_is_initialized(), timemory_pop_trace(), timemory_pop_trace_hash(), timemory_push_trace(), timemory_push_trace_hash(), timemory_trace_is_initialized(), and timemory_trace_set_env().

timemory_add_components()

void timemory_add_components

(

const char *

components

)

Add some components to the current set of components being collected Any components which are currently being collected are ignored.

timemory_add_components("peak_rss, priority_context_switch");

Definition at line 348 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        auto&                                 _stack = get_current_components();
        for(auto itr : tim::enumerate_components(_component_string))
            _stack.push_back(itr);
    }

References tim::enumerate_components(), and get_current_components().

timemory_begin_record()

void timemory_begin_record	(	const char *	name,
		uint64_t *	id
	)

Parameters

[in]	name	Label for the record
[in,out]	id	identifier passed back to timemory_end_record

uint64_t idx = 0;
timemory_begin_record("foo", &idx);
// ...
timemory_end_record(idx);

Definition at line 409 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk || tim::settings::enabled() == false)
        {
            *id = std::numeric_limits<uint64_t>::max();
            return;
        }
        auto& comp = get_current_components();
        timemory_create_record(name, id, comp.size(), (int*) (comp.data()));
 
#if defined(DEBUG)
        if(tim::settings::verbose() > 2)
            printf("beginning record for '%s' (id = %lli)...\n", name,
                   (long long int) *id);
#endif
    }

References tim::enabled, get_current_components(), std::max(), timemory_create_record(), and tim::verbose.

Referenced by timemory_begin_record_().

timemory_begin_record_()

void timemory_begin_record_	(	const char *	name,
		uint64_t *	id
	)

Definition at line 638 of file library.cpp.

    {
        timemory_begin_record(name, id);
    }

References timemory_begin_record().

timemory_begin_record_enum()

void timemory_begin_record_enum	(	const char *	name,
		uint64_t *	id,
			...
	)

Similar to timemory_begin_record but accepts a specific enumerated set of components, which is terminated by TIMEMORY_COMPONENTS_END.

uint64_t idx = 0;
timemory_begin_record("foo", &idx, WALL_CLOCK, CPU_UTIL, TIMEMORY_COMPONENTS_END);
// ...
timemory_end_record(idx);

Definition at line 450 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk || tim::settings::enabled() == false)
        {
            *id = std::numeric_limits<uint64_t>::max();
            return;
        }
 
        component_enum_t comp;
        va_list          args;
        va_start(args, id);
        for(int i = 0; i < TIMEMORY_COMPONENTS_END; ++i)
        {
            auto enum_arg = va_arg(args, int);
            if(enum_arg >= TIMEMORY_COMPONENTS_END)
                break;
            comp.push_back(enum_arg);
        }
        va_end(args);
 
        timemory_create_record(name, id, comp.size(), (int*) (comp.data()));
 
#if defined(DEBUG)
        if(tim::settings::verbose() > 2)
            printf("beginning record for '%s' (id = %lli)...\n", name,
                   (long long int) *id);
#endif
    }

References tim::enabled, std::max(), TIMEMORY_COMPONENTS_END, timemory_create_record(), and tim::verbose.

timemory_begin_record_types()

void timemory_begin_record_types	(	const char *	name,
		uint64_t *	id,
		const char *	ctypes
	)

Similar to timemory_begin_record but accepts a specific set of components as a string.

uint64_t idx = 0;
timemory_begin_record_types("foo", &idx, "wall_clock, cpu_util");
// ...
timemory_end_record(idx);

Definition at line 429 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk || tim::settings::enabled() == false)
        {
            *id = std::numeric_limits<uint64_t>::max();
            return;
        }
 
        auto comp = tim::enumerate_components(std::string(ctypes));
        timemory_create_record(name, id, comp.size(), (int*) (comp.data()));
 
#if defined(DEBUG)
        if(tim::settings::verbose() > 2)
            printf("beginning record for '%s' (id = %lli)...\n", name,
                   (long long int) *id);
#endif
    }

References tim::enabled, tim::enumerate_components(), std::max(), timemory_create_record(), and tim::verbose.

Referenced by timemory_begin_record_types_().

timemory_begin_record_types_()

void timemory_begin_record_types_	(	const char *	name,
		uint64_t *	id,
		const char *	ctypes
	)

Definition at line 643 of file library.cpp.

    {
        timemory_begin_record_types(name, id, ctypes);
    }

References timemory_begin_record_types().

timemory_create_record()

void timemory_create_record	(	const char *	name,
		uint64_t *	id,
		int	n,
		int *	ct
	)

Parameters

[in]	name	label for the record
[in,out]	id	assigned a unique identifier for the record
[in]	n	number of components
[in]	ct	array of enumeration identifiers of size n

Function called by timemory_begin_record, timemory_begin_record_enum, timemory_begin_record_types, timemory_get_begin_record, timemory_get_begin_record_enum, timemory_get_begin_record_types, timemory_push_region for creating and starting the current collection of components.

Definition at line 156 of file library.cpp.

    {
        if(timemory_create_function)
        {
            (*timemory_create_function)(name, id, n, ctypes);
            return;
        }
        // else: provide default behavior
 
        static thread_local auto& _record_map = get_record_map();
        *id                                   = timemory_get_unique_id();
        _record_map.insert({ *id, toolset_t(name, true) });
        tim::initialize(_record_map[*id], n, ctypes);
        _record_map[*id].start();
        if(_record_map.bucket_count() > _record_map.size())
            _record_map.rehash(_record_map.size() + 10);
    }

References timemory_create_function.

Referenced by timemory_begin_record(), timemory_begin_record_enum(), timemory_begin_record_types(), timemory_create_record_(), timemory_get_begin_record(), timemory_get_begin_record_enum(), and timemory_get_begin_record_types().

timemory_create_record_()

void timemory_create_record_	(	const char *	name,
		uint64_t *	id,
		int	n,
		int *	ct
	)

Definition at line 612 of file library.cpp.

    {
        timemory_create_record(name, id, n, ct);
    }

References timemory_create_record().

timemory_delete_record()

void timemory_delete_record

(

uint64_t

id

)

Deletes the record created by timemory_create_record.

Definition at line 177 of file library.cpp.

    {
        if(timemory_delete_function)
        {
            (*timemory_delete_function)(id);
        }
        else if(get_record_map().find(id) != get_record_map().end())
        {
            static thread_local auto& _record_map = get_record_map();
            // stop recording, destroy objects, and erase key from map
            _record_map[id].stop();
            _record_map.erase(id);
        }
    }

References timemory_delete_function.

Referenced by timemory_delete_record_(), and timemory_end_record().

timemory_delete_record_()

void timemory_delete_record_

(

uint64_t

id

)

Definition at line 617 of file library.cpp.

{ timemory_delete_record(id); }

References timemory_delete_record().

timemory_end_record()

void timemory_end_record

(

uint64_t

id

)

Parameters

[in]

id

Identifier for the recording entry

Definition at line 557 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk || id == std::numeric_limits<uint64_t>::max())
            return;
 
        timemory_delete_record(id);
 
#if defined(DEBUG)
        if(tim::settings::verbose() > 2)
            printf("ending record for %lli...\n", (long long int) id);
#endif
    }

References std::max(), timemory_delete_record(), and tim::verbose.

Referenced by timemory_end_record_().

timemory_end_record_()

void timemory_end_record_

(

uint64_t

id

)

Definition at line 658 of file library.cpp.

{ return timemory_end_record(id); }

References timemory_end_record().

timemory_finalize_library()

void timemory_finalize_library

(

void

)

Finalizes timemory. Output will be generated. Any attempt to store data within timemory storage is undefined after this point and will likely cause errors.

Definition at line 253 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        get_library_state()[1] = true;
 
        auto  _manager  = tim::manager::master_instance();
        auto* _settings = tim::settings::instance();
        if(!_manager || !_settings)
            return;
 
        if(_settings->get_enabled() == false && get_record_map().empty())
            return;
 
        auto& _record_map = get_record_map();
 
        if(_settings->get_verbose() > 0)
        {
            printf("\n%s\n", spacer.c_str());
            printf("\tFinalization of timemory library...\n");
            printf("%s\n\n", spacer.c_str());
        }
 
        // put keys into a set so that a potential LD_PRELOAD for timemory_delete_record
        // is called and there is not a concern for the map iterator
        std::unordered_set<uint64_t> keys;
        for(auto& itr : _record_map)
            keys.insert(itr.first);
 
        // delete all the records
        for(const auto& itr : keys)
            timemory_delete_record(itr);
 
        // clear the map
        _record_map.clear();
 
        // have the manager finalize
        if(tim::manager::instance())
            tim::manager::instance()->finalize();
 
        // do the finalization
        tim::timemory_finalize();
 
        // just in case
        _settings->get_enabled() = false;
 
        // set the finalization state to true
        tim::dmp::set_finalized(true);
 
        // reset manager
        tim::manager::instance().reset();
 
        // PGI and Intel compilers don't respect destruction order
#if defined(__PGI) || defined(__INTEL_COMPILER)
        _settings->get_output() = false;
#endif
    }

References get_library_state().

Referenced by c_timemory_finalize(), and timemory_finalize_library_().

timemory_finalize_library_()

void timemory_finalize_library_

(

void

)

Definition at line 624 of file library.cpp.

{ timemory_finalize_library(); }

References timemory_finalize_library().

timemory_get_begin_record()

uint64_t timemory_get_begin_record

(

const char *

name

)

Variant to timemory_begin_record which returns a unique integer.

Definition at line 482 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk || tim::settings::enabled() == false)
            return std::numeric_limits<uint64_t>::max();
 
        uint64_t id   = 0;
        auto&    comp = get_current_components();
        timemory_create_record(name, &id, comp.size(), (int*) (comp.data()));
 
#if defined(DEBUG)
        if(tim::settings::verbose() > 2)
            printf("beginning record for '%s' (id = %lli)...\n", name,
                   (long long int) id);
#endif
 
        return id;
    }

References tim::enabled, get_current_components(), std::max(), timemory_create_record(), and tim::verbose.

Referenced by timemory_get_begin_record_().

timemory_get_begin_record_()

uint64_t timemory_get_begin_record_

(

const char *

name

)

Definition at line 648 of file library.cpp.

    {
        return timemory_get_begin_record(name);
    }

References timemory_get_begin_record().

timemory_get_begin_record_enum()

uint64_t timemory_get_begin_record_enum	(	const char *	name,
			...
	)

Variant to timemory_begin_record_enum which returns a unique integer.

Definition at line 524 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk || tim::settings::enabled() == false)
            return std::numeric_limits<uint64_t>::max();
 
        uint64_t id = 0;
 
        component_enum_t comp;
        va_list          args;
        va_start(args, name);
        for(int i = 0; i < TIMEMORY_COMPONENTS_END; ++i)
        {
            auto enum_arg = va_arg(args, int);
            if(enum_arg >= TIMEMORY_COMPONENTS_END)
                break;
            comp.push_back(enum_arg);
        }
        va_end(args);
 
        timemory_create_record(name, &id, comp.size(), (int*) (comp.data()));
 
#if defined(DEBUG)
        if(tim::settings::verbose() > 2)
            printf("beginning record for '%s' (id = %lli)...\n", name,
                   (long long int) id);
#endif
 
        return id;
    }

References tim::enabled, std::max(), TIMEMORY_COMPONENTS_END, timemory_create_record(), and tim::verbose.

timemory_get_begin_record_types()

uint64_t timemory_get_begin_record_types	(	const char *	name,
		const char *	ctypes
	)

Variant to timemory_begin_record_types which returns a unique integer.

Definition at line 503 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk || tim::settings::enabled() == false)
            return std::numeric_limits<uint64_t>::max();
 
        uint64_t id   = 0;
        auto     comp = tim::enumerate_components(std::string(ctypes));
        timemory_create_record(name, &id, comp.size(), (int*) (comp.data()));
 
#if defined(DEBUG)
        if(tim::settings::verbose() > 2)
            printf("beginning record for '%s' (id = %lli)...\n", name,
                   (long long int) id);
#endif
 
        return id;
    }

References tim::enabled, tim::enumerate_components(), std::max(), timemory_create_record(), and tim::verbose.

Referenced by timemory_get_begin_record_types_().

timemory_get_begin_record_types_()

uint64_t timemory_get_begin_record_types_	(	const char *	name,
		const char *	ctypes
	)

Definition at line 653 of file library.cpp.

    {
        return timemory_get_begin_record_types(name, ctypes);
    }

References timemory_get_begin_record_types().

timemory_get_unique_id()

uint64_t timemory_get_unique_id

(

void

)

Returns a unique integer for a thread.

Definition at line 144 of file library.cpp.

    {
        // the maps are thread-local so no concerns for data-race here since
        // two threads updating at once and subsequently losing once of the updates
        // still results in a unique id for that thread
        static uint64_t uniqID = 0;
        return uniqID++;
    }

timemory_init_library()

void timemory_init_library	(	int	argc,
		char **	argv
	)

Initializes timemory. Not strictly necessary but highly recommended.

Definition at line 212 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(get_library_state()[0])
            return;
        get_library_state()[0] = true;
 
        if(argc < 1 && argv)
            argc = 1;
        if(argv == nullptr)
        {
            argc = 0;
        }
        else
        {
            int i = 0;
            for(; i < argc; ++i)
            {
                if(argv[i] == nullptr)
                {
                    argc = i;
                    break;
                }
            }
        }
 
        if(tim::settings::verbose() > 0)
        {
            printf("%s\n", spacer.c_str());
            printf("\tInitialization of timemory library...\n");
            printf("%s\n\n", spacer.c_str());
        }
 
        if(argc > 0 && argv)
            tim::timemory_init(argc, argv);
        tim::manager::instance()->update_metadata_prefix();
        // tim::settings::parse();
    }

References tim::argv, get_library_state(), and tim::verbose.

Referenced by c_timemory_init(), timemory_init_library_(), timemory_named_init_library(), and timemory_trace_init().

timemory_init_library_()

void timemory_init_library_	(	int	argc,
		char **	argv
	)

Definition at line 619 of file library.cpp.

    {
        timemory_init_library(argc, argv);
    }

References tim::argv, and timemory_init_library().

timemory_library_is_initialized()

bool timemory_library_is_initialized

(

void

)

Returns whether the library is initialized or not.

Definition at line 195 of file library.cpp.

{ return get_library_state()[0]; }

References get_library_state().

timemory_named_init_library()

void timemory_named_init_library

(

char *

name

)

Definition at line 200 of file library.cpp.

    {
        if(name)
        {
            char* _name[1] = { name };
            timemory_init_library(1, _name);
        }
    }

References timemory_init_library().

timemory_pause()

void timemory_pause

(

void

)

Turn off timemory collection.

Definition at line 313 of file library.cpp.

{ tim::settings::enabled() = false; }

References tim::enabled.

timemory_pop_components()

void timemory_pop_components

(

void

)

Inverse of the last timemory_push_components or timemory_push_components_enum call. Popping all components will restore to set the configured as the default.

Definition at line 399 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        static thread_local auto&             _stack = get_components_stack();
        if(_stack.size() > 1)
            _stack.pop_back();
    }

Referenced by timemory_pop_components_().

timemory_pop_components_()

void timemory_pop_components_

(

void

)

Definition at line 636 of file library.cpp.

{ timemory_pop_components(); }

References timemory_pop_components().

timemory_pop_region()

void timemory_pop_region

(

const char *

name

)

Parameters

[in]

name

label for region

Stops collection of components with label.

void foo()
{
    timemory_push_region("foo");
    // ...
    timemory_pop_region("foo");
}

Definition at line 587 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk)
            return;
        auto& region_map = get_region_map();
        auto  itr        = region_map.find(name);
        if(itr == region_map.end() || (itr != region_map.end() && itr->second.empty()))
            fprintf(stderr, "Warning! region '%s' does not exist!\n", name);
        else
        {
            uint64_t idx = itr->second.top();
            lk.release();
            timemory_end_record(idx);
            lk = tim::trace::lock<tim::trace::library>{};
            itr->second.pop();
        }
    }

Referenced by timemory_pop_region_().

timemory_pop_region_()

void timemory_pop_region_

(

const char *

name

)

Definition at line 662 of file library.cpp.

{ return timemory_pop_region(name); }

References timemory_pop_region().

timemory_push_components()

void timemory_push_components

(

const char *

components

)

Replace the current set of components with a new set of components.

timemory_push_components("priority_context_switch, read_bytes");

Definition at line 368 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        static thread_local auto&             _stack = get_components_stack();
        _stack.push_back(tim::enumerate_components(_component_string));
    }

Referenced by timemory_push_components_().

timemory_push_components_()

void timemory_push_components_

(

const char *

components

)

Definition at line 631 of file library.cpp.

    {
        timemory_push_components(components);
    }

References tim::components, and timemory_push_components().

timemory_push_components_enum()

void timemory_push_components_enum	(	int	args,
			...
	)

Replace the current set of components with a new set of components with the set of enumerations provided to the function. First argument should be the number of new components.

timemory_push_components(2, WALL_CLOCK, CPU_CLOCK);

Definition at line 377 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        static thread_local auto&             _stack = get_components_stack();
 
        component_enum_t comp({ types });
        va_list          args;
        va_start(args, types);
        for(int i = 0; i < TIMEMORY_COMPONENTS_END; ++i)
        {
            auto enum_arg = va_arg(args, int);
            if(enum_arg >= TIMEMORY_COMPONENTS_END)
                break;
            comp.push_back(enum_arg);
        }
        va_end(args);
 
        _stack.push_back(comp);
    }

timemory_push_region()

void timemory_push_region

(

const char *

name

)

Parameters

[in]

name

label for region

Starts collection of components with label.

void foo()
{
    timemory_push_region("foo");
    // ...
    timemory_pop_region("foo");
}

Definition at line 573 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(!lk)
            return;
        auto& region_map = get_region_map();
        lk.release();
        auto idx = timemory_get_begin_record(name);
        lk       = tim::trace::lock<tim::trace::library>{};
        region_map[name].push(idx);
    }

Referenced by timemory_push_region_().

timemory_push_region_()

void timemory_push_region_

(

const char *

name

)

Definition at line 660 of file library.cpp.

{ return timemory_push_region(name); }

References timemory_push_region().

timemory_remove_components()

void timemory_remove_components

(

const char *

components

)

Remove some components to the current set of components being collected. Any components which are not currently being collected are ignored.

timemory_add_components("priority_context_switch, read_bytes");

Definition at line 358 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        auto&                                 _stack = get_current_components();
        for(auto itr : tim::enumerate_components(_component_string))
            _stack.erase(std::remove(_stack.begin(), _stack.end(), itr), _stack.end());
    }

References tim::enumerate_components(), and get_current_components().

timemory_resume()

void timemory_resume

(

void

)

Turn on timemory collection.

Definition at line 318 of file library.cpp.

{ tim::settings::enabled() = true; }

References tim::enabled.

timemory_set_default()

void timemory_set_default

(

const char *

components

)

Pass in a default set of components to use. Will be overridden by TIMEMORY_COMPONENTS environment variable.

timemory_set_default("wall_clock, cpu_clock, cpu_util");

Definition at line 322 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        get_default_components() =
            tim::get_env<std::string>("TIMEMORY_GLOBAL_COMPONENTS", _component_string);
        // tim::set_env("TIMEMORY_COMPONENTS", _component_string, 0);
        static thread_local auto& _stack = get_components_stack();
        if(_stack.empty())
            _stack.push_back(tim::enumerate_components(get_default_components()));
    }

References get_default_components().

Referenced by timemory_set_default_().

timemory_set_default_()

void timemory_set_default_

(

const char *

components

)

Definition at line 626 of file library.cpp.

    {
        timemory_set_default(components);
    }

References tim::components, and timemory_set_default().

timemory_set_environ()

void timemory_set_environ	(	const char *	evar,
		const char *	eval,
		int	ovr,
		int	up
	)

Parameters

[in]	evar	Environment variable name
[in]	eval	Environment variable value
[in]	ovr	Overwrite existing environment variable when > 0
[in]	up	Update settings when > 0

Set an environment variable and (potentially) update settings with new value.

// overwrites the TIMEMORY_GLOBAL_COMPONENTS environment variable and updates
// settings
timemory_set_environ("TIIMEMORY_GLOBAL_COMPONENTS,
                     "wall_clock, cpu_clock, cpu_util", 1, 1);

Definition at line 335 of file library.cpp.

    {
        tim::trace::lock<tim::trace::library> lk{};
        if(evar && eval)
        {
            tim::set_env(evar, eval, over);
            if(parse > 0)
                tim::settings::parse();
        }
    }

References tim::settings::parse(), and tim::set_env().

Variable Documentation

timemory_create_function

timemory_create_func_t timemory_create_function = nullptr

The function pointer to set to customize which components are used by library interface.

using namespace tim::component;
using test_list_t =
    tim::component_list<wall_clock, cpu_util, cpu_clock, peak_rss>;
 
static std::map<uint64_t, std::shared_ptr<test_list_t>> test_map;
 
void
custom_create_record(const char* name, uint64_t* id, int n, int* ct)
{
    uint64_t idx = timemory_get_unique_id();
    auto     tmp = std::make_shared<test_list_t>(name);
    tim::initialize(*tmp, n, ct);
    tmp->initialize<cpu_util, cpu_clock>();
    test_map[idx] = tmp;
    test_map[idx]->start();
    *id = idx;
}
 
void
main()
{
    // ... using default create/delete functions ...
 
    timemory_create_function = &custom_create_record;
    timemory_delete_function = ...;
 
    // ... using custom create/delete functions ...
 
    timemory_create_function = nullptr;
    timemory_delete_function = ...;
 
    // ... using default create/delete functions ...
 
}

Definition at line 51 of file library.cpp.

Referenced by timemory_create_record().

timemory_delete_function

timemory_delete_func_t timemory_delete_function = nullptr

The function pointer to set which deletes an entry created by timemory_create_function.

static std::map<uint64_t, std::shared_ptr<test_list_t>> test_map;
 
void
custom_delete_record(uint64_t id)
{
    auto itr = test_map.find(id);
    if(itr != test_map.end())
    {
        itr->second->stop();
        test_map.erase(itr);
    }
}
 
void
main()
{
    // ... using default create/delete functions ...
 
    timemory_create_function = &custom_create_record;
    timemory_delete_function = &custom_delete_record;
 
    // ... using custom create/delete functions ...
 
    timemory_create_function = nullptr;
    timemory_delete_function = nullptr;
 
    // ... using default create/delete functions ...
 
}

Definition at line 52 of file library.cpp.

Referenced by timemory_delete_record().