tim::component::papi_common Struct Reference

#include "timemory/components/papi/papi_common.hpp"

Collaboration diagram for tim::component::papi_common:

Classes
struct	common_data
struct	state_data

Public Types
template<typename Tp >
using	vector_t = std::vector< Tp >
template<typename Tp , size_t N>
using	array_t = std::array< Tp, N >
using	size_type = size_t
using	event_list = vector_t< int >
using	value_type = vector_t< long long >
using	entry_type = typename value_type::value_type
using	get_initializer_t = std::function< event_list()>

Static Public Member Functions
static state_data &	state ()
template<typename Tp >
static common_data &	data ()
template<typename Tp >
static int &	event_set ()
template<typename Tp >
static bool &	is_configured ()
template<typename Tp >
static bool &	is_fixed ()
template<typename Tp >
static vector_t< int > &	get_events ()
static void	overflow_handler (int evt_set, void *address, long long overflow_vector, void *context)
static void	add_event (int evt)
static bool	initialize_papi ()
static bool	finalize_papi ()
template<typename Tp >
static get_initializer_t &	get_initializer ()
template<typename Tp >
static void	initialize ()
template<typename Tp >
static void	finalize ()

Static Protected Member Functions
static vector_t< int > &	private_events ()

Protected Attributes
event_list	events {}

Detailed Description

Definition at line 53 of file papi_common.hpp.

---

Class Documentation

tim::component::papi_common::common_data

struct tim::component::papi_common::common_data

Definition at line 81 of file papi_common.hpp.

Collaboration diagram for tim::component::papi_common::common_data:

Class Members
int	event_set
vector_t< int >	events
bool	is_configured
bool	is_fixed

tim::component::papi_common::state_data

struct tim::component::papi_common::state_data

Definition at line 70 of file papi_common.hpp.

Collaboration diagram for tim::component::papi_common::state_data:

Class Members
bool	is_finalized
bool	is_initialized
bool	is_working

Member Typedef Documentation

array_t

template<typename Tp , size_t N>

using tim::component::papi_common::array_t = std::array<Tp, N>

Definition at line 60 of file papi_common.hpp.

entry_type

using tim::component::papi_common::entry_type = typename value_type::value_type

Definition at line 65 of file papi_common.hpp.

event_list

using tim::component::papi_common::event_list = vector_t<int>

Definition at line 63 of file papi_common.hpp.

get_initializer_t

using tim::component::papi_common::get_initializer_t = std::function<event_list()>

Definition at line 66 of file papi_common.hpp.

size_type

using tim::component::papi_common::size_type = size_t

Definition at line 62 of file papi_common.hpp.

value_type

using tim::component::papi_common::value_type = vector_t<long long>

Definition at line 64 of file papi_common.hpp.

vector_t

template<typename Tp >

using tim::component::papi_common::vector_t = std::vector<Tp>

Definition at line 57 of file papi_common.hpp.

Member Function Documentation

add_event()

static void tim::component::papi_common::add_event ( int  evt )

inlinestatic

Definition at line 145 of file papi_common.hpp.

    {
        auto& pevents = private_events();
        auto  fitr    = std::find(pevents.begin(), pevents.end(), evt);
        if(fitr == pevents.end())
            pevents.push_back(evt);
    }

References private_events().

Referenced by tim::component::cpu_roofline< Types >::configure().

data()

template<typename Tp >

static common_data& tim::component::papi_common::data ( )

inlinestatic

Definition at line 100 of file papi_common.hpp.

    {
        static thread_local common_data _instance{};
        return _instance;
    }

Referenced by tim::component::papi_tuple< EventTypes >::record().

event_set()

template<typename Tp >

static int& tim::component::papi_common::event_set ( )

inlinestatic

Definition at line 107 of file papi_common.hpp.

    {
        return data<Tp>().event_set;
    }

finalize()

template<typename Tp >

static void tim::component::papi_common::finalize ( )

inlinestatic

Definition at line 329 of file papi_common.hpp.

    {
        if(!initialize_papi())
            return;
        auto& _event_set = event_set<Tp>();
        auto& _events    = get_events<Tp>();
        if(!_events.empty() && _event_set != PAPI_NULL && _event_set >= 0)
        {
            value_type values(_events.size(), 0);
            papi::stop(_event_set, values.data());
            papi::remove_events(_event_set, _events.data(), _events.size());
            papi::destroy_event_set(_event_set);
            _event_set = PAPI_NULL;
            _events.clear();
        }
    }

References initialize_papi(), and tim::invoke::stop().

finalize_papi()

static bool tim::component::papi_common::finalize_papi ( )

inlinestatic

Definition at line 190 of file papi_common.hpp.

    {
        if(!state().is_finalized && state().is_working)
        {
            papi::unregister_thread();
            state().is_working = papi::working();
            if(state().is_working)
                state().is_finalized = true;
        }
        return state().is_finalized && state().is_working;
    }

References tim::component::papi_common::state_data::is_finalized, tim::component::papi_common::state_data::is_working, and state().

Referenced by tim::component::papi_array< MaxNumEvents >::thread_finalize(), tim::component::papi_tuple< EventTypes >::thread_finalize(), and tim::component::papi_vector::thread_finalize().

get_events()

template<typename Tp >

static vector_t<int>& tim::component::papi_common::get_events ( )

inlinestatic

Definition at line 125 of file papi_common.hpp.

    {
        auto& _ret = data<Tp>().events;
        if(!is_fixed<Tp>() && _ret.empty())
            _ret = get_initializer<Tp>()();
        return _ret;
    }

get_initializer()

template<typename Tp >

static get_initializer_t& tim::component::papi_common::get_initializer ( )

inlinestatic

Definition at line 205 of file papi_common.hpp.

    {
        static get_initializer_t _instance = []() {
            if(!papi_common::initialize_papi())
            {
                fprintf(stderr, "[papi_common]> PAPI could not be initialized\n");
                return vector_t<int>{};
            }
 
            auto events_str = settings::papi_events();
 
            if(settings::verbose() > 1 || settings::debug())
            {
                printf("[papi_common]> TIMEMORY_PAPI_EVENTS: '%s'...\n",
                       events_str.c_str());
            }
 
            // don't delimit colons!
            vector_t<string_t> events_str_list = delimit(events_str, "\"',; ");
            vector_t<int>      events_list;
 
            auto& pevents = private_events();
            for(int& pevent : pevents)
            {
                auto fitr = std::find(events_list.begin(), events_list.end(), pevent);
                if(fitr == events_list.end())
                    events_list.push_back(pevent);
            }
 
            for(const auto& itr : events_str_list)
            {
                if(itr.length() == 0)
                    continue;
 
                if(settings::debug())
                {
                    printf("[papi_common]> Getting event code from '%s'...\n",
                           itr.c_str());
                }
 
                int evt_code = papi::get_event_code(itr);
                if(evt_code == PAPI_NOT_INITED)  // defined as zero
                {
                    std::stringstream ss;
                    ss << "[papi_common] Error creating event with ID: " << itr;
                    if(settings::papi_fail_on_error())
                    {
                        TIMEMORY_EXCEPTION(ss.str());
                    }
                    else
                    {
                        fprintf(stderr, "%s\n", ss.str().c_str());
                    }
                }
                else
                {
                    auto fitr =
                        std::find(events_list.begin(), events_list.end(), evt_code);
                    if(fitr == events_list.end())
                    {
                        if(settings::debug() || settings::verbose() > 1)
                        {
                            printf("[papi_common] Successfully created event '%s' with "
                                   "code '%i'...\n",
                                   itr.c_str(), evt_code);
                        }
                        events_list.push_back(evt_code);
                    }
                    else
                    {
                        if(settings::debug() || settings::verbose() > 1)
                        {
                            printf("[papi_common] Event '%s' with code '%i' already "
                                   "exists...\n",
                                   itr.c_str(), evt_code);
                        }
                    }
                }
            }
 
            return events_list;
        };
        return _instance;
    }

References tim::debug, tim::delimit(), initialize_papi(), tim::papi_events, tim::papi_fail_on_error, private_events(), TIMEMORY_EXCEPTION, and tim::verbose.

initialize()

template<typename Tp >

static void tim::component::papi_common::initialize ( )

inlinestatic

Definition at line 293 of file papi_common.hpp.

    {
        if(!is_configured<Tp>() && initialize_papi())
        {
            auto& _event_set = event_set<Tp>();
            auto& _events    = get_events<Tp>();
            if(!_events.empty())
            {
                if(settings::debug() || settings::verbose() > 1)
                    PRINT_HERE("configuring %i papi events", (int) _events.size());
                papi::create_event_set(&_event_set, settings::papi_multiplexing());
                papi::add_events(_event_set, _events.data(), _events.size());
                if(settings::papi_overflow() > 0)
                {
                    for(auto itr : _events)
                    {
                        papi::overflow(_event_set, itr, settings::papi_overflow(), 0,
                                       &overflow_handler);
                    }
                }
                if(settings::papi_attach())
                    papi::attach(_event_set, process::get_target_id());
                papi::start(_event_set);
                is_configured<Tp>() = papi::working();
            }
            if(!is_configured<Tp>())
            {
                PRINT_HERE("Warning! Configuring %i papi events failed",
                           (int) _events.size());
            }
        }
    }

References tim::debug, initialize_papi(), overflow_handler(), tim::papi_attach, tim::papi_multiplexing, tim::papi_overflow, PRINT_HERE, tim::invoke::start(), and tim::verbose.

initialize_papi()

static bool tim::component::papi_common::initialize_papi ( )

inlinestatic

Definition at line 155 of file papi_common.hpp.

    {
        if(!state().is_initialized && !state().is_working)
        {
            if(settings::debug() || settings::verbose() > 2)
            {
                PRINT_HERE("Initializing papi. is initialized: %s, is working: %s",
                           state().is_initialized ? "y" : "n",
                           state().is_working ? "y" : "n");
            }
            papi::init();
            papi::register_thread();
            state().is_working = papi::working();
            if(!state().is_working)
            {
                std::cerr << "Warning! PAPI failed to initialized!\n";
                std::cerr << "The following PAPI events will not be reported: \n";
                for(const auto& itr : get_events<void>())
                    std::cerr << "    " << papi::get_event_info(itr).short_descr << "\n";
                std::cerr << std::flush;
                // disable all the papi APIs with concrete instantiations
                tim::trait::apply<tim::trait::runtime_enabled>::set<
                    tpls::papi, papi_array_t, papi_common, papi_vector, papi_array8_t,
                    papi_array16_t, papi_array32_t>(false);
            }
            else
            {
                state().is_initialized = true;
            }
        }
        return state().is_initialized && state().is_working;
    }

References tim::debug, tim::init(), tim::component::papi_common::state_data::is_initialized, tim::component::papi_common::state_data::is_working, PRINT_HERE, state(), and tim::verbose.

Referenced by finalize(), get_initializer(), and initialize().

is_configured()

template<typename Tp >

static bool& tim::component::papi_common::is_configured ( )

inlinestatic

Definition at line 113 of file papi_common.hpp.

    {
        return data<Tp>().is_configured;
    }

is_fixed()

template<typename Tp >

static bool& tim::component::papi_common::is_fixed ( )

inlinestatic

Definition at line 119 of file papi_common.hpp.

    {
        return data<Tp>().is_fixed;
    }

overflow_handler()

static void tim::component::papi_common::overflow_handler ( int  evt_set, void *  address, long long  overflow_vector, void *  context  )

inlinestatic

Definition at line 135 of file papi_common.hpp.

    {
        fprintf(stderr, "[papi_common%i]> Overflow at %p! bit=0x%llx \n", evt_set,
                address, overflow_vector);
        consume_parameters(context);
    }

References tim::consume_parameters().

Referenced by initialize().

private_events()

static vector_t<int>& tim::component::papi_common::private_events ( )

inlinestaticprotected

Definition at line 355 of file papi_common.hpp.

    {
        static auto _instance = vector_t<int>{};
        return _instance;
    }

Referenced by add_event(), and get_initializer().

state()

static state_data& tim::component::papi_common::state ( )

inlinestatic

Definition at line 93 of file papi_common.hpp.

    {
        static thread_local state_data _instance{};
        return _instance;
    }

Referenced by finalize_papi(), and initialize_papi().

Member Data Documentation

events

event_list tim::component::papi_common::events {}

protected

Definition at line 352 of file papi_common.hpp.

Referenced by tim::component::papi_tuple< EventTypes >::sample(), and tim::component::papi_tuple< EventTypes >::start().

---

The documentation for this struct was generated from the following file:

• timemory/components/papi/papi_common.hpp