tim::component::cupti_counters Struct Reference

NVprof-style hardware counters via the CUpti callback API. Collecting these hardware counters has a higher overhead than the new CUpti Profiling API (tim::component::cupti_profiler). However, there are currently some issues with nesting the Profiling API and it is currently recommended to use this component for NVIDIA hardware counters in timemory. The callback API / NVprof is quite specific about the distinction between an "event" and a "metric". For your convenience, timemory removes this distinction and events can be specified arbitrarily as metrics and vice-versa and this component will sort them into their appropriate category. For the full list of the available events/metrics, use timemory-avail -H from the command-line. More...

#include "timemory/components/cupti/cupti_counters.hpp"

Collaboration diagram for tim::component::cupti_counters:

Public Types
using	value_type = cupti::profiler::results_t
using	this_type = cupti_counters
using	base_type = base< cupti_counters, value_type >
using	size_type = std::size_t
using	string_t = std::string
using	kernel_data_t = cupti::result
using	entry_type = typename value_type::value_type
using	results_t = cupti::profiler::results_t
using	kernel_results_t = cupti::profiler::kernel_results_t
using	strvec_t = std::vector< string_t >
using	profptr_t = std::shared_ptr< cupti::profiler >
using	tuple_type = std::tuple< int, strvec_t, strvec_t >
using	event_func_t = std::function< strvec_t()>
using	metric_func_t = std::function< strvec_t()>
using	device_func_t = std::function< int()>
using	get_initializer_t = std::function< tuple_type()>
using	secondary_type = std::unordered_multimap< std::string, value_type >
template<typename Tp >
using	array_t = std::vector< Tp >

Public Member Functions
	cupti_counters ()
	~cupti_counters ()=default
	cupti_counters (const cupti_counters &)=default
	cupti_counters (cupti_counters &&) noexcept=default
cupti_counters &	operator= (const cupti_counters &rhs)
cupti_counters &	operator= (cupti_counters &&) noexcept=default
void	start ()
void	stop ()
string_t	get_display () const
std::vector< double >	get () const
secondary_type	get_secondary () const
this_type &	operator+= (const this_type &rhs)
this_type &	operator-= (const this_type &rhs)
this_type &	operator+= (const results_t &rhs)
template<typename Archive >
void	serialize (Archive &ar, const unsigned int)

Static Public Member Functions
static event_func_t &	get_event_initializer ()
static metric_func_t &	get_metric_initializer ()
static device_func_t &	get_device_initializer ()
static get_initializer_t &	get_initializer ()
static void	configure ()
static void	configure (int device, const strvec_t &events, const strvec_t &metrics={})
	explicitly configure for a device and set of events/metrics. More...
static void	global_init ()
static void	global_finalize ()
static const profptr_t &	get_profiler ()
static const strvec_t &	get_events ()
static const strvec_t &	get_metrics ()
static int	get_device ()
static const strvec_t &	get_labels ()
static int64_t	unit ()
static string_t	label ()
static string_t	description ()
static string_t	display_unit ()
static value_type	record ()
static array_t< string_t >	label_array ()
static array_t< string_t >	description_array ()
static array_t< string_t >	display_unit_array ()
static array_t< int64_t >	unit_array ()
template<typename Archive >
static void	extra_serialization (Archive &ar)
static void	cleanup ()

Static Public Attributes
static const short	precision = 3
static const short	width = 8

Detailed Description

NVprof-style hardware counters via the CUpti callback API. Collecting these hardware counters has a higher overhead than the new CUpti Profiling API (tim::component::cupti_profiler). However, there are currently some issues with nesting the Profiling API and it is currently recommended to use this component for NVIDIA hardware counters in timemory. The callback API / NVprof is quite specific about the distinction between an "event" and a "metric". For your convenience, timemory removes this distinction and events can be specified arbitrarily as metrics and vice-versa and this component will sort them into their appropriate category. For the full list of the available events/metrics, use timemory-avail -H from the command-line.

Definition at line 70 of file cupti_counters.hpp.

Member Typedef Documentation

array_t

template<typename Tp >

using tim::component::cupti_counters::array_t = std::vector<Tp>

Definition at line 336 of file cupti_counters.hpp.

base_type

using tim::component::cupti_counters::base_type = base<cupti_counters, value_type>

Definition at line 75 of file cupti_counters.hpp.

device_func_t

using tim::component::cupti_counters::device_func_t = std::function<int()>

Definition at line 93 of file cupti_counters.hpp.

entry_type

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

Definition at line 81 of file cupti_counters.hpp.

event_func_t

using tim::component::cupti_counters::event_func_t = std::function<strvec_t()>

Definition at line 91 of file cupti_counters.hpp.

get_initializer_t

using tim::component::cupti_counters::get_initializer_t = std::function<tuple_type()>

Definition at line 95 of file cupti_counters.hpp.

kernel_data_t

using tim::component::cupti_counters::kernel_data_t = cupti::result

Definition at line 80 of file cupti_counters.hpp.

kernel_results_t

using tim::component::cupti_counters::kernel_results_t = cupti::profiler::kernel_results_t

Definition at line 83 of file cupti_counters.hpp.

metric_func_t

using tim::component::cupti_counters::metric_func_t = std::function<strvec_t()>

Definition at line 92 of file cupti_counters.hpp.

profptr_t

using tim::component::cupti_counters::profptr_t = std::shared_ptr<cupti::profiler>

Definition at line 87 of file cupti_counters.hpp.

results_t

using tim::component::cupti_counters::results_t = cupti::profiler::results_t

Definition at line 82 of file cupti_counters.hpp.

secondary_type

using tim::component::cupti_counters::secondary_type = std::unordered_multimap<std::string, value_type>

Definition at line 325 of file cupti_counters.hpp.

size_type

using tim::component::cupti_counters::size_type = std::size_t

Definition at line 78 of file cupti_counters.hpp.

string_t

using tim::component::cupti_counters::string_t = std::string

Definition at line 79 of file cupti_counters.hpp.

strvec_t

using tim::component::cupti_counters::strvec_t = std::vector<string_t>

Definition at line 86 of file cupti_counters.hpp.

this_type

using tim::component::cupti_counters::this_type = cupti_counters

Definition at line 74 of file cupti_counters.hpp.

tuple_type

using tim::component::cupti_counters::tuple_type = std::tuple<int, strvec_t, strvec_t>

Definition at line 89 of file cupti_counters.hpp.

value_type

using tim::component::cupti_counters::value_type = cupti::profiler::results_t

Definition at line 73 of file cupti_counters.hpp.

Constructor & Destructor Documentation

cupti_counters() [1/3]

tim::component::cupti_counters::cupti_counters ( )

inline

Definition at line 161 of file cupti_counters.hpp.

    {
        configure();
        auto* _labels = _get_labels();
        if(_labels)
        {
            value.resize(_labels->size());
            accum.resize(_labels->size());
            for(size_type i = 0; i < _labels->size(); ++i)
            {
                value[i].name = (*_labels)[i];
                accum[i].name = (*_labels)[i];
            }
        }
    }

References configure().

~cupti_counters()

tim::component::cupti_counters::~cupti_counters ( )

default

cupti_counters() [2/3]

tim::component::cupti_counters::cupti_counters ( const cupti_counters &  )

default

cupti_counters() [3/3]

tim::component::cupti_counters::cupti_counters ( cupti_counters &&  )

defaultnoexcept

Member Function Documentation

cleanup()

static void tim::component::cupti_counters::cleanup ( )

inlinestatic

Definition at line 658 of file cupti_counters.hpp.

    {
        clear();
        delete _get_device();
        delete _get_events();
        delete _get_labels();
        delete _get_metrics();
        _get_device()  = nullptr;
        _get_events()  = nullptr;
        _get_labels()  = nullptr;
        _get_metrics() = nullptr;
    }

configure() [1/2]

static void tim::component::cupti_counters::configure ( )

inlinestatic

Definition at line 135 of file cupti_counters.hpp.

    {
        if(_get_profiler().get() == nullptr)
            init();
    }

References get().

Referenced by cupti_counters(), tim::component::gpu_roofline< Types >::configure(), global_init(), and record().

configure() [2/2]

static void tim::component::cupti_counters::configure ( int  device, const strvec_t &  events, const strvec_t &  metrics = {}  )

inlinestatic

explicitly configure for a device and set of events/metrics.

Definition at line 142 of file cupti_counters.hpp.

                                                    {})
    {
        get_initializer() = [=]() -> tuple_type {
            return tuple_type(device, events, metrics);
        };
        if(_get_profiler().get() == nullptr)
            init();
    }

description()

static string_t tim::component::cupti_counters::description ( )

inlinestatic

Definition at line 195 of file cupti_counters.hpp.

{ return "Hardware counters for the CUDA API"; }

description_array()

static array_t<string_t> tim::component::cupti_counters::description_array ( )

inlinestatic

Definition at line 368 of file cupti_counters.hpp.

{ return label_array(); }

References label_array().

display_unit()

static string_t tim::component::cupti_counters::display_unit ( )

inlinestatic

Definition at line 196 of file cupti_counters.hpp.

{ return ""; }

Referenced by tim::component::gpu_roofline< Types >::display_unit().

display_unit_array()

static array_t<string_t> tim::component::cupti_counters::display_unit_array ( )

inlinestatic

Definition at line 373 of file cupti_counters.hpp.

    {
        return array_t<string_t>(get_labels().size(), "");
    }

References get_labels().

extra_serialization()

template<typename Archive >

static void tim::component::cupti_counters::extra_serialization ( Archive &  ar )

inlinestatic

Definition at line 468 of file cupti_counters.hpp.

    {
        auto& _devices = *_get_device();
        auto& _events  = *_get_events();
        auto& _metrics = *_get_metrics();
        auto& _labels  = *_get_labels();
 
        ar(cereal::make_nvp("devices", _devices), cereal::make_nvp("events", _events),
           cereal::make_nvp("metrics", _metrics), cereal::make_nvp("labels", _labels));
    }

get()

std::vector<double> tim::component::cupti_counters::get ( ) const

inline

Definition at line 315 of file cupti_counters.hpp.

    {
        std::vector<double> values;
        const auto&         _data = load();
        values.reserve(_data.size());
        for(const auto& itr : _data)
            values.push_back(cupti::get<double>(itr.data));
        return values;
    }

References tim::component::base< cupti_counters, cupti::profiler::results_t >::load().

Referenced by configure().

get_device()

static int tim::component::cupti_counters::get_device ( )

inlinestatic

Definition at line 158 of file cupti_counters.hpp.

{ return *_get_device(); }

get_device_initializer()

static device_func_t& tim::component::cupti_counters::get_device_initializer ( )

inlinestatic

Definition at line 116 of file cupti_counters.hpp.

    {
        static device_func_t _instance = []() {
            if(cuda::device_count() < 1)
                return -1;
            return settings::cupti_device();
        };
        return _instance;
    }

References tim::cupti_device.

Referenced by get_initializer().

get_display()

string_t tim::component::cupti_counters::get_display ( ) const

inline

Definition at line 284 of file cupti_counters.hpp.

    {
        auto _get_display = [&](std::ostream& os, const cupti::result& obj) {
            auto _label = obj.name;
            auto _prec  = base_type::get_precision();
            auto _width = base_type::get_width();
            auto _flags = base_type::get_format_flags();
 
            std::stringstream ss;
            std::stringstream ssv;
            std::stringstream ssi;
            ssv.setf(_flags);
            ssv << std::setw(_width) << std::setprecision(_prec);
            cupti::print(ssv, obj.data);
            if(!_label.empty())
                ssi << " " << _label;
            ss << ssv.str() << ssi.str();
            os << ss.str();
        };
 
        const auto&       _data = load();
        std::stringstream ss;
        for(size_type i = 0; i < _data.size(); ++i)
        {
            _get_display(ss, _data[i]);
            if(i + 1 < _data.size())
                ss << ", ";
        }
        return ss.str();
    }

References tim::component::base< Tp, Value >::get_format_flags(), tim::component::base< Tp, Value >::get_precision(), tim::component::base< Tp, Value >::get_width(), tim::component::base< cupti_counters, cupti::profiler::results_t >::load(), and tim::invoke::print().

get_event_initializer()

static event_func_t& tim::component::cupti_counters::get_event_initializer ( )

inlinestatic

Definition at line 100 of file cupti_counters.hpp.

    {
        static event_func_t _instance = []() {
            return delimit(settings::cupti_events());
        };
        return _instance;
    }

References tim::cupti_events, and tim::delimit().

Referenced by get_initializer().

get_events()

static const strvec_t& tim::component::cupti_counters::get_events ( )

inlinestatic

Definition at line 156 of file cupti_counters.hpp.

{ return *_get_events(); }

get_initializer()

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

inlinestatic

Definition at line 126 of file cupti_counters.hpp.

    {
        static get_initializer_t _instance = []() -> tuple_type {
            return tuple_type(get_device_initializer()(), get_event_initializer()(),
                              get_metric_initializer()());
        };
        return _instance;
    }

References get_device_initializer(), get_event_initializer(), and get_metric_initializer().

get_labels()

static const strvec_t& tim::component::cupti_counters::get_labels ( )

inlinestatic

Definition at line 159 of file cupti_counters.hpp.

{ return *_get_labels(); }

Referenced by display_unit_array(), and unit_array().

get_metric_initializer()

static metric_func_t& tim::component::cupti_counters::get_metric_initializer ( )

inlinestatic

Definition at line 108 of file cupti_counters.hpp.

    {
        static metric_func_t _instance = []() {
            return delimit(settings::cupti_metrics());
        };
        return _instance;
    }

References tim::cupti_metrics, and tim::delimit().

Referenced by get_initializer().

get_metrics()

static const strvec_t& tim::component::cupti_counters::get_metrics ( )

inlinestatic

Definition at line 157 of file cupti_counters.hpp.

{ return *_get_metrics(); }

get_profiler()

static const profptr_t& tim::component::cupti_counters::get_profiler ( )

inlinestatic

Definition at line 155 of file cupti_counters.hpp.

{ return _get_profiler(); }

get_secondary()

secondary_type tim::component::cupti_counters::get_secondary ( ) const

inline

Definition at line 327 of file cupti_counters.hpp.

    {
        secondary_type _data;
        for(const auto& itr : m_kernel_accum)
            _data.insert({ itr.first, itr.second });
        return _data;
    }

global_finalize()

static void tim::component::cupti_counters::global_finalize ( )

inlinestatic

Definition at line 153 of file cupti_counters.hpp.

{ clear(); }

global_init()

static void tim::component::cupti_counters::global_init ( )

inlinestatic

Definition at line 152 of file cupti_counters.hpp.

{ configure(); }

References configure().

label()

static string_t tim::component::cupti_counters::label ( )

inlinestatic

Definition at line 194 of file cupti_counters.hpp.

{ return "cupti_counters"; }

label_array()

static array_t<string_t> tim::component::cupti_counters::label_array ( )

inlinestatic

Definition at line 341 of file cupti_counters.hpp.

    {
        array_t<string_t> arr;
        auto              contains = [&](const string_t& entry) {
            return std::find(arr.begin(), arr.end(), entry) != arr.end();
        };
        auto insert = [&](const string_t& entry) {
            if(!contains(entry))
                arr.push_back(entry);
        };
        auto* _labels = _get_labels();
        if(_labels)
        {
            for(const auto& itr : *_labels)
                insert(itr);
        }
        // auto profiler = get_profiler();
        // for(const auto& itr : profiler->get_event_names())
        //     insert(itr);
        // for(const auto& itr : profiler->get_metric_names())
        //     insert(itr);
        return arr;
    }

References tim::insert().

Referenced by tim::component::gpu_roofline< Types >::configure(), and description_array().

operator+=() [1/2]

this_type& tim::component::cupti_counters::operator+= ( const results_t &  rhs )

inline

Definition at line 423 of file cupti_counters.hpp.

    {
        auto _combine = [](value_type& _data, const value_type& _other) {
            if(_data.empty())
            {
                _data = _other;
            }
            else
            {
                for(size_type i = 0; i < _other.size(); ++i)
                    _data[i] += _other[i];
            }
        };
 
        _combine(value, rhs);
        _combine(accum, rhs);
 
        return *this;
    }

operator+=() [2/2]

this_type& tim::component::cupti_counters::operator+= ( const this_type &  rhs )

inline

Definition at line 386 of file cupti_counters.hpp.

    {
        auto _combine = [](value_type& _data, const value_type& _other) {
            auto& _labels = *_get_labels();
            if(_data.empty())
            {
                _data = _other;
            }
            else
            {
                for(size_type i = 0; i < _labels.size(); ++i)
                    _data[i] += _other[i];
            }
        };
 
        _combine(value, rhs.value);
        _combine(accum, rhs.accum);
        return *this;
    }

operator-=()

this_type& tim::component::cupti_counters::operator-= ( const this_type &  rhs )

inline

Definition at line 406 of file cupti_counters.hpp.

    {
        auto _combine = [](value_type& _data, const value_type& _other) {
            auto& _labels = *_get_labels();
            // set to other
            if(_data.empty())
                _data = _other;
            // subtract other (if data was empty, will contain zero data)
            for(size_type i = 0; i < _labels.size(); ++i)
                _data[i] -= _other[i];
        };
 
        _combine(value, rhs.value);
        _combine(accum, rhs.accum);
        return *this;
    }

operator=() [1/2]

cupti_counters& tim::component::cupti_counters::operator= ( const cupti_counters &  rhs )

inline

Definition at line 180 of file cupti_counters.hpp.

    {
        if(this != &rhs)
        {
            base_type::operator=(rhs);
            m_kernel_value     = rhs.m_kernel_value;
            m_kernel_accum     = rhs.m_kernel_accum;
        }
        return *this;
    }

operator=() [2/2]

cupti_counters& tim::component::cupti_counters::operator= ( cupti_counters &&  )

defaultnoexcept

record()

static value_type tim::component::cupti_counters::record ( )

inlinestatic

Definition at line 198 of file cupti_counters.hpp.

    {
        configure();
        value_type tmp;
        auto&      _profiler = _get_profiler();
        if(!_profiler || !_get_labels())
            return tmp;
        auto& _labels = *_get_labels();
        _profiler->stop();
        if(tmp.empty())
        {
            tmp = _profiler->get_events_and_metrics(_labels);
        }
        else if(tmp.size() == _labels.size())
        {
            auto ret = _profiler->get_events_and_metrics(_labels);
            for(size_t j = 0; j < _labels.size(); ++j)
                tmp[j] += ret[j];
        }
        else
        {
            fprintf(stderr, "Warning! mis-matched size in cupti_event::%s @ %s:%i\n",
                    TIMEMORY_ERROR_FUNCTION_MACRO, __FILE__, __LINE__);
        }
 
        return tmp;
    }

References configure(), and TIMEMORY_ERROR_FUNCTION_MACRO.

Referenced by tim::component::gpu_roofline< Types >::record(), start(), and stop().

serialize()

template<typename Archive >

void tim::component::cupti_counters::serialize ( Archive &  ar, const unsigned int    )

inline

Definition at line 447 of file cupti_counters.hpp.

    {
        auto _get = [&](const value_type& _data) {
            std::vector<double> values;
            for(const auto& itr : _data)
                values.push_back(cupti::get<double>(itr.data));
            return values;
        };
        array_t<double> _disp  = _get(accum);
        array_t<double> _value = _get(value);
        array_t<double> _accum = _get(accum);
        ar(cereal::make_nvp("laps", laps), cereal::make_nvp("repr_data", _disp),
           cereal::make_nvp("value", _value), cereal::make_nvp("accum", _accum),
           cereal::make_nvp("display", _disp));
        // ar(cereal::make_nvp("units", unit_array()),
        //   cereal::make_nvp("display_units", display_unit_array()));
    }

References tim::component::base< cupti_counters, cupti::profiler::results_t >::laps.

start()

void tim::component::cupti_counters::start ( )

inline

Definition at line 229 of file cupti_counters.hpp.

    {
        value           = record();
        auto& _profiler = _get_profiler();
        if(_profiler)
        {
            m_kernel_value = _profiler->get_kernel_events_and_metrics(*_get_labels());
            _profiler->start();
        }
    }

References record().

stop()

void tim::component::cupti_counters::stop ( )

inline

Definition at line 240 of file cupti_counters.hpp.

    {
        using namespace stl;
        using namespace tim::component::operators;
 
        value_type tmp       = record();
        auto&      _profiler = _get_profiler();
        if(!_profiler)
            return;
 
        kernel_results_t kernel_data =
            _profiler->get_kernel_events_and_metrics(*_get_labels());
        kernel_results_t kernel_tmp = kernel_data;
 
        if(accum.empty())
        {
            accum = tmp;
            for(size_type i = 0; i < tmp.size(); ++i)
                accum[i] -= value[i];
        }
        else
        {
            for(size_type i = 0; i < tmp.size(); ++i)
                accum[i] += (tmp[i] - value[i]);
        }
 
        for(size_t i = 0; i < m_kernel_value.size(); ++i)
            kernel_tmp[i].second -= m_kernel_value[i].second;
        for(size_t i = 0; i < kernel_tmp.size(); ++i)
        {
            if(i >= m_kernel_accum.size())
            {
                m_kernel_accum.resize(i + 1, kernel_tmp[i]);
            }
            else
            {
                m_kernel_accum[i].second += kernel_tmp[i].second;
            }
        }
 
        value          = std::move(tmp);
        m_kernel_value = std::move(kernel_data);
    }

References record().

unit()

static int64_t tim::component::cupti_counters::unit ( )

inlinestatic

Definition at line 192 of file cupti_counters.hpp.

{ return 1; }

Referenced by tim::component::gpu_roofline< Types >::unit().

unit_array()

static array_t<int64_t> tim::component::cupti_counters::unit_array ( )

inlinestatic

Definition at line 381 of file cupti_counters.hpp.

    {
        return array_t<int64_t>(get_labels().size(), 1);
    }

References get_labels().

Member Data Documentation

precision

const short tim::component::cupti_counters::precision = 3

static

Definition at line 97 of file cupti_counters.hpp.

width

const short tim::component::cupti_counters::width = 8

static

Definition at line 98 of file cupti_counters.hpp.

---

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

• timemory/components/cupti/cupti_counters.hpp