tim::component::read_char Struct Reference

I/O counter for chars read. The number of bytes which this task has caused to be read from storage. This is simply the sum of bytes which this process passed to read() and pread(). It includes things like tty IO and it is unaffected by whether or not actual physical disk IO was required (the read might have been satisfied from pagecache) More...

#include "timemory/components/io/components.hpp"

Collaboration diagram for tim::component::read_char:

Public Types
using	this_type = read_char
using	value_type = std::pair< int64_t, int64_t >
using	base_type = base< this_type, value_type >
using	result_type = std::pair< double, double >
using	unit_type = typename trait::units< this_type >::type
using	display_unit_type = typename trait::units< this_type >::display_type

Public Member Functions
std::string	get_display () const
result_type	get () const
void	start ()
void	stop ()
void	sample ()
	sample a measurement More...
void	sample (const cache_type &_cache)
	sample a measurement from cached data More...
void	start (const cache_type &_cache)
	start a measurement using the cached data More...
void	stop (const cache_type &_cache)
	stop a measurement using the cached data More...

Static Public Member Functions
static std::string	label ()
static std::string	description ()
static std::pair< double, double >	unit ()
static std::vector< std::string >	display_unit_array ()
static std::vector< std::string >	label_array ()
static display_unit_type	display_unit ()
static std::pair< double, double >	unit_array ()
static std::vector< std::string >	description_array ()
static auto	get_timestamp ()
static value_type	record ()
static auto	get_timing_unit ()
static unit_type	get_unit ()
static display_unit_type	get_display_unit ()
static value_type	record (const cache_type &_cache)
	read the value from cached data More...

Detailed Description

I/O counter for chars read. The number of bytes which this task has caused to be read from storage. This is simply the sum of bytes which this process passed to read() and pread(). It includes things like tty IO and it is unaffected by whether or not actual physical disk IO was required (the read might have been satisfied from pagecache)

Definition at line 55 of file components.hpp.

Member Typedef Documentation

base_type

using tim::component::read_char::base_type = base<this_type, value_type>

Definition at line 59 of file components.hpp.

display_unit_type

using tim::component::read_char::display_unit_type = typename trait::units<this_type>::display_type

Definition at line 62 of file components.hpp.

result_type

using tim::component::read_char::result_type = std::pair<double, double>

Definition at line 60 of file components.hpp.

this_type

using tim::component::read_char::this_type = read_char

Definition at line 57 of file components.hpp.

unit_type

using tim::component::read_char::unit_type = typename trait::units<this_type>::type

Definition at line 61 of file components.hpp.

value_type

using tim::component::read_char::value_type = std::pair<int64_t, int64_t>

Definition at line 58 of file components.hpp.

Member Function Documentation

description()

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

inlinestatic

Definition at line 65 of file components.hpp.

    {
        return "Number of bytes which this task has caused to be read from storage. Sum "
               "of bytes which this process passed to read() and pread(). Not disk IO.";
    }

description_array()

static std::vector<std::string> tim::component::read_char::description_array ( )

inlinestatic

Definition at line 96 of file components.hpp.

    {
        return std::vector<std::string>{ "Number of char read", "Rate of char read" };
    }

display_unit()

static display_unit_type tim::component::read_char::display_unit ( )

inlinestatic

Definition at line 89 of file components.hpp.

    {
        return display_unit_type{ "MB", "MB/sec" };
    }

Referenced by get_display_unit(), tim::component::written_char::get_display_unit(), tim::component::read_bytes::get_display_unit(), and tim::component::written_bytes::get_display_unit().

display_unit_array()

static std::vector<std::string> tim::component::read_char::display_unit_array ( )

inlinestatic

Definition at line 78 of file components.hpp.

    {
        return std::vector<std::string>{ std::get<0>(get_display_unit()),
                                         std::get<1>(get_display_unit()) };
    }

References get_display_unit().

get()

result_type tim::component::read_char::get ( ) const

inline

Definition at line 140 of file components.hpp.

    {
        auto val = base_type::load();
 
        double data  = std::get<0>(val);
        double delta = std::get<1>(val);
 
        delta /= static_cast<double>(std::nano::den);
        delta *= get_timing_unit();
 
        double rate = 0.0;
        if(delta != 0.0)
            rate = data / delta;
 
        if(laps > 0)
            rate *= laps;
 
        data /= std::get<0>(get_unit());
        rate /= std::get<0>(get_unit());
 
        if(!std::isfinite(rate))
            rate = 0.0;
 
        return result_type(data, rate);
    }

References get_timing_unit(), get_unit(), tim::isfinite(), tim::component::base< read_char, std::pair< int64_t, int64_t > >::laps, and tim::component::base< Tp, Value >::load().

Referenced by get_display(), tim::component::written_char::get_display(), tim::component::read_bytes::get_display(), and tim::component::written_bytes::get_display().

get_display()

std::string tim::component::read_char::get_display ( ) const

inline

Definition at line 113 of file components.hpp.

    {
        std::stringstream ss;
        std::stringstream ssv;
        std::stringstream ssr;
        auto              _prec  = base_type::get_precision();
        auto              _width = base_type::get_width();
        auto              _flags = base_type::get_format_flags();
        auto              _disp  = get_display_unit();
 
        auto _val = get();
 
        ssv.setf(_flags);
        ssv << std::setw(_width) << std::setprecision(_prec) << std::get<0>(_val);
        if(!std::get<0>(_disp).empty())
            ssv << " " << std::get<0>(_disp);
 
        ssr.setf(_flags);
        ssr << std::setw(_width) << std::setprecision(_prec) << std::get<1>(_val);
        if(!std::get<1>(_disp).empty())
            ssr << " " << std::get<1>(_disp);
 
        ss << ssv.str() << ", " << ssr.str();
        ss << " rchar";
        return ss.str();
    }

References get(), get_display_unit(), tim::component::base< Tp, Value >::get_format_flags(), tim::component::base< Tp, Value >::get_precision(), and tim::component::base< Tp, Value >::get_width().

get_display_unit()

static display_unit_type tim::component::read_char::get_display_unit ( )

inlinestatic

Definition at line 199 of file components.hpp.

    {
        static display_unit_type _instance = this_type::display_unit();
        static auto&             _mem      = std::get<0>(_instance);
        static auto&             _rate     = std::get<1>(_instance);
 
        if(settings::memory_units().length() > 0)
            _mem = std::get<0>(units::get_memory_unit(settings::memory_units()));
 
        if(settings::timing_units().length() > 0)
        {
            auto _tval = std::get<0>(units::get_timing_unit(settings::timing_units()));
            _rate      = mpl::apply<std::string>::join('/', _mem, _tval);
        }
        else if(settings::memory_units().length() > 0)
        {
            _rate = mpl::apply<std::string>::join('/', _mem, "sec");
        }
 
        return _instance;
    }

References display_unit(), tim::units::get_memory_unit(), tim::units::get_timing_unit(), tim::mpl::apply< Ret >::join(), tim::memory_units, and tim::timing_units.

Referenced by display_unit_array(), tim::component::written_char::display_unit_array(), tim::component::read_bytes::display_unit_array(), tim::component::written_bytes::display_unit_array(), get_display(), tim::component::written_char::get_display(), tim::component::read_bytes::get_display(), and tim::component::written_bytes::get_display().

get_timestamp()

static auto tim::component::read_char::get_timestamp ( )

inlinestatic

Definition at line 101 of file components.hpp.

{ return tim::get_clock_real_now<int64_t, std::nano>(); }

Referenced by record(), tim::component::written_char::record(), tim::component::read_bytes::record(), and tim::component::written_bytes::record().

get_timing_unit()

static auto tim::component::read_char::get_timing_unit ( )

inlinestatic

Definition at line 105 of file components.hpp.

    {
        static auto _value = units::sec;
        if(settings::timing_units().length() > 0)
            _value = std::get<1>(units::get_timing_unit(settings::timing_units()));
        return _value;
    }

References tim::units::get_timing_unit(), and tim::timing_units.

Referenced by get(), tim::component::written_char::get(), tim::component::read_bytes::get(), and tim::component::written_bytes::get().

get_unit()

static unit_type tim::component::read_char::get_unit ( )

inlinestatic

Definition at line 176 of file components.hpp.

    {
        static auto  _instance = this_type::unit();
        static auto& _mem      = std::get<0>(_instance);
        static auto& _rate     = std::get<1>(_instance);
 
        if(settings::memory_units().length() > 0)
            _mem = std::get<1>(units::get_memory_unit(settings::memory_units()));
 
        if(settings::timing_units().length() > 0)
        {
            auto _timing_val =
                std::get<1>(units::get_timing_unit(settings::timing_units()));
            _rate = _mem / (_timing_val);
        }
 
        static const auto factor = static_cast<double>(std::nano::den);
        unit_type         _tmp   = _instance;
        std::get<1>(_tmp) *= factor;
 
        return _tmp;
    }

References tim::units::get_memory_unit(), tim::units::get_timing_unit(), tim::memory_units, tim::timing_units, and unit().

Referenced by get(), tim::component::written_char::get(), tim::component::read_bytes::get(), and tim::component::written_bytes::get().

label()

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

inlinestatic

Definition at line 64 of file components.hpp.

{ return "read_char"; }

Referenced by label_array(), tim::component::written_char::label_array(), tim::component::read_bytes::label_array(), and tim::component::written_bytes::label_array().

label_array()

static std::vector<std::string> tim::component::read_char::label_array ( )

inlinestatic

Definition at line 84 of file components.hpp.

    {
        return std::vector<std::string>{ label(), "read_rate" };
    }

References label().

record() [1/2]

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

inlinestatic

Definition at line 103 of file components.hpp.

{ return value_type(get_char_read(), get_timestamp()); }

References get_timestamp().

Referenced by start(), tim::component::written_char::start(), tim::component::read_bytes::start(), tim::component::written_bytes::start(), stop(), tim::component::written_char::stop(), tim::component::read_bytes::stop(), and tim::component::written_bytes::stop().

record() [2/2]

static value_type tim::component::read_char::record ( const cache_type &  _cache )

inlinestatic

read the value from cached data

Definition at line 236 of file components.hpp.

    {
        return value_type{ _cache.get_char_read(), get_timestamp() };
    }

References get_timestamp().

sample() [1/2]

void tim::component::read_char::sample ( )

inline

sample a measurement

Definition at line 222 of file components.hpp.

    {
        std::get<0>(accum) = std::get<0>(value) =
            std::max<int64_t>(std::get<0>(value), get_char_read());
    }

sample() [2/2]

void tim::component::read_char::sample ( const cache_type &  _cache )

inline

sample a measurement from cached data

Definition at line 229 of file components.hpp.

    {
        std::get<0>(accum) = std::get<0>(value) =
            std::max<int64_t>(std::get<0>(value), _cache.get_char_read());
    }

start() [1/2]

void tim::component::read_char::start ( )

inline

Definition at line 166 of file components.hpp.

{ value = record(); }

References record().

start() [2/2]

void tim::component::read_char::start ( const cache_type &  _cache )

inline

start a measurement using the cached data

Definition at line 242 of file components.hpp.

{ value = record(_cache); }

References record().

stop() [1/2]

void tim::component::read_char::stop ( )

inline

Definition at line 168 of file components.hpp.

    {
        using namespace tim::component::operators;
        auto diff         = (record() - value);
        std::get<0>(diff) = std::abs(std::get<0>(diff));
        accum += (value = diff);
    }

References tim::math::abs, and record().

stop() [2/2]

void tim::component::read_char::stop ( const cache_type &  _cache )

inline

stop a measurement using the cached data

Definition at line 245 of file components.hpp.

    {
        using namespace tim::component::operators;
        auto diff         = (record(_cache) - value);
        std::get<0>(diff) = std::abs(std::get<0>(diff));
        accum += (value = diff);
    }

References tim::math::abs, and record().

unit()

static std::pair<double, double> tim::component::read_char::unit ( )

inlinestatic

Definition at line 71 of file components.hpp.

    {
        return std::pair<double, double>{
            units::megabyte, static_cast<double>(units::megabyte) / units::sec
        };
    }

Referenced by get_unit(), tim::component::written_char::get_unit(), tim::component::read_bytes::get_unit(), tim::component::written_bytes::get_unit(), unit_array(), tim::component::written_char::unit_array(), tim::component::read_bytes::unit_array(), and tim::component::written_bytes::unit_array().

unit_array()

static std::pair<double, double> tim::component::read_char::unit_array ( )

inlinestatic

Definition at line 94 of file components.hpp.

{ return unit(); }

References unit().

---

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

• timemory/components/io/components.hpp