tim::component::cupti_activity Struct Reference

CUPTI activity tracing component for high-precision kernel timing. For low-precision kernel timing, use tim::component::cuda_event component. More...

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

Collaboration diagram for tim::component::cupti_activity:

Public Types
using	value_type = intmax_t
using	this_type = cupti_activity
using	base_type = base< cupti_activity, value_type >
using	ratio_t = std::nano
using	size_type = std::size_t
using	string_t = std::string
using	receiver_type = cupti::activity::receiver
using	kind_vector_type = std::vector< cupti::activity_kind_t >
using	get_initializer_t = std::function< kind_vector_type()>
using	kernel_elapsed_t = typename cupti::activity::receiver::named_elapsed_t
using	kernel_names_t = std::unordered_set< std::string >

Public Member Functions
	~cupti_activity ()
void	start ()
void	stop ()
double	get_display () const
double	get () const
kernel_elapsed_t	get_secondary () const
void	set_depth_change (bool v)

Static Public Member Functions
static std::string	label ()
static std::string	description ()
static get_initializer_t &	get_initializer ()
static kind_vector_type	get_kind_types ()
static void	global_init ()
static void	global_finalize ()
static value_type	record ()

Detailed Description

CUPTI activity tracing component for high-precision kernel timing. For low-precision kernel timing, use tim::component::cuda_event component.

Definition at line 58 of file cupti_activity.hpp.

Member Typedef Documentation

base_type

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

Definition at line 63 of file cupti_activity.hpp.

get_initializer_t

using tim::component::cupti_activity::get_initializer_t = std::function<kind_vector_type()>

Definition at line 71 of file cupti_activity.hpp.

kernel_elapsed_t

using tim::component::cupti_activity::kernel_elapsed_t = typename cupti::activity::receiver::named_elapsed_t

Definition at line 72 of file cupti_activity.hpp.

kernel_names_t

using tim::component::cupti_activity::kernel_names_t = std::unordered_set<std::string>

Definition at line 73 of file cupti_activity.hpp.

kind_vector_type

using tim::component::cupti_activity::kind_vector_type = std::vector<cupti::activity_kind_t>

Definition at line 70 of file cupti_activity.hpp.

ratio_t

using tim::component::cupti_activity::ratio_t = std::nano

Definition at line 66 of file cupti_activity.hpp.

receiver_type

using tim::component::cupti_activity::receiver_type = cupti::activity::receiver

Definition at line 69 of file cupti_activity.hpp.

size_type

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

Definition at line 67 of file cupti_activity.hpp.

string_t

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

Definition at line 68 of file cupti_activity.hpp.

this_type

using tim::component::cupti_activity::this_type = cupti_activity

Definition at line 62 of file cupti_activity.hpp.

value_type

using tim::component::cupti_activity::value_type = intmax_t

Definition at line 61 of file cupti_activity.hpp.

Constructor & Destructor Documentation

~cupti_activity()

tim::component::cupti_activity::~cupti_activity ( )

inline

Definition at line 174 of file cupti_activity.hpp.

{ cupti::activity::get_receiver().remove(this); }

Member Function Documentation

description()

static std::string tim::component::cupti_activity::description ( )

inlinestatic

Definition at line 76 of file cupti_activity.hpp.

    {
        return "Wall-clock execution timing for the CUDA API";
    }

get()

double tim::component::cupti_activity::get ( ) const

inline

Definition at line 212 of file cupti_activity.hpp.

    {
        return static_cast<double>(load() / static_cast<double>(ratio_t::den) *
                                   base_type::get_unit());
    }

References tim::component::base< Tp, Value >::get_unit(), and tim::component::base< cupti_activity, intmax_t >::load().

get_display()

double tim::component::cupti_activity::get_display ( ) const

inline

Definition at line 204 of file cupti_activity.hpp.

    {
        return static_cast<double>(load() / static_cast<double>(ratio_t::den) *
                                   base_type::get_unit());
    }

References tim::component::base< Tp, Value >::get_unit(), and tim::component::base< cupti_activity, intmax_t >::load().

get_initializer()

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

inlinestatic

look up integer codes in <timemory/backends/types/cupti.hpp>

Definition at line 83 of file cupti_activity.hpp.

    {
        static get_initializer_t _instance = []() -> kind_vector_type {
            std::vector<cupti::activity_kind_t> _kinds;
            auto                                lvl = settings::cupti_activity_level();
 
            /// look up integer codes in <timemory/backends/types/cupti.hpp>
            auto vec = delimit(settings::cupti_activity_kinds());
            for(const auto& itr : vec)
            {
                int iactivity = atoi(itr.c_str());
                if(iactivity > static_cast<int>(CUPTI_ACTIVITY_KIND_INVALID) &&
                   iactivity < static_cast<int>(CUPTI_ACTIVITY_KIND_COUNT))
                {
                    _kinds.push_back(static_cast<cupti::activity_kind_t>(iactivity));
                }
            }
 
            // if found settings in environment, use those
            if(!_kinds.empty())
            {
                return _kinds;
            }
            if(lvl == 0)
            {
                // general settings for kernels, runtime, overhead
                _kinds = { CUPTI_ACTIVITY_KIND_CONCURRENT_KERNEL };
            }
            else if(lvl == 1)
            {
                // general settings for kernels, runtime, memory, overhead
                _kinds = { { CUPTI_ACTIVITY_KIND_CONCURRENT_KERNEL,
                             CUPTI_ACTIVITY_KIND_MEMCPY, CUPTI_ACTIVITY_KIND_MEMSET } };
            }
            else if(lvl == 2)
            {
                // general settings for kernels, runtime, memory, overhead, and device
                _kinds = { { CUPTI_ACTIVITY_KIND_CONCURRENT_KERNEL,
                             CUPTI_ACTIVITY_KIND_MEMCPY, CUPTI_ACTIVITY_KIND_MEMSET,
                             CUPTI_ACTIVITY_KIND_RUNTIME, CUPTI_ACTIVITY_KIND_DEVICE,
                             CUPTI_ACTIVITY_KIND_DRIVER, CUPTI_ACTIVITY_KIND_OVERHEAD } };
            }
            else if(lvl > 2)
            {
                // general settings for kernels, runtime, memory, overhead, device,
                // stream, CDP kernels
                _kinds = { { CUPTI_ACTIVITY_KIND_CONCURRENT_KERNEL,
                             CUPTI_ACTIVITY_KIND_MEMCPY, CUPTI_ACTIVITY_KIND_MEMSET,
                             CUPTI_ACTIVITY_KIND_RUNTIME, CUPTI_ACTIVITY_KIND_DEVICE,
                             CUPTI_ACTIVITY_KIND_DRIVER, CUPTI_ACTIVITY_KIND_OVERHEAD,
                             CUPTI_ACTIVITY_KIND_MARKER, CUPTI_ACTIVITY_KIND_STREAM,
                             CUPTI_ACTIVITY_KIND_CDP_KERNEL } };
            }
            return _kinds;
        };
        return _instance;
    }

References tim::cupti_activity_kinds, tim::cupti_activity_level, and tim::delimit().

Referenced by get_kind_types().

get_kind_types()

static kind_vector_type tim::component::cupti_activity::get_kind_types ( )

inlinestatic

Definition at line 143 of file cupti_activity.hpp.

    {
        static kind_vector_type _instance = get_initializer()();
        return _instance;
    }

References get_initializer().

Referenced by global_finalize(), and global_init().

get_secondary()

kernel_elapsed_t tim::component::cupti_activity::get_secondary ( ) const

inline

Definition at line 220 of file cupti_activity.hpp.

{ return m_kernels_accum; }

global_finalize()

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

inlinestatic

Definition at line 162 of file cupti_activity.hpp.

{ cupti::activity::finalize_trace(get_kind_types()); }

References get_kind_types().

global_init()

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

inlinestatic

Definition at line 151 of file cupti_activity.hpp.

    {
        static std::atomic<short> _once(0);
        if(_once++ > 0)
            return;
        cupti::activity::initialize_trace(get_kind_types());
        cupti::init_driver();
    }

References get_kind_types().

label()

static std::string tim::component::cupti_activity::label ( )

inlinestatic

Definition at line 75 of file cupti_activity.hpp.

{ return "cupti_activity"; }

record()

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

inlinestatic

Definition at line 166 of file cupti_activity.hpp.

{ return cupti::activity::get_receiver().get(); }

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

set_depth_change()

void tim::component::cupti_activity::set_depth_change ( bool  v )

inline

Definition at line 222 of file cupti_activity.hpp.

{ m_depth_change = v; }

start()

void tim::component::cupti_activity::start ( )

inline

Definition at line 179 of file cupti_activity.hpp.

    {
        cupti::activity::start_trace(this, m_depth_change);
        value           = cupti::activity::get_receiver().get();
        m_kernels_index = cupti::activity::get_receiver().get_named_index();
    }

stop()

void tim::component::cupti_activity::stop ( )

inline

Definition at line 188 of file cupti_activity.hpp.

    {
        using namespace tim::component::operators;
        cupti::activity::stop_trace(this);
        auto tmp     = cupti::activity::get_receiver().get();
        auto kernels = cupti::activity::get_receiver().get_named(m_kernels_index, true);
 
        accum += (tmp - value);
        value = tmp;
        for(const auto& itr : kernels)
            m_kernels_accum[itr.first] += itr.second;
        m_kernels_value = std::move(kernels);
    }

---

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

• timemory/components/cupti/cupti_activity.hpp