#include "timemory/ert/counter.hpp"

Collaboration diagram for tim::ert::counter< DeviceT, Tp, Counter >:

Public Types
using	mutex_t = std::recursive_mutex

using	lock_t = std::unique_lock< mutex_t >

using	counter_type = Counter

using	ert_data_t = exec_data< Counter >

using	this_type = counter< DeviceT, Tp, Counter >

using	callback_type = std::function< void(uint64_t, this_type &)>

using	data_type = typename ert_data_t::value_type

using	data_ptr_t = std::shared_ptr< ert_data_t >

using	ull = unsigned long long

using	skip_ops_t = std::unordered_set< size_t >

Public Member Functions
	counter ()=default

	~counter ()=default

	counter (const counter &)=default

	counter (counter &&) noexcept=default

counter &	operator= (const counter &)=default

counter &	operator= (counter &&) noexcept=default

	counter (const exec_params &_params, data_ptr_t _exec_data, uint64_t _align=8 *sizeof(Tp))

	counter (const exec_params &_params, callback_type _func, data_ptr_t _exec_data, uint64_t _align=8 *sizeof(Tp))

template<typename Up = Tp, typename Dev = DeviceT, typename std::enable_if<(std::is_same< Dev, device::cpu >::value\|\|(std::is_same< Dev, device::gpu >::value &&!std::is_same< Up, gpu::fp16_t >::value)), int >::type = 0>
Up *	get_buffer ()
	allocate a buffer for the ERT calculation uses this function if device is CPU or device is GPU and type is not half2 More...

template<typename Up = Tp, typename Dev = DeviceT, typename std::enable_if<(std::is_same< Up, gpu::fp16_t >::value &&std::is_same< Dev, device::gpu >::value), int >::type = 0>
Up *	get_buffer ()
	allocate a buffer for the ERT calculation uses this function if device is GPU and type is half2 More...

void	destroy_buffer (Tp *buffer)

void	configure (uint64_t tid)

counter_type	get_counter () const

void	record (counter_type &_counter, int n, int trials, uint64_t nops, const exec_params &_itrp)

template<typename FuncT >
void	set_callback (FuncT &&_f)

template<typename Archive >
void	serialize (Archive &ar, const unsigned int)

data_ptr_t &	get_data ()

const data_ptr_t &	get_data () const

void	add_skip_ops (size_t _Nops)

void	add_skip_ops (std::initializer_list< size_t > _args)

bool	skip (size_t _Nops)

Public Attributes
exec_params	params = exec_params()

int	bytes_per_element = 0

int	memory_accesses_per_element = 0

uint64_t	align = sizeof(Tp)

uint64_t	nsize = 0

data_ptr_t	data = std::make_shared<ert_data_t>()

std::string	label = ""

skip_ops_t	skip_ops = skip_ops_t()

Friends
std::ostream &	operator<< (std::ostream &os, const counter &obj)

Detailed Description

template<typename DeviceT, typename Tp, typename Counter>
class tim::ert::counter< DeviceT, Tp, Counter >

Definition at line 73 of file counter.hpp.

Member Typedef Documentation

◆ callback_type

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::callback_type = std::function<void(uint64_t, this_type&)>

Definition at line 81 of file counter.hpp.

◆ counter_type

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::counter_type = Counter

Definition at line 78 of file counter.hpp.

◆ data_ptr_t

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::data_ptr_t = std::shared_ptr<ert_data_t>

Definition at line 83 of file counter.hpp.

◆ data_type

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::data_type = typename ert_data_t::value_type

Definition at line 82 of file counter.hpp.

◆ ert_data_t

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::ert_data_t = exec_data<Counter>

Definition at line 79 of file counter.hpp.

◆ lock_t

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::lock_t = std::unique_lock<mutex_t>

Definition at line 77 of file counter.hpp.

◆ mutex_t

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::mutex_t = std::recursive_mutex

Definition at line 76 of file counter.hpp.

◆ skip_ops_t

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::skip_ops_t = std::unordered_set<size_t>

Definition at line 85 of file counter.hpp.

◆ this_type

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::this_type = counter<DeviceT, Tp, Counter>

Definition at line 80 of file counter.hpp.

◆ ull

template<typename DeviceT , typename Tp , typename Counter >

using tim::ert::counter< DeviceT, Tp, Counter >::ull = unsigned long long

Definition at line 84 of file counter.hpp.

Constructor & Destructor Documentation

◆ counter() [1/5]

template<typename DeviceT , typename Tp , typename Counter >

tim::ert::counter< DeviceT, Tp, Counter >::counter ( )

default

◆ ~counter()

template<typename DeviceT , typename Tp , typename Counter >

tim::ert::counter< DeviceT, Tp, Counter >::~counter ( )

default

◆ counter() [2/5]

template<typename DeviceT , typename Tp , typename Counter >

tim::ert::counter< DeviceT, Tp, Counter >::counter ( const counter< DeviceT, Tp, Counter > & )

default

◆ counter() [3/5]

template<typename DeviceT , typename Tp , typename Counter >

tim::ert::counter< DeviceT, Tp, Counter >::counter ( counter< DeviceT, Tp, Counter > && )

defaultnoexcept

◆ counter() [4/5]

template<typename DeviceT , typename Tp , typename Counter >

tim::ert::counter< DeviceT, Tp, Counter >::counter	(	const exec_params &	_params,
		data_ptr_t	_exec_data,
		uint64_t	_align = `8 * sizeof(Tp)`
	)

inlineexplicit

Definition at line 101 of file counter.hpp.

    : params(_params)
    , align(_align)
    , data(std::move(_exec_data))
    {
        compute_internal();
    }

◆ counter() [5/5]

template<typename DeviceT , typename Tp , typename Counter >

tim::ert::counter< DeviceT, Tp, Counter >::counter	(	const exec_params &	_params,
		callback_type	_func,
		data_ptr_t	_exec_data,
		uint64_t	_align = `8 * sizeof(Tp)`
	)

inline

Definition at line 113 of file counter.hpp.

    : params(_params)
    , align(_align)
    , data(std::move(_exec_data))
    , configure_callback(std::move(_func))
    {
        compute_internal();
    }

Member Function Documentation

◆ add_skip_ops() [1/2]

template<typename DeviceT , typename Tp , typename Counter >

void tim::ert::counter< DeviceT, Tp, Counter >::add_skip_ops ( size_t _Nops )

inline

Definition at line 280 of file counter.hpp.

280{ skip_ops.insert(_Nops); }

tim::ert::counter::skip_ops

skip_ops_t skip_ops

Definition: counter.hpp:301

References tim::ert::counter< DeviceT, Tp, Counter >::skip_ops.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_executor().

◆ add_skip_ops() [2/2]

template<typename DeviceT , typename Tp , typename Counter >

void tim::ert::counter< DeviceT, Tp, Counter >::add_skip_ops ( std::initializer_list< size_t > _args )

inline

Definition at line 282 of file counter.hpp.

    {
        for(const auto& itr : _args)
            skip_ops.insert(itr);
    }

References tim::_args, and tim::ert::counter< DeviceT, Tp, Counter >::skip_ops.

◆ configure()

template<typename DeviceT , typename Tp , typename Counter >

void tim::ert::counter< DeviceT, Tp, Counter >::configure ( uint64_t tid )

inline

Definition at line 184 of file counter.hpp.

184{ configure_callback(tid, *this); }

Referenced by tim::ert::ops_main().

◆ destroy_buffer()

template<typename DeviceT , typename Tp , typename Counter >

void tim::ert::counter< DeviceT, Tp, Counter >::destroy_buffer ( Tp * buffer )

inline

Definition at line 178 of file counter.hpp.

178{ free_aligned<Tp, DeviceT>(buffer); }

Referenced by tim::ert::ops_main().

◆ get_buffer() [1/2]

template<typename DeviceT , typename Tp , typename Counter >

template<typename Up = Tp, typename Dev = DeviceT, typename std::enable_if<(std::is_same< Dev, device::cpu >::value||(std::is_same< Dev, device::gpu >::value &&!std::is_same< Up, gpu::fp16_t >::value)), int >::type = 0>

Up * tim::ert::counter< DeviceT, Tp, Counter >::get_buffer ( )

inline

allocate a buffer for the ERT calculation uses this function if device is CPU or device is GPU and type is not half2

Definition at line 133 of file counter.hpp.

    {
        // check alignment and
        align = std::max<uint64_t>(align, 8 * sizeof(Up));
        compute_internal();
 
        if(settings::debug())
            printf("[%s]> nsize = %llu\n", __FUNCTION__, (ull) nsize);
        Up* buffer = allocate_aligned<Up, DeviceT>(nsize, align);
        if(settings::debug())
            printf("[%s]> buffer = %p\n", __FUNCTION__, (void*) buffer);
        device::params<DeviceT> _params(0, 512, 0, 0);
        device::launch(nsize, _params, initialize_buffer<DeviceT, Up, uint64_t>, buffer,
                       Up{ 1 }, nsize);
        return buffer;
    }

References tim::ert::counter< DeviceT, Tp, Counter >::align, tim::debug, and tim::ert::counter< DeviceT, Tp, Counter >::nsize.

Referenced by tim::ert::ops_main().

◆ get_buffer() [2/2]

template<typename DeviceT , typename Tp , typename Counter >

template<typename Up = Tp, typename Dev = DeviceT, typename std::enable_if<(std::is_same< Up, gpu::fp16_t >::value &&std::is_same< Dev, device::gpu >::value), int >::type = 0>

Up * tim::ert::counter< DeviceT, Tp, Counter >::get_buffer ( )

inline

allocate a buffer for the ERT calculation uses this function if device is GPU and type is half2

Definition at line 158 of file counter.hpp.

    {
        // check alignment and
        align = std::max<uint64_t>(align, 8 * sizeof(Up));
        compute_internal();
 
        if(settings::debug())
            printf("[%s]> nsize = %llu\n", __FUNCTION__, (ull) nsize);
        Up* buffer = allocate_aligned<Up, DeviceT>(nsize, align);
        if(settings::debug())
            printf("[%s]> buffer = %p\n", __FUNCTION__, (void*) buffer);
        device::params<DeviceT> _params(0, 512, 0, 0);
        device::launch(nsize, _params, initialize_buffer<DeviceT, Up, uint32_t>, buffer,
                       Up{ 1, 1 }, nsize);
        return buffer;
    }

References tim::ert::counter< DeviceT, Tp, Counter >::align, tim::debug, and tim::ert::counter< DeviceT, Tp, Counter >::nsize.

◆ get_counter()

template<typename DeviceT , typename Tp , typename Counter >

counter_type tim::ert::counter< DeviceT, Tp, Counter >::get_counter ( ) const

inline

Definition at line 190 of file counter.hpp.

190{ return counter_type(); }

tim::ert::counter::counter_type

Counter counter_type

Definition: counter.hpp:78

Referenced by tim::ert::ops_main().

◆ get_data() [1/2]

template<typename DeviceT , typename Tp , typename Counter >

data_ptr_t & tim::ert::counter< DeviceT, Tp, Counter >::get_data ( )

inline

Definition at line 274 of file counter.hpp.

274{ return data; }

References tim::ert::counter< DeviceT, Tp, Counter >::data.

◆ get_data() [2/2]

template<typename DeviceT , typename Tp , typename Counter >

const data_ptr_t & tim::ert::counter< DeviceT, Tp, Counter >::get_data ( ) const

inline

Definition at line 275 of file counter.hpp.

275{ return data; }

References tim::ert::counter< DeviceT, Tp, Counter >::data.

◆ operator=() [1/2]

template<typename DeviceT , typename Tp , typename Counter >

counter & tim::ert::counter< DeviceT, Tp, Counter >::operator= ( const counter< DeviceT, Tp, Counter > & )

default

◆ operator=() [2/2]

template<typename DeviceT , typename Tp , typename Counter >

counter & tim::ert::counter< DeviceT, Tp, Counter >::operator= ( counter< DeviceT, Tp, Counter > && )

defaultnoexcept

◆ record()

template<typename DeviceT , typename Tp , typename Counter >

void tim::ert::counter< DeviceT, Tp, Counter >::record	(	counter_type &	_counter,
		int	n,
		int	trials,
		uint64_t	nops,
		const exec_params &	_itrp
	)

inline

Definition at line 196 of file counter.hpp.

    {
        uint64_t working_set_size = n * params.nthreads * params.nproc;
        uint64_t working_set      = working_set_size * bytes_per_element;
        uint64_t total_bytes      = trials * working_set * memory_accesses_per_element;
        uint64_t total_ops        = trials * working_set_size * nops;
 
        std::stringstream ss;
        ss << label;
        if(label.length() == 0)
        {
            if(nops > 1)
            {
                ss << "vector_op";
            }
            else
            {
                ss << "scalar_op";
            }
        }
 
        auto      _label = tim::demangle<Tp>();
        data_type _data(ss.str(), working_set, trials, total_bytes, total_ops, nops,
                        _counter, DeviceT::name(), _label, _itrp);
 
#if !defined(TIMEMORY_WINDOWS)
        // using namespace tim::stl::ostream;
        // if(settings::verbose() > 1 || settings::debug())
        //    std::cout << "[RECORD]> " << _data << std::endl;
#endif
 
        static std::mutex _mutex;
        // std::unique_lock<std::mutex> _lock(_mutex);
        _mutex.lock();
        *data += _data;
        _mutex.unlock();
    }

References tim::ert::counter< DeviceT, Tp, Counter >::bytes_per_element, tim::ert::counter< DeviceT, Tp, Counter >::data, tim::ert::counter< DeviceT, Tp, Counter >::label, tim::ert::counter< DeviceT, Tp, Counter >::memory_accesses_per_element, tim::ert::exec_params::nproc, tim::ert::exec_params::nthreads, and tim::ert::counter< DeviceT, Tp, Counter >::params.

Referenced by tim::ert::ops_main().

◆ serialize()

template<typename DeviceT , typename Tp , typename Counter >

template<typename Archive >

void tim::ert::counter< DeviceT, Tp, Counter >::serialize	(	Archive &	ar,
		const unsigned int
	)

inline

Definition at line 247 of file counter.hpp.

    {
        if(!data.get())  // for input
            data = std::make_shared<ert_data_t>();
        ar(cereal::make_nvp("params", params), cereal::make_nvp("data", *data));
    }

References tim::ert::counter< DeviceT, Tp, Counter >::data, and tim::ert::counter< DeviceT, Tp, Counter >::params.

◆ set_callback()

template<typename DeviceT , typename Tp , typename Counter >

template<typename FuncT >

void tim::ert::counter< DeviceT, Tp, Counter >::set_callback ( FuncT && _f )

inline

Definition at line 238 of file counter.hpp.

    {
        configure_callback = std::forward<FuncT>(_f);
    }

◆ skip()

template<typename DeviceT , typename Tp , typename Counter >

bool tim::ert::counter< DeviceT, Tp, Counter >::skip ( size_t _Nops )

inline

Definition at line 288 of file counter.hpp.

288{ return (skip_ops.count(_Nops) > 0); }

References tim::ert::counter< DeviceT, Tp, Counter >::skip_ops.

Referenced by tim::ert::ops_main().

Friends And Related Function Documentation

◆ operator<<

template<typename DeviceT , typename Tp , typename Counter >

std::ostream & operator<<	(	std::ostream &	os,
		const counter< DeviceT, Tp, Counter > &	obj
	)

friend

Definition at line 257 of file counter.hpp.

    {
        std::stringstream ss;
        ss << obj.params << ", "
           << "bytes_per_element = " << obj.bytes_per_element << ", "
           << "memory_accesses_per_element = " << obj.memory_accesses_per_element << ", "
           << "alignment = " << obj.align << ", "
           << "nsize = " << obj.nsize << ", "
           << "label = " << obj.label << ", "
           << "data entries = " << ((obj.data.get()) ? obj.data->size() : 0);
        os << ss.str();
        return os;
    }

Member Data Documentation

◆ align

template<typename DeviceT , typename Tp , typename Counter >

uint64_t tim::ert::counter< DeviceT, Tp, Counter >::align = sizeof(Tp)

Definition at line 297 of file counter.hpp.

Referenced by tim::ert::counter< DeviceT, Tp, Counter >::get_buffer().

◆ bytes_per_element

template<typename DeviceT , typename Tp , typename Counter >

int tim::ert::counter< DeviceT, Tp, Counter >::bytes_per_element = 0

Definition at line 295 of file counter.hpp.

Referenced by tim::ert::executor< DeviceT, Tp, CounterT >::execute(), tim::ert::executor< device::gpu, Tp, CounterT >::execute(), tim::ert::executor< device::gpu, Tp, CounterT >::execute_impl(), tim::ert::configuration< DeviceT, Tp, CounterT >::get_executor(), tim::ert::ops_main(), and tim::ert::counter< DeviceT, Tp, Counter >::record().

◆ data

template<typename DeviceT , typename Tp , typename Counter >

data_ptr_t tim::ert::counter< DeviceT, Tp, Counter >::data = std::make_shared<ert_data_t>()

Definition at line 299 of file counter.hpp.

Referenced by tim::ert::counter< DeviceT, Tp, Counter >::get_data(), tim::ert::counter< DeviceT, Tp, Counter >::record(), and tim::ert::counter< DeviceT, Tp, Counter >::serialize().

◆ label

template<typename DeviceT , typename Tp , typename Counter >

std::string tim::ert::counter< DeviceT, Tp, Counter >::label = ""

Definition at line 300 of file counter.hpp.

Referenced by tim::ert::executor< DeviceT, Tp, CounterT >::execute(), tim::ert::executor< device::gpu, Tp, CounterT >::execute(), tim::ert::executor< device::gpu, Tp, CounterT >::execute_impl(), and tim::ert::counter< DeviceT, Tp, Counter >::record().

◆ memory_accesses_per_element

template<typename DeviceT , typename Tp , typename Counter >

int tim::ert::counter< DeviceT, Tp, Counter >::memory_accesses_per_element = 0

Definition at line 296 of file counter.hpp.

Referenced by tim::ert::executor< DeviceT, Tp, CounterT >::execute(), tim::ert::executor< device::gpu, Tp, CounterT >::execute(), tim::ert::executor< device::gpu, Tp, CounterT >::execute_impl(), tim::ert::configuration< DeviceT, Tp, CounterT >::get_executor(), tim::ert::ops_main(), and tim::ert::counter< DeviceT, Tp, Counter >::record().

◆ nsize

template<typename DeviceT , typename Tp , typename Counter >

uint64_t tim::ert::counter< DeviceT, Tp, Counter >::nsize = 0

Definition at line 298 of file counter.hpp.

Referenced by tim::ert::counter< DeviceT, Tp, Counter >::get_buffer(), and tim::ert::ops_main().

◆ params

template<typename DeviceT , typename Tp , typename Counter >

exec_params tim::ert::counter< DeviceT, Tp, Counter >::params = exec_params()

Definition at line 294 of file counter.hpp.

Referenced by tim::ert::ops_main(), tim::ert::counter< DeviceT, Tp, Counter >::record(), and tim::ert::counter< DeviceT, Tp, Counter >::serialize().

◆ skip_ops

template<typename DeviceT , typename Tp , typename Counter >

skip_ops_t tim::ert::counter< DeviceT, Tp, Counter >::skip_ops = skip_ops_t()

Definition at line 301 of file counter.hpp.

Referenced by tim::ert::counter< DeviceT, Tp, Counter >::add_skip_ops(), and tim::ert::counter< DeviceT, Tp, Counter >::skip().

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

timemory/ert/counter.hpp

Public Types

Public Member Functions

Public Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ callback_type

◆ counter_type

◆ data_ptr_t

◆ data_type

◆ ert_data_t

◆ lock_t

◆ mutex_t

◆ skip_ops_t

◆ this_type

◆ ull

Constructor & Destructor Documentation

◆ counter() [1/5]

◆ ~counter()

◆ counter() [2/5]

◆ counter() [3/5]

◆ counter() [4/5]

◆ counter() [5/5]

Member Function Documentation

◆ add_skip_ops() [1/2]

◆ add_skip_ops() [2/2]

◆ configure()

◆ destroy_buffer()

◆ get_buffer() [1/2]

◆ get_buffer() [2/2]

◆ get_counter()

◆ get_data() [1/2]

◆ get_data() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ record()

◆ serialize()

◆ set_callback()

◆ skip()

Friends And Related Function Documentation

◆ operator<<

Member Data Documentation

◆ align

◆ bytes_per_element

◆ data

◆ label

◆ memory_accesses_per_element

◆ nsize

◆ params

◆ skip_ops