#include "timemory/ert/configuration.hpp"

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

Public Types
using	DeviceT = device::gpu

using	device_type = device::gpu

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)

template<size_t Flops>
static enable_if_t< Flops==1, bool >	execute_impl (counter_type &_counter, const std::string &_label)

template<size_t Flops>
static enable_if_t<(Flops > 1), bool >	execute_impl (counter_type &_counter, const std::string &_label)

Public Attributes
callback_type	callback = get_callback()

Detailed Description

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

Definition at line 447 of file configuration.hpp.

Member Typedef Documentation

◆ callback_type

template<typename Tp , typename CounterT >

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

Definition at line 461 of file configuration.hpp.

◆ configuration_type

template<typename Tp , typename CounterT >

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

Definition at line 458 of file configuration.hpp.

◆ counter_type

template<typename Tp , typename CounterT >

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

Definition at line 459 of file configuration.hpp.

◆ device_type

template<typename Tp , typename CounterT >

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

Definition at line 456 of file configuration.hpp.

◆ DeviceT

template<typename Tp , typename CounterT >

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

Definition at line 449 of file configuration.hpp.

◆ ert_data_t

template<typename Tp , typename CounterT >

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

Definition at line 462 of file configuration.hpp.

◆ this_type

template<typename Tp , typename CounterT >

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

Definition at line 460 of file configuration.hpp.

◆ value_type

template<typename Tp , typename CounterT >

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

Definition at line 457 of file configuration.hpp.

Constructor & Destructor Documentation

◆ executor() [1/2]

template<typename Tp , typename CounterT >

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

inline

Definition at line 470 of file configuration.hpp.

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

◆ executor() [2/2]

template<typename Tp , typename CounterT >

template<typename FuncT >

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

inline

Definition at line 479 of file configuration.hpp.

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

Member Function Documentation

◆ execute() [1/2]

template<typename Tp , typename CounterT >

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

inlinestatic

Definition at line 529 of file configuration.hpp.

    {
        // functions
        auto store_func = [] TIMEMORY_DEVICE_LAMBDA(Tp & a, const Tp& b) { a = b; };
        auto add_func   = [] TIMEMORY_DEVICE_LAMBDA(Tp & a, const Tp& b, const Tp& c) {
            a = b + c;
        };
        // auto mult_func = [] TIMEMORY_LAMBDA(Tp & a, const Tp& b, const Tp& c) {
        //    a = b * c;
        //};
        auto fma_func = [] TIMEMORY_DEVICE_LAMBDA(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_mult";
        // run the kernels
        // ops_main<4, 16, 64, 128, 256, 512>(_counter, mult_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<4, 16, 64, 128, 256, 512>(_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, and TIMEMORY_DEVICE_LAMBDA.

◆ execute() [2/2]

template<typename Tp , typename CounterT >

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

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

inlinestatic

Definition at line 568 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.

◆ execute_impl() [1/2]

template<typename Tp , typename CounterT >

template<size_t Flops>

static enable_if_t< Flops==1, bool > tim::ert::executor< device::gpu, Tp, CounterT >::execute_impl	(	counter_type &	_counter,
		const std::string &	_label
	)

inlinestatic

Definition at line 581 of file configuration.hpp.

    {
        // functions
        auto store_func = [] TIMEMORY_DEVICE_LAMBDA(Tp & a, const Tp& b) { a = b; };
        auto add_func   = [] TIMEMORY_DEVICE_LAMBDA(Tp & a, const Tp& b, const Tp& c) {
            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 = _label;
        // run the kernels
        return ops_main<Flops>(_counter, add_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, and TIMEMORY_DEVICE_LAMBDA.

◆ execute_impl() [2/2]

template<typename Tp , typename CounterT >

template<size_t Flops>

static enable_if_t<(Flops > 1), bool > tim::ert::executor< device::gpu, Tp, CounterT >::execute_impl	(	counter_type &	_counter,
		const std::string &	_label
	)

inlinestatic

Definition at line 604 of file configuration.hpp.

    {
        // functions
        auto store_func = [] TIMEMORY_DEVICE_LAMBDA(Tp & a, const Tp& b) { a = b; };
        auto fma_func   = [] TIMEMORY_DEVICE_LAMBDA(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 = _label;
        return ops_main<Flops>(_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, and TIMEMORY_DEVICE_LAMBDA.

◆ get_callback()

template<typename Tp , typename CounterT >

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

inlinestatic

Definition at line 518 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().

◆ operator()()

template<typename Tp , typename CounterT >

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

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

inline

Definition at line 489 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 Tp , typename CounterT >

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

Definition at line 513 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

◆ DeviceT

◆ 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]

◆ execute_impl() [1/2]

◆ execute_impl() [2/2]

◆ get_callback()

◆ operator()()

Member Data Documentation

◆ callback