Refine perfstatsd daemon for io usage part
Bug: 115702127
Test: make perfstatsd -j100 && adb root && adb disable-verity && adb \
reboot && sleep 5 && adb wait-for-device && adb root && sleep 5 && adb \
remount && adb shell setenforce 0 && adb root && adb push \
out/target/product/$TARGET_PRODUCT/vendor/bin/perfstatsd /vendor/bin/ && \
adb shell chmod +x /vendor/bin/perfstatsd && adb reboot && adb \
wait-for-device && adb root
Test: adb shell /vendor/bin/perfstatsd -d
Change-Id: I7ee9868a0d0cfdc7f96b25a129249f145d1f6bf1
diff --git a/perfstatsd/OWNERS b/perfstatsd/OWNERS
new file mode 100644
index 0000000..5f28965
--- /dev/null
+++ b/perfstatsd/OWNERS
@@ -0,0 +1,2 @@
+charleschan@google.com
+jimmyshiu@google.com
diff --git a/perfstatsd/include/io_usage.h b/perfstatsd/include/io_usage.h
index 82c32a1..49232ad 100644
--- a/perfstatsd/include/io_usage.h
+++ b/perfstatsd/include/io_usage.h
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
#define _IO_USAGE_H_
#include <statstype.h>
+#include <chrono>
#include <sstream>
#include <string>
@@ -36,105 +37,113 @@
std::vector<uint32_t> mCurrPids;
std::unordered_map<uint32_t, std::string> mUidNameMapping;
// functions
- std::vector<uint32_t> getNewPids() {
- std::vector<uint32_t> newpids;
- // Not exists in Previous
- for (int i = 0, len = mCurrPids.size(); i < len; i++) {
- if (std::find(mPrevPids.begin(), mPrevPids.end(), mCurrPids[i]) == mPrevPids.end()) {
- newpids.push_back(mCurrPids[i]);
- }
- }
- return newpids;
- }
+ std::vector<uint32_t> getNewPids();
public:
void update(bool forceAll);
bool getNameForUid(uint32_t uid, std::string *name);
};
-struct user_io {
+struct UserIo {
uint32_t uid;
- uint64_t fg_read;
- uint64_t bg_read;
- uint64_t fg_write;
- uint64_t bg_write;
- uint64_t fg_fsync;
- uint64_t bg_fsync;
+ uint64_t fgRead;
+ uint64_t bgRead;
+ uint64_t fgWrite;
+ uint64_t bgWrite;
+ uint64_t fgFsync;
+ uint64_t bgFsync;
- user_io &operator=(const user_io &other) {
+ UserIo &operator=(const UserIo &other) {
uid = other.uid;
- fg_read = other.fg_read;
- bg_read = other.bg_read;
- fg_write = other.fg_write;
- bg_write = other.bg_write;
- fg_fsync = other.fg_fsync;
- bg_fsync = other.bg_fsync;
+ fgRead = other.fgRead;
+ bgRead = other.bgRead;
+ fgWrite = other.fgWrite;
+ bgWrite = other.bgWrite;
+ fgFsync = other.fgFsync;
+ bgFsync = other.bgFsync;
return *this;
}
- user_io operator-(const user_io &other) const {
- user_io r;
+
+ UserIo operator-(const UserIo &other) const {
+ UserIo r;
r.uid = uid;
- r.fg_read = fg_read - other.fg_read;
- r.bg_read = bg_read - other.bg_read;
- r.fg_write = fg_write - other.fg_write;
- r.bg_write = bg_write - other.bg_write;
- r.fg_fsync = fg_fsync - other.fg_fsync;
- r.bg_fsync = bg_fsync - other.bg_fsync;
+ r.fgRead = fgRead - other.fgRead;
+ r.bgRead = bgRead - other.bgRead;
+ r.fgWrite = fgWrite - other.fgWrite;
+ r.bgWrite = bgWrite - other.bgWrite;
+ r.fgFsync = fgFsync - other.fgFsync;
+ r.bgFsync = bgFsync - other.bgFsync;
return r;
}
- user_io operator+(const user_io &other) const {
- user_io r;
+
+ UserIo operator+(const UserIo &other) const {
+ UserIo r;
r.uid = uid;
- r.fg_read = fg_read + other.fg_read;
- r.bg_read = bg_read + other.bg_read;
- r.fg_write = fg_write + other.fg_write;
- r.bg_write = bg_write + other.bg_write;
- r.fg_fsync = fg_fsync + other.fg_fsync;
- r.bg_fsync = bg_fsync + other.bg_fsync;
+ r.fgRead = fgRead + other.fgRead;
+ r.bgRead = bgRead + other.bgRead;
+ r.fgWrite = fgWrite + other.fgWrite;
+ r.bgWrite = bgWrite + other.bgWrite;
+ r.fgFsync = fgFsync + other.fgFsync;
+ r.bgFsync = bgFsync + other.bgFsync;
return r;
}
+ uint64_t sumWrite() { return fgWrite + bgWrite; }
+
+ uint64_t sumRead() { return fgRead + bgRead; }
+
void reset() {
uid = 0;
- fg_read = 0;
- bg_read = 0;
- fg_write = 0;
- bg_write = 0;
- fg_fsync = 0;
- bg_fsync = 0;
+ fgRead = 0;
+ bgRead = 0;
+ fgWrite = 0;
+ bgWrite = 0;
+ fgFsync = 0;
+ bgFsync = 0;
}
};
class ScopeTimer {
private:
+ bool mDisabled;
std::string mName;
std::chrono::system_clock::time_point mStart;
public:
- ScopeTimer();
- ScopeTimer(std::string name);
- ~ScopeTimer();
+ ScopeTimer() : ScopeTimer("") {}
+ ScopeTimer(std::string name) : mDisabled(false), mName(name) {
+ mStart = std::chrono::system_clock::now();
+ }
+ ~ScopeTimer() {
+ if (!mDisabled) {
+ std::string msg;
+ dump(&msg);
+ LOG_TO(SYSTEM, INFO) << msg;
+ }
+ }
+ void setEnabled(bool enabled) { mDisabled = !enabled; }
+ void dump(std::string *outAppend);
};
-const uint64_t IO_USAGE_DUMP_THRESHOLD = 50L * 1000L * 1000L; // 50MB
+constexpr uint64_t IO_USAGE_DUMP_THRESHOLD = 50L * 1000L * 1000L; // 50MB
class IoStats {
private:
uint64_t mMinSizeOfTotalRead = IO_USAGE_DUMP_THRESHOLD;
uint64_t mMinSizeOfTotalWrite = IO_USAGE_DUMP_THRESHOLD;
std::chrono::system_clock::time_point mLast;
std::chrono::system_clock::time_point mNow;
- std::unordered_map<uint32_t, user_io> mPrevious;
- user_io mTotal;
- user_io mWriteTop[IO_TOP_MAX];
- user_io mReadTop[IO_TOP_MAX];
+ std::unordered_map<uint32_t, UserIo> mPrevious;
+ UserIo mTotal;
+ UserIo mWriteTop[IO_TOP_MAX];
+ UserIo mReadTop[IO_TOP_MAX];
std::vector<uint32_t> mUnknownUidList;
std::unordered_map<uint32_t, std::string> mUidNameMap;
ProcPidIoStats mProcIoStats;
// Functions
- std::unordered_map<uint32_t, user_io> calcIncrement(
- const std::unordered_map<uint32_t, user_io> &data);
- void updateTopWrite(user_io usage);
- void updateTopRead(user_io usage);
+ std::unordered_map<uint32_t, UserIo> calcIncrement(
+ const std::unordered_map<uint32_t, UserIo> &data);
+ void updateTopWrite(UserIo usage);
+ void updateTopRead(UserIo usage);
void updateUnknownUidList();
public:
@@ -142,17 +151,19 @@
mNow = std::chrono::system_clock::now();
mLast = mNow;
}
- void calcAll(std::unordered_map<uint32_t, user_io> &&data);
+ void calcAll(std::unordered_map<uint32_t, UserIo> &&data);
void setDumpThresholdSizeForRead(uint64_t size) { mMinSizeOfTotalRead = size; }
void setDumpThresholdSizeForWrite(uint64_t size) { mMinSizeOfTotalWrite = size; }
bool dump(std::stringstream *output);
};
-class io_usage : public StatsType {
+class IoUsage : public StatsType {
private:
+ bool mDisabled;
IoStats mStats;
public:
+ IoUsage() : mDisabled(false) {}
void refresh(void);
void setOptions(const std::string &key, const std::string &value);
};
diff --git a/perfstatsd/io_usage.cpp b/perfstatsd/io_usage.cpp
index 9585f52..7c06791 100644
--- a/perfstatsd/io_usage.cpp
+++ b/perfstatsd/io_usage.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -25,7 +25,7 @@
#include <pwd.h>
using namespace android::pixel::perfstatsd;
-static const char *UID_IO_STATS_PATH = "/proc/uid_io/stats";
+static constexpr const char *UID_IO_STATS_PATH = "/proc/uid_io/stats";
static constexpr char FMT_STR_TOTAL_USAGE[] =
"[IO_TOTAL: %lld.%03llds] RD:%s WR:%s fsync:%" PRIu64 "\n";
static constexpr char STR_TOP_HEADER[] =
@@ -34,24 +34,15 @@
"[W%d:%6.2f%%]%12" PRIu64 ",%12" PRIu64 ",%5" PRIu64 ",%5" PRIu64 " :%6u %s\n";
static constexpr char FMT_STR_TOP_READ_USAGE[] =
"[R%d:%6.2f%%]%12" PRIu64 ",%12" PRIu64 ",%5" PRIu64 ",%5" PRIu64 " :%6u %s\n";
-static constexpr char FMT_STR_SKIP_TOP_READ[] = "(%" PRIu64 "<%" PRIu64 "MB)skip RD";
-static constexpr char FMT_STR_SKIP_TOP_WRITE[] = "(%" PRIu64 "<%" PRIu64 "MB)skip WR";
+static constexpr char FMT_STR_SKIP_TOP_READ[] = "(< %" PRIu64 "MB)skip RD";
+static constexpr char FMT_STR_SKIP_TOP_WRITE[] = "(< %" PRIu64 "MB)skip WR";
-static bool sDisabled = false;
static bool sOptDebug = false;
-static uint64_t io_sum_read(user_io &d) {
- return d.fg_read + d.bg_read;
-}
-
-static uint64_t io_sum_write(user_io &d) {
- return d.fg_write + d.bg_write;
-}
-
/* format number with comma
* Ex: 10000 => 10,000
*/
-static bool print_num(uint64_t x, char *str, int size) {
+static bool formatNum(uint64_t x, char *str, int size) {
int len = snprintf(str, size, "%" PRIu64, x);
if (len + 1 > size) {
return false;
@@ -82,8 +73,20 @@
return false;
}
+std::vector<uint32_t> ProcPidIoStats::getNewPids() {
+ std::vector<uint32_t> newpids;
+ // Not exists in Previous
+ for (int i = 0, len = mCurrPids.size(); i < len; i++) {
+ if (std::find(mPrevPids.begin(), mPrevPids.end(), mCurrPids[i]) == mPrevPids.end()) {
+ newpids.push_back(mCurrPids[i]);
+ }
+ }
+ return newpids;
+}
+
void ProcPidIoStats::update(bool forceAll) {
- ScopeTimer _timer("ProcPidIoStats::update");
+ ScopeTimer _debugTimer("update: /proc/pid/status for UID/Name mapping");
+ _debugTimer.setEnabled(sOptDebug);
if (forceAll) {
mPrevPids.clear();
} else {
@@ -166,10 +169,10 @@
return false;
}
-void IoStats::updateTopRead(user_io usage) {
- user_io tmp;
+void IoStats::updateTopRead(UserIo usage) {
+ UserIo tmp;
for (int i = 0, len = IO_TOP_MAX; i < len; i++) {
- if (io_sum_read(usage) > io_sum_read(mReadTop[i])) {
+ if (usage.sumRead() > mReadTop[i].sumRead()) {
// if new read > old read, then swap values
tmp = mReadTop[i];
mReadTop[i] = usage;
@@ -178,10 +181,10 @@
}
}
-void IoStats::updateTopWrite(user_io usage) {
- user_io tmp;
+void IoStats::updateTopWrite(UserIo usage) {
+ UserIo tmp;
for (int i = 0, len = IO_TOP_MAX; i < len; i++) {
- if (io_sum_write(usage) > io_sum_write(mWriteTop[i])) {
+ if (usage.sumWrite() > mWriteTop[i].sumWrite()) {
// if new write > old write, then swap values
tmp = mWriteTop[i];
mWriteTop[i] = usage;
@@ -194,7 +197,8 @@
if (!mUnknownUidList.size()) {
return;
}
- ScopeTimer _DEBUG_TIME_COUNTER("update uid/name");
+ ScopeTimer _debugTimer("update overall UID/Name");
+ _debugTimer.setEnabled(sOptDebug);
mProcIoStats.update(false);
for (uint32_t i = 0, len = mUnknownUidList.size(); i < len; i++) {
uint32_t uid = mUnknownUidList[i];
@@ -235,11 +239,11 @@
mUnknownUidList.clear();
}
-std::unordered_map<uint32_t, user_io> IoStats::calcIncrement(
- const std::unordered_map<uint32_t, user_io> &data) {
- std::unordered_map<uint32_t, user_io> diffs;
+std::unordered_map<uint32_t, UserIo> IoStats::calcIncrement(
+ const std::unordered_map<uint32_t, UserIo> &data) {
+ std::unordered_map<uint32_t, UserIo> diffs;
for (const auto &it : data) {
- const user_io &d = it.second;
+ const UserIo &d = it.second;
// If data not existed, copy one, else calculate the increment.
if (mPrevious.find(d.uid) == mPrevious.end()) {
diffs[d.uid] = d;
@@ -247,7 +251,7 @@
diffs[d.uid] = d - mPrevious[d.uid];
}
// If uid not existed in UidNameMap, then add into unknown list
- if ((io_sum_read(diffs[d.uid]) || io_sum_write(diffs[d.uid])) &&
+ if ((diffs[d.uid].sumRead() || diffs[d.uid].sumWrite()) &&
mUidNameMap.find(d.uid) == mUidNameMap.end()) {
mUnknownUidList.push_back(d.uid);
}
@@ -257,7 +261,7 @@
return diffs;
}
-void IoStats::calcAll(std::unordered_map<uint32_t, user_io> &&data) {
+void IoStats::calcAll(std::unordered_map<uint32_t, UserIo> &&data) {
// if mList == mNow, it's in init state.
if (mLast == mNow) {
mPrevious = std::move(data);
@@ -274,7 +278,7 @@
mNow = std::chrono::system_clock::now();
// calculate incremental IO throughput
- std::unordered_map<uint32_t, user_io> amounts = calcIncrement(data);
+ std::unordered_map<uint32_t, UserIo> amounts = calcIncrement(data);
// assign current data to Previous for next calculating
mPrevious = std::move(data);
// Reset Total and Tops
@@ -284,7 +288,7 @@
mWriteTop[i].reset();
}
for (const auto &it : amounts) {
- const user_io &d = it.second;
+ const UserIo &d = it.second;
// Add into total
mTotal = mTotal + d;
// Check if it's top
@@ -313,120 +317,98 @@
std::stringstream &out = (*output);
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(mNow - mLast);
- char r_total[32];
- char w_total[32];
- if (!print_num(io_sum_read(mTotal), r_total, 32)) {
- LOG_TO(SYSTEM, ERROR) << "print_num buffer size is too small for read: "
- << io_sum_read(mTotal);
+ char readTotal[32];
+ char writeTotal[32];
+ if (!formatNum(mTotal.sumRead(), readTotal, 32)) {
+ LOG_TO(SYSTEM, ERROR) << "formatNum buffer size is too small for read: "
+ << mTotal.sumRead();
}
- if (!print_num(io_sum_write(mTotal), w_total, 32)) {
- LOG_TO(SYSTEM, ERROR) << "print_num buffer size is too small for write: "
- << io_sum_write(mTotal);
+ if (!formatNum(mTotal.sumWrite(), writeTotal, 32)) {
+ LOG_TO(SYSTEM, ERROR) << "formatNum buffer size is too small for write: "
+ << mTotal.sumWrite();
}
out << android::base::StringPrintf(FMT_STR_TOTAL_USAGE, ms.count() / 1000, ms.count() % 1000,
- r_total, w_total, mTotal.fg_fsync + mTotal.bg_fsync);
+ readTotal, writeTotal, mTotal.fgFsync + mTotal.bgFsync);
- if (io_sum_read(mTotal) >= mMinSizeOfTotalRead ||
- io_sum_write(mTotal) >= mMinSizeOfTotalWrite) {
+ if (mTotal.sumRead() >= mMinSizeOfTotalRead || mTotal.sumWrite() >= mMinSizeOfTotalWrite) {
out << STR_TOP_HEADER;
}
// Dump READ TOP
- user_io total = {};
- if (io_sum_read(mTotal) < mMinSizeOfTotalRead) {
- out << android::base::StringPrintf(FMT_STR_SKIP_TOP_READ, io_sum_read(mTotal),
- mMinSizeOfTotalRead / 1000000)
+ if (mTotal.sumRead() < mMinSizeOfTotalRead) {
+ out << android::base::StringPrintf(FMT_STR_SKIP_TOP_READ, mMinSizeOfTotalRead / 1000000)
<< std::endl;
} else {
for (int i = 0, len = IO_TOP_MAX; i < len; i++) {
- total = total + mReadTop[i];
- }
-
- for (int i = 0, len = IO_TOP_MAX; i < len; i++) {
- user_io &target = mReadTop[i];
- if (io_sum_read(total) == 0) {
+ UserIo &target = mReadTop[i];
+ if (target.sumRead() == 0) {
break;
}
- if (io_sum_read(target) == 0) {
- break;
- }
- float percent = 100.0f * io_sum_read(target) / io_sum_read(total);
+ float percent = 100.0f * target.sumRead() / mTotal.sumRead();
const char *package = mUidNameMap.find(target.uid) == mUidNameMap.end()
? "-"
: mUidNameMap[target.uid].c_str();
out << android::base::StringPrintf(FMT_STR_TOP_READ_USAGE, i + 1, percent,
- target.fg_read, target.bg_read, target.fg_fsync,
- target.bg_fsync, target.uid, package);
+ target.fgRead, target.bgRead, target.fgFsync,
+ target.bgFsync, target.uid, package);
}
}
// Dump WRITE TOP
- total = {};
- if (io_sum_write(mTotal) < mMinSizeOfTotalWrite) {
- out << android::base::StringPrintf(FMT_STR_SKIP_TOP_WRITE, io_sum_write(mTotal),
- mMinSizeOfTotalWrite / 1000000)
+ if (mTotal.sumWrite() < mMinSizeOfTotalWrite) {
+ out << android::base::StringPrintf(FMT_STR_SKIP_TOP_WRITE, mMinSizeOfTotalWrite / 1000000)
<< std::endl;
} else {
for (int i = 0, len = IO_TOP_MAX; i < len; i++) {
- total = total + mWriteTop[i];
- }
-
- for (int i = 0, len = IO_TOP_MAX; i < len; i++) {
- user_io &target = mWriteTop[i];
- if (io_sum_write(total) == 0) {
+ UserIo &target = mWriteTop[i];
+ if (target.sumWrite() == 0) {
break;
}
- if (io_sum_write(target) == 0) {
- break;
- }
- float percent = 100.0f * io_sum_write(target) / io_sum_write(total);
+ float percent = 100.0f * target.sumWrite() / mTotal.sumWrite();
const char *package = mUidNameMap.find(target.uid) == mUidNameMap.end()
? "-"
: mUidNameMap[target.uid].c_str();
out << android::base::StringPrintf(FMT_STR_TOP_WRITE_USAGE, i + 1, percent,
- target.fg_write, target.bg_write, target.fg_fsync,
- target.bg_fsync, target.uid, package);
+ target.fgWrite, target.bgWrite, target.fgFsync,
+ target.bgFsync, target.uid, package);
}
}
return true;
}
-static bool read_line_to_data(std::string &&line, user_io &data) {
+static bool loadDataFromLine(std::string &&line, UserIo &data) {
std::vector<std::string> fields = android::base::Split(line, " ");
if (fields.size() < 11 || !android::base::ParseUint(fields[0], &data.uid) ||
- !android::base::ParseUint(fields[3], &data.fg_read) ||
- !android::base::ParseUint(fields[4], &data.fg_write) ||
- !android::base::ParseUint(fields[7], &data.bg_read) ||
- !android::base::ParseUint(fields[8], &data.bg_write) ||
- !android::base::ParseUint(fields[9], &data.fg_fsync) ||
- !android::base::ParseUint(fields[10], &data.bg_fsync)) {
+ !android::base::ParseUint(fields[3], &data.fgRead) ||
+ !android::base::ParseUint(fields[4], &data.fgWrite) ||
+ !android::base::ParseUint(fields[7], &data.bgRead) ||
+ !android::base::ParseUint(fields[8], &data.bgWrite) ||
+ !android::base::ParseUint(fields[9], &data.fgFsync) ||
+ !android::base::ParseUint(fields[10], &data.bgFsync)) {
LOG_TO(SYSTEM, WARNING) << "Invalid uid I/O stats: \"" << line << "\"";
return false;
}
return true;
}
-ScopeTimer::ScopeTimer() : ScopeTimer("") {}
-ScopeTimer::ScopeTimer(std::string name) {
- mStart = std::chrono::system_clock::now();
- mName = name;
-}
-ScopeTimer::~ScopeTimer() {
- if (sOptDebug) {
- auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
- std::chrono::system_clock::now() - mStart);
- LOG_TO(SYSTEM, INFO) << "duration (" << mName << "): " << ms.count() << "ms";
- }
+void ScopeTimer::dump(std::string *outAppend) {
+ auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+ std::chrono::system_clock::now() - mStart);
+ outAppend->append("duration (");
+ outAppend->append(mName);
+ outAppend->append("): ");
+ outAppend->append(std::to_string(ms.count()));
+ outAppend->append("ms");
}
/*
- * setOptions - io_usage supports following options
+ * setOptions - IoUsage supports following options
* iostats.min : skip dump when R/W amount is lower than the value
* iostats.read.min : skip dump when READ amount is lower than the value
* iostats.write.min : skip dump when WRITE amount is lower than the value
* iostats.debug : 1 - to enable debug log; 0 - disabled
*/
-void io_usage::setOptions(const std::string &key, const std::string &value) {
+void IoUsage::setOptions(const std::string &key, const std::string &value) {
std::stringstream out;
out << "set IO options: " << key << " , " << value;
if (key == "iostats.min" || key == "iostats.read.min" || key == "iostats.write.min" ||
@@ -441,7 +423,7 @@
mStats.setDumpThresholdSizeForRead(val);
mStats.setDumpThresholdSizeForWrite(val);
} else if (key == "iostats.disabled") {
- sDisabled = (val != 0);
+ mDisabled = (val != 0);
} else if (key == "iostats.read.min") {
mStats.setDumpThresholdSizeForRead(val);
} else if (key == "iostats.write.min") {
@@ -453,10 +435,11 @@
}
}
-void io_usage::refresh(void) {
- if (sDisabled)
+void IoUsage::refresh(void) {
+ if (mDisabled)
return;
- ScopeTimer _DEBUG_TIME_COUNTER("refresh");
+ ScopeTimer _debugTimer("refresh");
+ _debugTimer.setEnabled(sOptDebug);
std::string buffer;
if (!android::base::ReadFileToString(UID_IO_STATS_PATH, &buffer)) {
LOG_TO(SYSTEM, ERROR) << UID_IO_STATS_PATH << ": ReadFileToString failed";
@@ -464,13 +447,13 @@
if (sOptDebug)
LOG_TO(SYSTEM, INFO) << "read " << UID_IO_STATS_PATH << " OK.";
std::vector<std::string> lines = android::base::Split(std::move(buffer), "\n");
- std::unordered_map<uint32_t, user_io> datas;
+ std::unordered_map<uint32_t, UserIo> datas;
for (uint32_t i = 0; i < lines.size(); i++) {
if (lines[i].empty()) {
continue;
}
- user_io data;
- if (!read_line_to_data(std::move(lines[i]), data))
+ UserIo data;
+ if (!loadDataFromLine(std::move(lines[i]), data))
continue;
datas[data.uid] = data;
}
diff --git a/perfstatsd/perfstatsd.cpp b/perfstatsd/perfstatsd.cpp
index c69612c..6a16e47 100644
--- a/perfstatsd/perfstatsd.cpp
+++ b/perfstatsd/perfstatsd.cpp
@@ -27,7 +27,7 @@
cpuUsage->setBufferSize(CPU_USAGE_BUFFER_SIZE);
mStats.emplace_back(std::move(cpuUsage));
- std::unique_ptr<StatsType> ioUsage(new io_usage);
+ std::unique_ptr<StatsType> ioUsage(new IoUsage);
ioUsage->setBufferSize(IO_USAGE_BUFFER_SIZE);
mStats.emplace_back(std::move(ioUsage));
}
