kcenon::network::utils::memory_profiler Class Reference

#include <memory_profiler.h>

Collaboration diagram for kcenon::network::utils::memory_profiler:

Public Member Functions
void	start (std::chrono::milliseconds interval=std::chrono::milliseconds{1000})
void	stop ()
memory_snapshot	snapshot ()
std::vector< memory_snapshot >	get_history (std::size_t max_count=256) const
void	clear_history ()
std::string	to_tsv () const

Static Public Member Functions
static memory_profiler &	instance ()

Private Member Functions
	memory_profiler ()=default
	~memory_profiler ()
	memory_profiler (const memory_profiler &)=delete
memory_profiler &	operator= (const memory_profiler &)=delete
void	schedule_next_sample ()

Static Private Member Functions
static bool	query_process_memory (std::uint64_t &rss, std::uint64_t &vms)

Private Attributes
std::atomic< bool >	running_ {false}
std::chrono::milliseconds	sampling_interval_ {1000}
std::mutex	mutex_ {}
std::vector< memory_snapshot >	history_ {}
std::size_t	max_history_ {4096}

Detailed Description

Definition at line 32 of file memory_profiler.h.

Constructor & Destructor Documentation

memory_profiler() [1/2]

kcenon::network::utils::memory_profiler::memory_profiler ( )

privatedefault

~memory_profiler()

kcenon::network::utils::memory_profiler::~memory_profiler ( )

private

Definition at line 29 of file memory_profiler.cpp.

{ stop(); }

References stop().

Here is the call graph for this function:

memory_profiler() [2/2]

kcenon::network::utils::memory_profiler::memory_profiler ( const memory_profiler & )

privatedelete

Member Function Documentation

clear_history()

void kcenon::network::utils::memory_profiler::clear_history

(

)

Definition at line 70 of file memory_profiler.cpp.

                                    {
    std::lock_guard<std::mutex> lock(mutex_);
    history_.clear();
}

References history_, and mutex_.

get_history()

std::vector< memory_snapshot > kcenon::network::utils::memory_profiler::get_history

(

std::size_t

max_count = 256

)

const

Definition at line 64 of file memory_profiler.cpp.

                                                                                 {
    std::lock_guard<std::mutex> lock(mutex_);
    if (max_count >= history_.size()) return history_;
    return std::vector<memory_snapshot>(history_.end() - max_count, history_.end());
}

References history_, and mutex_.

instance()

memory_profiler & kcenon::network::utils::memory_profiler::instance ( )

static

Definition at line 24 of file memory_profiler.cpp.

                                           {
    static memory_profiler s;
    return s;
}

operator=()

memory_profiler & kcenon::network::utils::memory_profiler::operator= ( const memory_profiler & )

privatedelete

query_process_memory()

bool kcenon::network::utils::memory_profiler::query_process_memory ( std::uint64_t & rss, std::uint64_t & vms )

staticprivate

Definition at line 104 of file memory_profiler.cpp.

                                                                             {
#if defined(__APPLE__)
    task_basic_info_data_t info;
    mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT;
    if (task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count) != KERN_SUCCESS) {
        return false;
    }
    rss = static_cast<std::uint64_t>(info.resident_size);
    vms = static_cast<std::uint64_t>(info.virtual_size);
    return true;
#elif defined(__linux__)
    FILE* f = std::fopen("/proc/self/statm", "r");
    if (!f) return false;
    long pages_res=0, pages_total=0;
    int rc = std::fscanf(f, "%ld %ld", &pages_total, &pages_res);
    std::fclose(f);
    if (rc != 2) return false;
    long page_size = sysconf(_SC_PAGESIZE);
    vms = static_cast<std::uint64_t>(pages_total) * static_cast<std::uint64_t>(page_size);
    rss = static_cast<std::uint64_t>(pages_res) * static_cast<std::uint64_t>(page_size);
    return true;
#elif defined(_WIN32)
    PROCESS_MEMORY_COUNTERS_EX pmc{};
    if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {
        rss = static_cast<std::uint64_t>(pmc.WorkingSetSize);
        vms = static_cast<std::uint64_t>(pmc.PrivateUsage);
        return true;
    }
    return false;
#else
    // Unknown platform
    rss = vms = 0;
    return false;
#endif
}

Referenced by snapshot().

Here is the caller graph for this function:

schedule_next_sample()

void kcenon::network::utils::memory_profiler::schedule_next_sample ( )

private

Definition at line 88 of file memory_profiler.cpp.

                                           {
#ifdef NETWORK_ENABLE_MEMORY_PROFILER
    if (!running_.load()) return;
 
    kcenon::network::integration::thread_integration_manager::instance()
        .submit_delayed_task(
            [this]() {
                if (running_.load()) {
                    snapshot();
                    schedule_next_sample();
                }
            },
            sampling_interval_);
#endif
}

References kcenon::network::integration::thread_integration_manager::instance(), running_, sampling_interval_, schedule_next_sample(), snapshot(), and kcenon::network::integration::thread_integration_manager::submit_delayed_task().

Referenced by schedule_next_sample(), and start().

Here is the call graph for this function:

Here is the caller graph for this function:

snapshot()

memory_snapshot kcenon::network::utils::memory_profiler::snapshot

(

)

Definition at line 48 of file memory_profiler.cpp.

                                          {
    memory_snapshot snap;
    snap.timestamp = std::chrono::system_clock::now();
    std::uint64_t rss=0, vms=0;
    query_process_memory(rss, vms);
    snap.resident_bytes = rss;
    snap.virtual_bytes = vms;
 
    std::lock_guard<std::mutex> lock(mutex_);
    history_.push_back(snap);
    if (history_.size() > max_history_) {
        history_.erase(history_.begin(), history_.begin() + (history_.size() - max_history_));
    }
    return snap;
}

References history_, max_history_, mutex_, query_process_memory(), kcenon::network::utils::memory_snapshot::resident_bytes, kcenon::network::utils::memory_snapshot::timestamp, and kcenon::network::utils::memory_snapshot::virtual_bytes.

Referenced by schedule_next_sample().

Here is the call graph for this function:

Here is the caller graph for this function:

start()

void kcenon::network::utils::memory_profiler::start

(

std::chrono::milliseconds

interval = std::chrono::milliseconds{1000}

)

Definition at line 31 of file memory_profiler.cpp.

                                                          {
#ifndef NETWORK_ENABLE_MEMORY_PROFILER
    (void)interval;
    return; // profiling disabled
#else
    if (running_.exchange(true)) return;
    sampling_interval_ = interval;
    schedule_next_sample();
#endif
}

References running_, sampling_interval_, and schedule_next_sample().

Here is the call graph for this function:

stop()

void kcenon::network::utils::memory_profiler::stop

(

)

Definition at line 42 of file memory_profiler.cpp.

                           {
#ifdef NETWORK_ENABLE_MEMORY_PROFILER
    running_.store(false);
#endif
}

References running_.

Referenced by ~memory_profiler().

Here is the caller graph for this function:

to_tsv()

std::string kcenon::network::utils::memory_profiler::to_tsv

(

)

const

Definition at line 75 of file memory_profiler.cpp.

                                        {
    std::ostringstream oss;
    std::lock_guard<std::mutex> lock(mutex_);
    for (const auto& s : history_) {
        auto t = std::chrono::system_clock::to_time_t(s.timestamp);
        oss << std::put_time(std::localtime(&t), "%Y-%m-%d %H:%M:%S")
            << '\t' << s.resident_bytes
            << '\t' << s.virtual_bytes
            << '\n';
    }
    return oss.str();
}

References history_, and mutex_.

Member Data Documentation

history_

std::vector<memory_snapshot> kcenon::network::utils::memory_profiler::history_ {}

private

Definition at line 69 of file memory_profiler.h.

{};

Referenced by clear_history(), get_history(), snapshot(), and to_tsv().

max_history_

std::size_t kcenon::network::utils::memory_profiler::max_history_ {4096}

private

Definition at line 70 of file memory_profiler.h.

{4096};

Referenced by snapshot().

mutex_

std::mutex kcenon::network::utils::memory_profiler::mutex_ {}

mutableprivate

Definition at line 68 of file memory_profiler.h.

{};

Referenced by clear_history(), get_history(), snapshot(), and to_tsv().

running_

std::atomic<bool> kcenon::network::utils::memory_profiler::running_ {false}

private

Definition at line 66 of file memory_profiler.h.

{false};

Referenced by schedule_next_sample(), start(), and stop().

sampling_interval_

std::chrono::milliseconds kcenon::network::utils::memory_profiler::sampling_interval_ {1000}

private

Definition at line 67 of file memory_profiler.h.

{1000};

Referenced by schedule_next_sample(), and start().

---

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

• src/internal/utils/memory_profiler.h
• src/internal/utils/memory_profiler.cpp