cpp/watchdog/server/src/IoPerfCollection.h - platform/packages/services/Car - Gitiles

 /**
  * Copyright (c) 2020, 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 CPP_WATCHDOG_SERVER_SRC_IOPERFCOLLECTION_H_
 #define CPP_WATCHDOG_SERVER_SRC_IOPERFCOLLECTION_H_

 #include "PackageInfoResolver.h"
 #include "ProcDiskStats.h"
 #include "ProcPidStat.h"
 #include "ProcStat.h"
 #include "UidIoStats.h"
 #include "WatchdogPerfService.h"

 #include <android-base/result.h>
 #include <cutils/multiuser.h>
 #include <gtest/gtest_prod.h>
 #include <utils/Errors.h>
 #include <utils/Mutex.h>
 #include <utils/RefBase.h>

 #include <ctime>
 #include <string>
 #include <unordered_set>
 #include <vector>

 namespace android {
 namespace automotive {
 namespace watchdog {

 // Number of periodic collection perf data snapshots to cache in memory.
 const int32_t kDefaultPeriodicCollectionBufferSize = 180;
 constexpr const char* kEmptyCollectionMessage = "No collection recorded\n";

 // Performance data collected from the `/proc/uid_io/stats` file.
 struct UidIoPerfData {
     struct Stats {
         userid_t userId = 0;
         std::string packageName;
         int64_t bytes[UID_STATES];
         int64_t fsync[UID_STATES];
     };
     std::vector<Stats> topNReads = {};
     std::vector<Stats> topNWrites = {};
     int64_t total[METRIC_TYPES][UID_STATES] = {{0}};
 };

 std::string toString(const UidIoPerfData& perfData);

 // Performance data collected from the `/proc/stats` file.
 struct SystemIoPerfData {
     uint64_t cpuIoWaitTime = 0;
     uint64_t totalCpuTime = 0;
     uint32_t ioBlockedProcessesCnt = 0;
     uint32_t totalProcessesCnt = 0;
 };

 std::string toString(const SystemIoPerfData& perfData);

 // Performance data collected from the `/proc/[pid]/stat` and `/proc/[pid]/task/[tid]/stat` files.
 struct ProcessIoPerfData {
     struct UidStats {
         userid_t userId = 0;
         std::string packageName;
         uint64_t count = 0;
         struct ProcessStats {
             std::string comm = "";
             uint64_t count = 0;
         };
         std::vector<ProcessStats> topNProcesses = {};
     };
     std::vector<UidStats> topNIoBlockedUids = {};
     // Total # of tasks owned by each UID in |topNIoBlockedUids|.
     std::vector<uint64_t> topNIoBlockedUidsTotalTaskCnt = {};
     std::vector<UidStats> topNMajorFaultUids = {};
     uint64_t totalMajorFaults = 0;
     // Percentage of increase/decrease in the major page faults since last collection.
     double majorFaultsPercentChange = 0.0;
 };

 std::string toString(const ProcessIoPerfData& data);

 struct IoPerfRecord {
     time_t time;  // Collection time.
     UidIoPerfData uidIoPerfData;
     SystemIoPerfData systemIoPerfData;
     ProcessIoPerfData processIoPerfData;
 };

 std::string toString(const IoPerfRecord& record);

 struct CollectionInfo {
     size_t maxCacheSize = 0;            // Maximum cache size for the collection.
     std::vector<IoPerfRecord> records;  // Cache of collected performance records.
 };

 std::string toString(const CollectionInfo& collectionInfo);

 // Forward declaration for testing use only.
 namespace internal {

 class IoPerfCollectionPeer;

 }  // namespace internal

 // IoPerfCollection implements the I/O performance data collection module.
 class IoPerfCollection : public IDataProcessorInterface {
 public:
     IoPerfCollection() :
           mTopNStatsPerCategory(0),
           mTopNStatsPerSubcategory(0),
           mPackageInfoResolver(PackageInfoResolver::getInstance()),
           mBoottimeCollection({}),
           mPeriodicCollection({}),
           mCustomCollection({}),
           mLastMajorFaults(0) {}

     ~IoPerfCollection() { terminate(); }

     std::string name() { return "IoPerfCollection"; }

     // Implements IDataProcessorInterface.
     android::base::Result<void> onBoottimeCollection(time_t time,
                                                      const android::wp<UidIoStats>& uidIoStats,
                                                      const android::wp<ProcStat>& procStat,
                                                      const android::wp<ProcPidStat>& procPidStat);

     android::base::Result<void> onPeriodicCollection(time_t time, SystemState systemState,
                                                      const android::wp<UidIoStats>& uidIoStats,
                                                      const android::wp<ProcStat>& procStat,
                                                      const android::wp<ProcPidStat>& procPidStat);

     android::base::Result<void> onCustomCollection(
             time_t time, SystemState systemState,
             const std::unordered_set<std::string>& filterPackages,
             const android::wp<UidIoStats>& uidIoStats, const android::wp<ProcStat>& procStat,
             const android::wp<ProcPidStat>& procPidStat);

     android::base::Result<void> onPeriodicMonitor(
             [[maybe_unused]] time_t time,
             [[maybe_unused]] const android::wp<IProcDiskStatsInterface>& procDiskStats,
             [[maybe_unused]] const std::function<void()>& alertHandler) {
         // No monitoring done here as this DataProcessor only collects I/O performance records.
         return {};
     }

     android::base::Result<void> onDump(int fd);

     android::base::Result<void> onCustomCollectionDump(int fd);

 protected:
     android::base::Result<void> init();

     // Clears in-memory cache.
     void terminate();

 private:
     // Processes the collected data.
     android::base::Result<void> processLocked(time_t time,
                                               const std::unordered_set<std::string>& filterPackages,
                                               const android::wp<UidIoStats>& uidIoStats,
                                               const android::wp<ProcStat>& procStat,
                                               const android::wp<ProcPidStat>& procPidStat,
                                               CollectionInfo* collectionInfo);

     // Processes performance data from the `/proc/uid_io/stats` file.
     void processUidIoPerfData(const std::unordered_set<std::string>& filterPackages,
                               const android::wp<UidIoStats>& uidIoStats,
                               UidIoPerfData* uidIoPerfData) const;

     // Processes performance data from the `/proc/stats` file.
     void processSystemIoPerfData(const android::wp<ProcStat>& procStat,
                                  SystemIoPerfData* systemIoPerfData) const;

     // Processes performance data from the `/proc/[pid]/stat` and `/proc/[pid]/task/[tid]/stat`
     // files.
     void processProcessIoPerfDataLocked(const std::unordered_set<std::string>& filterPackages,
                                         const android::wp<ProcPidStat>& procPidStat,
                                         ProcessIoPerfData* processIoPerfData);

     // Top N per-UID stats per category.
     int mTopNStatsPerCategory;

     // Top N per-process stats per subcategory.
     int mTopNStatsPerSubcategory;

     // Local IPackageInfoResolver instance. Useful to mock in tests.
     sp<IPackageInfoResolver> mPackageInfoResolver;

     // Makes sure only one collection is running at any given time.
     Mutex mMutex;

     // Info for the boot-time collection event. The cache is persisted until system shutdown/reboot.
     CollectionInfo mBoottimeCollection GUARDED_BY(mMutex);

     // Info for the periodic collection event. The cache size is limited by
     // |ro.carwatchdog.periodic_collection_buffer_size|.
     CollectionInfo mPeriodicCollection GUARDED_BY(mMutex);

     // Info for the custom collection event. The info is cleared at the end of every custom
     // collection.
     CollectionInfo mCustomCollection GUARDED_BY(mMutex);

     // Major faults delta from last collection. Useful when calculating the percentage change in
     // major faults since last collection.
     uint64_t mLastMajorFaults GUARDED_BY(mMutex);

     friend class WatchdogPerfService;

     // For unit tests.
     friend class internal::IoPerfCollectionPeer;
     FRIEND_TEST(IoPerfCollectionTest, TestUidIoStatsGreaterThanTopNStatsLimit);
     FRIEND_TEST(IoPerfCollectionTest, TestUidIOStatsLessThanTopNStatsLimit);
     FRIEND_TEST(IoPerfCollectionTest, TestProcessSystemIoPerfData);
     FRIEND_TEST(IoPerfCollectionTest, TestProcPidContentsGreaterThanTopNStatsLimit);
     FRIEND_TEST(IoPerfCollectionTest, TestProcPidContentsLessThanTopNStatsLimit);
 };

 }  // namespace watchdog
 }  // namespace automotive
 }  // namespace android

 #endif  //  CPP_WATCHDOG_SERVER_SRC_IOPERFCOLLECTION_H_
	/**
	* Copyright (c) 2020, 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 CPP_WATCHDOG_SERVER_SRC_IOPERFCOLLECTION_H_
	#define CPP_WATCHDOG_SERVER_SRC_IOPERFCOLLECTION_H_

	#include "PackageInfoResolver.h"
	#include "ProcDiskStats.h"
	#include "ProcPidStat.h"
	#include "ProcStat.h"
	#include "UidIoStats.h"
	#include "WatchdogPerfService.h"

	#include <android-base/result.h>
	#include <cutils/multiuser.h>
	#include <gtest/gtest_prod.h>
	#include <utils/Errors.h>
	#include <utils/Mutex.h>
	#include <utils/RefBase.h>

	#include <ctime>
	#include <string>
	#include <unordered_set>
	#include <vector>

	namespace android {
	namespace automotive {
	namespace watchdog {

	// Number of periodic collection perf data snapshots to cache in memory.
	const int32_t kDefaultPeriodicCollectionBufferSize = 180;
	constexpr const char* kEmptyCollectionMessage = "No collection recorded\n";

	// Performance data collected from the `/proc/uid_io/stats` file.
	struct UidIoPerfData {
	struct Stats {
	userid_t userId = 0;
	std::string packageName;
	int64_t bytes[UID_STATES];
	int64_t fsync[UID_STATES];
	};
	std::vector<Stats> topNReads = {};
	std::vector<Stats> topNWrites = {};
	int64_t total[METRIC_TYPES][UID_STATES] = {{0}};
	};

	std::string toString(const UidIoPerfData& perfData);

	// Performance data collected from the `/proc/stats` file.
	struct SystemIoPerfData {
	uint64_t cpuIoWaitTime = 0;
	uint64_t totalCpuTime = 0;
	uint32_t ioBlockedProcessesCnt = 0;
	uint32_t totalProcessesCnt = 0;
	};

	std::string toString(const SystemIoPerfData& perfData);

	// Performance data collected from the `/proc/[pid]/stat` and `/proc/[pid]/task/[tid]/stat` files.
	struct ProcessIoPerfData {
	struct UidStats {
	userid_t userId = 0;
	std::string packageName;
	uint64_t count = 0;
	struct ProcessStats {
	std::string comm = "";
	uint64_t count = 0;
	};
	std::vector<ProcessStats> topNProcesses = {};
	};
	std::vector<UidStats> topNIoBlockedUids = {};
	// Total # of tasks owned by each UID in \|topNIoBlockedUids\|.
	std::vector<uint64_t> topNIoBlockedUidsTotalTaskCnt = {};
	std::vector<UidStats> topNMajorFaultUids = {};
	uint64_t totalMajorFaults = 0;
	// Percentage of increase/decrease in the major page faults since last collection.
	double majorFaultsPercentChange = 0.0;
	};

	std::string toString(const ProcessIoPerfData& data);

	struct IoPerfRecord {
	time_t time; // Collection time.
	UidIoPerfData uidIoPerfData;
	SystemIoPerfData systemIoPerfData;
	ProcessIoPerfData processIoPerfData;
	};

	std::string toString(const IoPerfRecord& record);

	struct CollectionInfo {
	size_t maxCacheSize = 0; // Maximum cache size for the collection.
	std::vector<IoPerfRecord> records; // Cache of collected performance records.
	};

	std::string toString(const CollectionInfo& collectionInfo);

	// Forward declaration for testing use only.
	namespace internal {

	class IoPerfCollectionPeer;

	} // namespace internal

	// IoPerfCollection implements the I/O performance data collection module.
	class IoPerfCollection : public IDataProcessorInterface {
	public:
	IoPerfCollection() :
	mTopNStatsPerCategory(0),
	mTopNStatsPerSubcategory(0),
	mPackageInfoResolver(PackageInfoResolver::getInstance()),
	mBoottimeCollection({}),
	mPeriodicCollection({}),
	mCustomCollection({}),
	mLastMajorFaults(0) {}

	~IoPerfCollection() { terminate(); }

	std::string name() { return "IoPerfCollection"; }

	// Implements IDataProcessorInterface.
	android::base::Result<void> onBoottimeCollection(time_t time,
	const android::wp<UidIoStats>& uidIoStats,
	const android::wp<ProcStat>& procStat,
	const android::wp<ProcPidStat>& procPidStat);

	android::base::Result<void> onPeriodicCollection(time_t time, SystemState systemState,
	const android::wp<UidIoStats>& uidIoStats,
	const android::wp<ProcStat>& procStat,
	const android::wp<ProcPidStat>& procPidStat);

	android::base::Result<void> onCustomCollection(
	time_t time, SystemState systemState,
	const std::unordered_set<std::string>& filterPackages,
	const android::wp<UidIoStats>& uidIoStats, const android::wp<ProcStat>& procStat,
	const android::wp<ProcPidStat>& procPidStat);

	android::base::Result<void> onPeriodicMonitor(
	[[maybe_unused]] time_t time,
	[[maybe_unused]] const android::wp<IProcDiskStatsInterface>& procDiskStats,
	[[maybe_unused]] const std::function<void()>& alertHandler) {
	// No monitoring done here as this DataProcessor only collects I/O performance records.
	return {};
	}

	android::base::Result<void> onDump(int fd);

	android::base::Result<void> onCustomCollectionDump(int fd);

	protected:
	android::base::Result<void> init();

	// Clears in-memory cache.
	void terminate();

	private:
	// Processes the collected data.
	android::base::Result<void> processLocked(time_t time,
	const std::unordered_set<std::string>& filterPackages,
	const android::wp<UidIoStats>& uidIoStats,
	const android::wp<ProcStat>& procStat,
	const android::wp<ProcPidStat>& procPidStat,
	CollectionInfo* collectionInfo);

	// Processes performance data from the `/proc/uid_io/stats` file.
	void processUidIoPerfData(const std::unordered_set<std::string>& filterPackages,
	const android::wp<UidIoStats>& uidIoStats,
	UidIoPerfData* uidIoPerfData) const;

	// Processes performance data from the `/proc/stats` file.
	void processSystemIoPerfData(const android::wp<ProcStat>& procStat,
	SystemIoPerfData* systemIoPerfData) const;

	// Processes performance data from the `/proc/[pid]/stat` and `/proc/[pid]/task/[tid]/stat`
	// files.
	void processProcessIoPerfDataLocked(const std::unordered_set<std::string>& filterPackages,
	const android::wp<ProcPidStat>& procPidStat,
	ProcessIoPerfData* processIoPerfData);

	// Top N per-UID stats per category.
	int mTopNStatsPerCategory;

	// Top N per-process stats per subcategory.
	int mTopNStatsPerSubcategory;

	// Local IPackageInfoResolver instance. Useful to mock in tests.
	sp<IPackageInfoResolver> mPackageInfoResolver;

	// Makes sure only one collection is running at any given time.
	Mutex mMutex;

	// Info for the boot-time collection event. The cache is persisted until system shutdown/reboot.
	CollectionInfo mBoottimeCollection GUARDED_BY(mMutex);

	// Info for the periodic collection event. The cache size is limited by
	// \|ro.carwatchdog.periodic_collection_buffer_size\|.
	CollectionInfo mPeriodicCollection GUARDED_BY(mMutex);

	// Info for the custom collection event. The info is cleared at the end of every custom
	// collection.
	CollectionInfo mCustomCollection GUARDED_BY(mMutex);

	// Major faults delta from last collection. Useful when calculating the percentage change in
	// major faults since last collection.
	uint64_t mLastMajorFaults GUARDED_BY(mMutex);

	friend class WatchdogPerfService;

	// For unit tests.
	friend class internal::IoPerfCollectionPeer;
	FRIEND_TEST(IoPerfCollectionTest, TestUidIoStatsGreaterThanTopNStatsLimit);
	FRIEND_TEST(IoPerfCollectionTest, TestUidIOStatsLessThanTopNStatsLimit);
	FRIEND_TEST(IoPerfCollectionTest, TestProcessSystemIoPerfData);
	FRIEND_TEST(IoPerfCollectionTest, TestProcPidContentsGreaterThanTopNStatsLimit);
	FRIEND_TEST(IoPerfCollectionTest, TestProcPidContentsLessThanTopNStatsLimit);
	};

	} // namespace watchdog
	} // namespace automotive
	} // namespace android

	#endif // CPP_WATCHDOG_SERVER_SRC_IOPERFCOLLECTION_H_