Parse /proc/buddyinfo into a Fragmentation health score. More...

#include <DataMgr.h>

Collaboration diagram for Data_Namespace::ProcBuddyinfoParser:

Public Member Functions
	ProcBuddyinfoParser (std::string text={})

auto	operator[] (size_t order)

auto	begin ()

auto	end ()

auto	getFragmentationPercent ()

auto	getInputText ()

Private Attributes
std::string	inputText_

std::vector< size_t >	orders_

size_t	fragmentationPercent_

Detailed Description

Parse /proc/buddyinfo into a Fragmentation health score.

Definition at line 113 of file DataMgr.h.

Constructor & Destructor Documentation

Data_Namespace::ProcBuddyinfoParser::ProcBuddyinfoParser ( std::string text = {} )

inline

Definition at line 119 of file DataMgr.h.

                                        {}) {
     if (text.empty()) {
       std::ifstream f("/proc/buddyinfo");
       std::stringstream ss;
       ss << f.rdbuf();
       text = ss.str();
     }
     inputText_ = text;
 
     const size_t skipped_columns = 4;
     // NOTE(sy): For now this calculation ignores the first four buddyinfo columns,
     // but in the future we could break out subscores by node and/or by zone.
     size_t number_of_columns = 0;
     for (const std::string& line : split(text, "\n")) {
       if (line.empty()) {
         continue;
       }
       const auto columns = split(line);
       CHECK_GT(columns.size(), skipped_columns) << "unexpected line format: " << line;
       if (number_of_columns != 0) {
         CHECK_EQ(columns.size(), number_of_columns)
             << "expected line to have " << number_of_columns << " columns: " << line;
       } else {
         number_of_columns = columns.size();
         orders_.resize(number_of_columns - skipped_columns, 0);
       }
       for (size_t i = skipped_columns; i < number_of_columns; ++i) {
         orders_[i - skipped_columns] += strtoull(columns[i].c_str(), NULL, 10);
       }
     }
 #ifdef __linux__
     const long page_size =
         sysconf(_SC_PAGE_SIZE);  // in case x86-64 is configured to use 2MB pages
 #else
     const long page_size = heavyai::get_page_size();
 #endif
     size_t scaled = 0;
     size_t total = 0;
     for (size_t order = 0; order < orders_.size(); ++order) {
       const size_t bytes = orders_[order] * (size_t(1) << order) * page_size;
       scaled += (bytes * (orders_.size() - 1 - order)) / (orders_.size() - 1);
       total += bytes;
     }
 
     CHECK_GT(total, size_t(0)) << "failed to parse:\n" << text;
     fragmentationPercent_ = (scaled * 100) / total;
   }