tim::component::written_bytes Struct Reference

I/O counter for bytes written. Attempt to count the number of bytes which this process caused to be sent to the storage layer. This is done at page-dirtying time. More...

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

Collaboration diagram for tim::component::written_bytes:

Public Types
using	this_type = written_bytes
using	value_type = std::array< int64_t, 2 >
using	base_type = base< this_type, value_type >
using	result_type = std::array< double, 2 >
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 result_type	unit ()
static std::vector< std::string >	display_unit_array ()
static std::vector< std::string >	label_array ()
static display_unit_type	display_unit ()
static std::array< double, 2 >	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 the cache More...

Detailed Description

I/O counter for bytes written. Attempt to count the number of bytes which this process caused to be sent to the storage layer. This is done at page-dirtying time.

Definition at line 669 of file components.hpp.

Member Typedef Documentation

base_type

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

Definition at line 673 of file components.hpp.

display_unit_type

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

Definition at line 676 of file components.hpp.

result_type

using tim::component::written_bytes::result_type = std::array<double, 2>

Definition at line 674 of file components.hpp.

this_type

using tim::component::written_bytes::this_type = written_bytes

Definition at line 671 of file components.hpp.

unit_type

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

Definition at line 675 of file components.hpp.

value_type

using tim::component::written_bytes::value_type = std::array<int64_t, 2>

Definition at line 672 of file components.hpp.

Member Function Documentation

description()

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

inlinestatic

Definition at line 679 of file components.hpp.

    {
        return "Number of bytes sent to the storage layer";
    }

description_array()

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

inlinestatic

Definition at line 708 of file components.hpp.

    {
        return std::vector<std::string>{ "Number of bytes written",
                                         "Rate of bytes written" };
    }

display_unit()

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

inlinestatic

Definition at line 701 of file components.hpp.

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

display_unit_array()

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

inlinestatic

Definition at line 690 of file components.hpp.

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

References tim::component::read_char::get_display_unit().

get()

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

inline

Definition at line 756 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 tim::component::read_char::get_timing_unit(), tim::component::read_char::get_unit(), tim::isfinite(), tim::component::base< read_char, std::pair< int64_t, int64_t > >::laps, and tim::component::base< Tp, Value >::load().

get_display()

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

inline

Definition at line 729 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 << " write_bytes";
        return ss.str();
    }

References tim::component::read_char::get(), tim::component::read_char::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::written_bytes::get_display_unit ( )

inlinestatic

Definition at line 815 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 tim::component::read_char::display_unit(), tim::units::get_memory_unit(), tim::units::get_timing_unit(), tim::mpl::apply< Ret >::join(), tim::memory_units, and tim::timing_units.

get_timestamp()

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

inlinestatic

Definition at line 714 of file components.hpp.

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

get_timing_unit()

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

inlinestatic

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

get_unit()

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

inlinestatic

Definition at line 792 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 tim::component::read_char::unit().

label()

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

inlinestatic

Definition at line 678 of file components.hpp.

{ return "written_bytes"; }

label_array()

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

inlinestatic

Definition at line 696 of file components.hpp.

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

References tim::component::read_char::label().

record() [1/2]

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

inlinestatic

Definition at line 716 of file components.hpp.

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

References tim::component::read_char::get_timestamp().

record() [2/2]

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

inlinestatic

read the value from the cache

Definition at line 852 of file components.hpp.

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

References tim::component::read_char::get_timestamp().

sample() [1/2]

void tim::component::written_bytes::sample ( )

inline

sample a measurement

Definition at line 838 of file components.hpp.

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

sample() [2/2]

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

inline

sample a measurement from cached data

Definition at line 845 of file components.hpp.

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

start() [1/2]

void tim::component::written_bytes::start ( )

inline

Definition at line 782 of file components.hpp.

{ value = record(); }

References tim::component::read_char::record().

start() [2/2]

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

inline

start a measurement using the cached data

Definition at line 858 of file components.hpp.

{ value = record(_cache); }

References tim::component::read_char::record().

stop() [1/2]

void tim::component::written_bytes::stop ( )

inline

Definition at line 784 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 tim::component::read_char::record().

stop() [2/2]

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

inline

stop a measurement using the cached data

Definition at line 861 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 tim::component::read_char::record().

unit()

static result_type tim::component::written_bytes::unit ( )

inlinestatic

Definition at line 684 of file components.hpp.

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

unit_array()

static std::array<double, 2> tim::component::written_bytes::unit_array ( )

inlinestatic

Definition at line 706 of file components.hpp.

{ return unit(); }

References tim::component::read_char::unit().

---

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

• timemory/components/io/components.hpp