tim::units Namespace Reference

Functions
std::string	time_repr (int64_t _unit)
std::string	mem_repr (int64_t _unit)
std::tuple< std::string, int64_t >	get_memory_unit (std::string _unit)
std::tuple< std::string, int64_t >	get_timing_unit (std::string _unit)

Function Documentation

get_memory_unit()

std::tuple< std::string, int64_t > tim::units::get_memory_unit ( std::string  _unit )

inline

Definition at line 188 of file units.hpp.

{
    using string_t    = std::string;
    using return_type = std::tuple<string_t, int64_t>;
    using inner_t     = std::tuple<string_t, string_t, int64_t>;
 
    if(_unit.length() == 0)
        return return_type{ "MB", tim::units::megabyte };
 
    for(auto& itr : _unit)
        itr = tolower(itr);
 
    for(const auto& itr : { inner_t{ "byte", "b", tim::units::byte },
                            inner_t{ "kilobyte", "kb", tim::units::kilobyte },
                            inner_t{ "megabyte", "mb", tim::units::megabyte },
                            inner_t{ "gigabyte", "gb", tim::units::gigabyte },
                            inner_t{ "terabyte", "tb", tim::units::terabyte },
                            inner_t{ "petabyte", "pb", tim::units::petabyte },
                            inner_t{ "kibibyte", "kib", tim::units::KiB },
                            inner_t{ "mebibyte", "mib", tim::units::MiB },
                            inner_t{ "gibibyte", "gib", tim::units::GiB },
                            inner_t{ "tebibyte", "tib", tim::units::TiB },
                            inner_t{ "pebibyte", "pib", tim::units::PiB } })
    {
        if(_unit == std::get<0>(itr) || _unit == std::get<1>(itr))
        {
            if(std::get<0>(itr) == "byte")
                return return_type(std::get<0>(itr), std::get<2>(itr));
            return return_type(std::get<1>(itr), std::get<2>(itr));
        }
    }
 
    std::cerr << "Warning!! No memory unit matching \"" << _unit << "\". Using default..."
              << std::endl;
 
    return return_type{ "MB", tim::units::megabyte };
}

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

get_timing_unit()

std::tuple< std::string, int64_t > tim::units::get_timing_unit ( std::string  _unit )

inline

Definition at line 229 of file units.hpp.

{
    using string_t    = std::string;
    using strset_t    = std::unordered_set<string_t>;
    using return_type = std::tuple<string_t, int64_t>;
    using inner_t     = std::tuple<string_t, strset_t, int64_t>;
 
    if(_unit.length() == 0)
        return return_type{ "sec", tim::units::sec };
 
    for(auto& itr : _unit)
        itr = tolower(itr);
 
    for(const auto& itr :
        { inner_t{ "nsec", strset_t{ "ns", "nanosecond", "nanoseconds" },
                   tim::units::nsec },
          inner_t{ "usec", strset_t{ "us", "microsecond", "microseconds" },
                   tim::units::usec },
          inner_t{ "msec", strset_t{ "ms", "millisecond", "milliseconds" },
                   tim::units::msec },
          inner_t{ "csec", strset_t{ "cs", "centisecond", "centiseconds" },
                   tim::units::csec },
          inner_t{ "dsec", strset_t{ "ds", "decisecond", "deciseconds" },
                   tim::units::dsec },
          inner_t{ "sec", strset_t{ "s", "second", "seconds" }, tim::units::sec },
          inner_t{ "min", strset_t{ "minute", "minutes" }, tim::units::minute },
          inner_t{ "hr", strset_t{ "hr", "hour", "hours" }, tim::units::hour } })
    {
        if(_unit == std::get<0>(itr) ||
           std::get<1>(itr).find(_unit) != std::get<1>(itr).end())
        {
            return return_type{ std::get<0>(itr), std::get<2>(itr) };
        }
    }
 
    std::cerr << "Warning!! No timing unit matching \"" << _unit << "\". Using default..."
              << std::endl;
 
    return return_type{ "sec", tim::units::sec };
}

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

mem_repr()

std::string tim::units::mem_repr ( int64_t  _unit )

inline

Definition at line 164 of file units.hpp.

{
    std::string _sunit;
    switch(_unit)
    {
        case byte: _sunit = "B"; break;
        case kilobyte: _sunit = "KB"; break;
        case megabyte: _sunit = "MB"; break;
        case gigabyte: _sunit = "GB"; break;
        case terabyte: _sunit = "TB"; break;
        case petabyte: _sunit = "PB"; break;
        case kibibyte: _sunit = "KiB"; break;
        case mebibyte: _sunit = "MiB"; break;
        case gibibyte: _sunit = "GiB"; break;
        case tebibyte: _sunit = "TiB"; break;
        case pebibyte: _sunit = "PiB"; break;
        default: _sunit = "UNK"; break;
    }
    return _sunit;
}

time_repr()

std::string tim::units::time_repr ( int64_t  _unit )

inline

Definition at line 145 of file units.hpp.

{
    std::string _sunit;
    switch(_unit)
    {
        case nsec: _sunit = "nsec"; break;
        case usec: _sunit = "usec"; break;
        case msec: _sunit = "msec"; break;
        case csec: _sunit = "csec"; break;
        case dsec: _sunit = "dsec"; break;
        case sec: _sunit = "sec"; break;
        default: _sunit = "UNK"; break;
    }
    return _sunit;
}

Referenced by tim::component::ert_timer::get_display_unit().