| /* |
| * 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. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #ifndef _IO_USAGE_H_ |
| #define _IO_USAGE_H_ |
| |
| #include <statstype.h> |
| #include <chrono> |
| #include <sstream> |
| #include <string> |
| |
| #include <unordered_map> |
| |
| #define IO_USAGE_BUFFER_SIZE (6 * 30) |
| #define IO_TOP_MAX 5 |
| |
| namespace android { |
| namespace pixel { |
| namespace perfstatsd { |
| |
| class ProcPidIoStats { |
| private: |
| std::chrono::system_clock::time_point mCheckTime; |
| std::vector<uint32_t> mPrevPids; |
| std::vector<uint32_t> mCurrPids; |
| std::unordered_map<uint32_t, std::string> mUidNameMapping; |
| // functions |
| std::vector<uint32_t> getNewPids(); |
| |
| public: |
| void update(bool forceAll); |
| bool getNameForUid(uint32_t uid, std::string *name); |
| }; |
| |
| struct UserIo { |
| uint32_t uid; |
| uint64_t fgRead; |
| uint64_t bgRead; |
| uint64_t fgWrite; |
| uint64_t bgWrite; |
| uint64_t fgFsync; |
| uint64_t bgFsync; |
| |
| UserIo &operator=(const UserIo &other) { |
| uid = other.uid; |
| fgRead = other.fgRead; |
| bgRead = other.bgRead; |
| fgWrite = other.fgWrite; |
| bgWrite = other.bgWrite; |
| fgFsync = other.fgFsync; |
| bgFsync = other.bgFsync; |
| return *this; |
| } |
| |
| UserIo operator-(const UserIo &other) const { |
| UserIo r; |
| r.uid = uid; |
| 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; |
| } |
| |
| UserIo operator+(const UserIo &other) const { |
| UserIo r; |
| r.uid = uid; |
| 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; |
| 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("") {} |
| 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); |
| }; |
| |
| 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, 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, UserIo> calcIncrement( |
| const std::unordered_map<uint32_t, UserIo> &data); |
| void updateTopWrite(UserIo usage); |
| void updateTopRead(UserIo usage); |
| void updateUnknownUidList(); |
| |
| public: |
| IoStats() { |
| mNow = std::chrono::system_clock::now(); |
| mLast = mNow; |
| } |
| 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 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); |
| }; |
| |
| } // namespace perfstatsd |
| } // namespace pixel |
| } // namespace android |
| |
| #endif /* _IO_USAGE_H_ */ |