#include "timemory/ert/configuration.hpp"

Collaboration diagram for tim::ert::executor< DeviceT, Tp, CounterT >:

Public Types
using	device_type = DeviceT

using	value_type = Tp

using	configuration_type = configuration< device_type, value_type, CounterT >

using	counter_type = counter< device_type, value_type, CounterT >

using	this_type = executor< device_type, value_type, CounterT >

using	callback_type = std::function< void(counter_type &)>

using	ert_data_t = exec_data< CounterT >

Public Member Functions
	executor (configuration_type &config, std::shared_ptr< ert_data_t > _data)

template<typename FuncT >
	executor (configuration_type &config, std::shared_ptr< ert_data_t > _data, FuncT &&_counter_callback)

template<typename FuncT = std::function<void(uint64_t, counter_type&)>>
auto	operator() (configuration_type &config, std::shared_ptr< ert_data_t > _data={}, FuncT &&_counter_callback=FuncT{})

Static Public Member Functions
static callback_type &	get_callback ()

static void	execute (counter_type &_counter)

template<size_t... Flops, enable_if_t<(sizeof...(Flops) > 0)> = 0>
static bool	execute (counter_type &_counter, std::array< std::string, sizeof...(Flops)> _labels)

Public Attributes
callback_type	callback = get_callback()

Detailed Description

template<typename DeviceT, typename Tp, typename CounterT>
struct tim::ert::executor< DeviceT, Tp, CounterT >

Definition at line 281 of file configuration.hpp.

Member Typedef Documentation

◆ callback_type

template<typename DeviceT , typename Tp , typename CounterT >

using tim::ert::executor< DeviceT, Tp, CounterT >::callback_type = std::function<void(counter_type&)>

Definition at line 294 of file configuration.hpp.

◆ configuration_type

template<typename DeviceT , typename Tp , typename CounterT >

using tim::ert::executor< DeviceT, Tp, CounterT >::configuration_type = configuration<device_type, value_type, CounterT>

Definition at line 291 of file configuration.hpp.

◆ counter_type

template<typename DeviceT , typename Tp , typename CounterT >

using tim::ert::executor< DeviceT, Tp, CounterT >::counter_type = counter<device_type, value_type, CounterT>

Definition at line 292 of file configuration.hpp.

◆ device_type

template<typename DeviceT , typename Tp , typename CounterT >

using tim::ert::executor< DeviceT, Tp, CounterT >::device_type = DeviceT

Definition at line 289 of file configuration.hpp.

◆ ert_data_t

template<typename DeviceT , typename Tp , typename CounterT >

using tim::ert::executor< DeviceT, Tp, CounterT >::ert_data_t = exec_data<CounterT>

Definition at line 295 of file configuration.hpp.

◆ this_type

template<typename DeviceT , typename Tp , typename CounterT >

using tim::ert::executor< DeviceT, Tp, CounterT >::this_type = executor<device_type, value_type, CounterT>

Definition at line 293 of file configuration.hpp.

◆ value_type

template<typename DeviceT , typename Tp , typename CounterT >

using tim::ert::executor< DeviceT, Tp, CounterT >::value_type = Tp

Definition at line 290 of file configuration.hpp.

Constructor & Destructor Documentation

◆ executor() [1/2]

template<typename DeviceT , typename Tp , typename CounterT >

tim::ert::executor< DeviceT, Tp, CounterT >::executor	(	configuration_type &	config,
		std::shared_ptr< ert_data_t >	_data
	)

inline

Definition at line 303 of file configuration.hpp.

    {
        (*this)(config, _data);
    }

◆ executor() [2/2]

template<typename DeviceT , typename Tp , typename CounterT >

template<typename FuncT >

tim::ert::executor< DeviceT, Tp, CounterT >::executor	(	configuration_type &	config,
		std::shared_ptr< ert_data_t >	_data,
		FuncT &&	_counter_callback
	)

inline

Definition at line 312 of file configuration.hpp.

    {
        (*this)(config, _data, std::forward<FuncT>(_counter_callback));
    }

Member Function Documentation

◆ execute() [1/2]

template<typename DeviceT , typename Tp , typename CounterT >

static void tim::ert::executor< DeviceT, Tp, CounterT >::execute ( counter_type & _counter )

inlinestatic

Definition at line 361 of file configuration.hpp.

    {
        // vectorization number of ops
        static constexpr const int SIZE_BITS = sizeof(Tp) * 8;
        static_assert(SIZE_BITS > 0, "Calculated bits size is not greater than zero");
        static constexpr const int VEC = TIMEMORY_VEC / SIZE_BITS;
        static_assert(VEC > 0, "Calculated vector size is zero");
 
        // functions
        auto store_func = [](Tp& a, const Tp& b) { a = b; };
        auto add_func   = [](Tp& a, const Tp& b, const Tp& c) { a = b + c; };
        auto fma_func   = [](Tp& a, const Tp& b, const Tp& c) { a = a * b + c; };
 
        // set bytes per element
        _counter.bytes_per_element = sizeof(Tp);
        // set number of memory accesses per element from two functions
        _counter.memory_accesses_per_element = 2;
 
        // set the label
        _counter.label = "scalar_add";
        // run the kernels
        ops_main<1>(_counter, add_func, store_func);
 
        // set the label
        _counter.label = "vector_fma";
        // run the kernels
        if(!ops_main<TIMEMORY_USER_ERT_FLOPS>(_counter, fma_func, store_func))
            ops_main<VEC / 2, VEC, 2 * VEC, 4 * VEC>(_counter, fma_func, store_func);
    }

References tim::ert::counter< DeviceT, Tp, Counter >::bytes_per_element, tim::ert::counter< DeviceT, Tp, Counter >::label, tim::ert::counter< DeviceT, Tp, Counter >::memory_accesses_per_element, tim::ert::ops_main(), and TIMEMORY_VEC.

Referenced by tim::ert::executor< DeviceT, Tp, CounterT >::get_callback(), and tim::ert::executor< device::gpu, Tp, CounterT >::get_callback().

◆ execute() [2/2]

template<typename DeviceT , typename Tp , typename CounterT >

template<size_t... Flops, enable_if_t<(sizeof...(Flops) > 0)> = 0>

static bool tim::ert::executor< DeviceT, Tp, CounterT >::execute	(	counter_type &	_counter,
		std::array< std::string, sizeof...(Flops)>	_labels
	)

inlinestatic

Definition at line 394 of file configuration.hpp.

    {
        bool _executed = false;
        auto itr       = _labels.begin();
        TIMEMORY_FOLD_EXPRESSION(_executed |= execute_impl<Flops>(_counter, *(itr++)));
        return _executed;
    }

References TIMEMORY_FOLD_EXPRESSION.

◆ get_callback()

template<typename DeviceT , typename Tp , typename CounterT >

static callback_type & tim::ert::executor< DeviceT, Tp, CounterT >::get_callback ( )

inlinestatic

Definition at line 351 of file configuration.hpp.

    {
        static callback_type _instance = [](counter_type& _counter) {
            this_type::execute(_counter);
        };
        return _instance;
    }

References tim::ert::executor< DeviceT, Tp, CounterT >::execute().

Referenced by tim::component::cpu_roofline< Types >::set_executor_callback(), and tim::component::gpu_roofline< Types >::set_executor_callback().

◆ operator()()

template<typename DeviceT , typename Tp , typename CounterT >

template<typename FuncT = std::function<void(uint64_t, counter_type&)>>

auto tim::ert::executor< DeviceT, Tp, CounterT >::operator()	(	configuration_type &	config,
		std::shared_ptr< ert_data_t >	_data = `{}`,
		FuncT &&	_counter_callback = `FuncT{}`
	)

inline

Definition at line 322 of file configuration.hpp.

                                                                                  {},
                    FuncT&& _counter_callback = FuncT{})
    {
        std::function<void(uint64_t, counter_type&)> _cb =
            std::forward<FuncT>(_counter_callback);
        try
        {
            if(!_data)
                _data.reset(new ert_data_t);
            auto _counter = config.executor(_data);
            if(_cb)
                _counter.set_callback(std::move(_cb));
            callback(_counter);
        } catch(std::exception& e)
        {
            std::cerr << "\n\nEXCEPTION:\n";
            std::cerr << "\t" << e.what() << "\n\n" << std::endl;
        }
        return _data;
    }

Member Data Documentation

◆ callback

template<typename DeviceT , typename Tp , typename CounterT >

callback_type tim::ert::executor< DeviceT, Tp, CounterT >::callback = get_callback()

Definition at line 346 of file configuration.hpp.

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

timemory/ert/configuration.hpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ callback_type

◆ configuration_type

◆ counter_type

◆ device_type

◆ ert_data_t

◆ this_type

◆ value_type

Constructor & Destructor Documentation

◆ executor() [1/2]

◆ executor() [2/2]

Member Function Documentation

◆ execute() [1/2]

◆ execute() [2/2]

◆ get_callback()

◆ operator()()

Member Data Documentation

◆ callback