iotop/iotop.cpp - nest-cam/4320010/iotop - Git at Google

 // Copyright (C) 2015 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.

 #include <getopt.h>
 #include <inttypes.h>
 #include <stdint.h>
 #include <stdlib.h>

 #include <algorithm>
 #include <map>
 #include <unordered_map>
 #include <vector>

 #include <android-base/logging.h>

 #include "tasklist.h"
 #include "taskstats.h"

 constexpr uint64_t NSEC_PER_SEC = 1000000000;

 static uint64_t BytesToKB(uint64_t bytes) {
   return (bytes + 1024-1) / 1024;
 }

 static float TimeToTgidPercent(uint64_t ns, int time, const TaskStatistics& stats) {
   float percent = ns / stats.threads() / (time * NSEC_PER_SEC / 100.0f);
   return std::min(percent, 99.99f);
 }

 static void usage(char* myname) {
   printf(
       "Usage: %s [-h] [-P] [-d <delay>] [-n <cycles>] [-s <column>]\n"
       "   -a  Show byte count instead of rate\n"
       "   -d  Set the delay between refreshes in seconds.\n"
       "   -h  Display this help screen.\n"
       "   -m  Set the number of processes or threads to show\n"
       "   -n  Set the number of refreshes before exiting.\n"
       "   -P  Show processes instead of the default threads.\n"
       "   -s  Set the column to sort by:\n"
       "       pid, read, write, total, io, swap, sched, mem or delay.\n",
       myname);
 }

 using Sorter = std::function<void(std::vector<TaskStatistics>&)>;
 static Sorter GetSorter(const std::string& field) {
   // Generic comparator
   static auto comparator = [](auto& lhs, auto& rhs, auto field, bool ascending) -> bool {
     auto a = (lhs.*field)();
     auto b = (rhs.*field)();
     if (a != b) {
       // Sort by selected field
       return ascending ^ (a < b);
     } else {
       // And then fall back to sorting by pid
       return lhs.pid() < rhs.pid();
     }
   };

   auto make_sorter = [](auto field, bool ascending) {
     // Make closure for comparator on a specific field
     using namespace std::placeholders;
     auto bound_comparator = std::bind(comparator, _1, _2, field, ascending);

     // Return closure to std::sort with specialized comparator
     return [bound_comparator](auto& vector) {
       return std::sort(vector.begin(), vector.end(), bound_comparator);
     };
   };

   static const std::map<std::string, Sorter> sorters{
       {"pid", make_sorter(&TaskStatistics::pid, false)},
       {"read", make_sorter(&TaskStatistics::read, true)},
       {"write", make_sorter(&TaskStatistics::write, true)},
       {"total", make_sorter(&TaskStatistics::read_write, true)},
       {"io", make_sorter(&TaskStatistics::delay_io, true)},
       {"swap", make_sorter(&TaskStatistics::delay_swap, true)},
       {"sched", make_sorter(&TaskStatistics::delay_sched, true)},
       {"mem", make_sorter(&TaskStatistics::delay_mem, true)},
       {"delay", make_sorter(&TaskStatistics::delay_total, true)},
   };

   auto it = sorters.find(field);
   if (it == sorters.end()) {
     return nullptr;
   }
   return it->second;
 }

 int main(int argc, char* argv[]) {
   bool accumulated = false;
   bool processes = false;
   int delay = 1;
   int cycles = -1;
   int limit = -1;
   Sorter sorter = GetSorter("total");

   android::base::InitLogging(argv, android::base::StderrLogger);

   while (1) {
     int c;
     static const option longopts[] = {
         {"accumulated", 0, 0, 'a'},
         {"delay", required_argument, 0, 'd'},
         {"help", 0, 0, 'h'},
         {"limit", required_argument, 0, 'm'},
         {"iter", required_argument, 0, 'n'},
         {"sort", required_argument, 0, 's'},
         {"processes", 0, 0, 'P'},
         {0, 0, 0, 0},
     };
     c = getopt_long(argc, argv, "ad:hm:n:Ps:", longopts, NULL);
     if (c < 0) {
       break;
     }
     switch (c) {
     case 'a':
       accumulated = true;
       break;
     case 'd':
       delay = atoi(optarg);
       break;
     case 'h':
       usage(argv[0]);
       return(EXIT_SUCCESS);
     case 'm':
       limit = atoi(optarg);
       break;
     case 'n':
       cycles = atoi(optarg);
       break;
     case 's': {
       sorter = GetSorter(optarg);
       if (sorter == nullptr) {
         LOG(ERROR) << "Invalid sort column \"" << optarg << "\"";
         usage(argv[0]);
         return(EXIT_FAILURE);
       }
       break;
     }
     case 'P':
       processes = true;
       break;
     case '?':
       usage(argv[0]);
       return(EXIT_FAILURE);
     default:
       abort();
     }
   }

   std::map<pid_t, std::vector<pid_t>> tgid_map;

   TaskstatsSocket taskstats_socket;
   taskstats_socket.Open();

   std::unordered_map<pid_t, TaskStatistics> pid_stats;
   std::unordered_map<pid_t, TaskStatistics> tgid_stats;
   std::vector<TaskStatistics> stats;

   bool first = true;
   bool second = true;

   while (true) {
     stats.clear();
     if (!TaskList::Scan(tgid_map)) {
       LOG(FATAL) << "failed to scan tasks";
     }
     for (auto& tgid_it : tgid_map) {
       pid_t tgid = tgid_it.first;
       std::vector<pid_t>& pid_list = tgid_it.second;

       TaskStatistics tgid_stats_new;
       TaskStatistics tgid_stats_delta;

       if (processes) {
         // If printing processes, collect stats for the tgid which will
         // hold delay accounting data across all threads, including
         // ones that have exited.
         if (!taskstats_socket.GetTgidStats(tgid, tgid_stats_new)) {
           continue;
         }
         tgid_stats_delta = tgid_stats[tgid].Update(tgid_stats_new);
       }

       // Collect per-thread stats
       for (pid_t pid : pid_list) {
         TaskStatistics pid_stats_new;
         if (!taskstats_socket.GetPidStats(pid, pid_stats_new)) {
           continue;
         }

         TaskStatistics pid_stats_delta = pid_stats[pid].Update(pid_stats_new);

         if (processes) {
           tgid_stats_delta.AddPidToTgid(pid_stats_delta);
         } else {
           stats.push_back(pid_stats_delta);
         }
       }

       if (processes) {
         stats.push_back(tgid_stats_delta);
       }
     }

     if (!first) {
       sorter(stats);
       if (!second) {
         printf("\n");
       }
       if (accumulated) {
         printf("%6s %-16s %20s %34s\n", "", "",
             "---- IO (KiB) ----", "----------- delayed on ----------");
       } else {
         printf("%6s %-16s %20s %34s\n", "", "",
             "--- IO (KiB/s) ---", "----------- delayed on ----------");
       }
       printf("%6s %-16s %6s %6s %6s  %-5s  %-5s  %-5s  %-5s  %-5s\n",
           "PID",
           "Command",
           "read",
           "write",
           "total",
           "IO",
           "swap",
           "sched",
           "mem",
           "total");
       int n = limit;
       const int delay_div = accumulated ? 1 : delay;
       uint64_t total_read = 0;
       uint64_t total_write = 0;
       uint64_t total_read_write = 0;
       for (const TaskStatistics& statistics : stats) {
         total_read += statistics.read();
         total_write += statistics.write();
         total_read_write += statistics.read_write();

         if (n == 0) {
           continue;
         } else if (n > 0) {
           n--;
         }

         printf("%6d %-16s %6" PRIu64 " %6" PRIu64 " %6" PRIu64 " %5.2f%% %5.2f%% %5.2f%% %5.2f%% %5.2f%%\n",
             statistics.pid(),
             statistics.comm().c_str(),
             BytesToKB(statistics.read()) / delay_div,
             BytesToKB(statistics.write()) / delay_div,
             BytesToKB(statistics.read_write()) / delay_div,
             TimeToTgidPercent(statistics.delay_io(), delay, statistics),
             TimeToTgidPercent(statistics.delay_swap(), delay, statistics),
             TimeToTgidPercent(statistics.delay_sched(), delay, statistics),
             TimeToTgidPercent(statistics.delay_mem(), delay, statistics),
             TimeToTgidPercent(statistics.delay_total(), delay, statistics));
       }
       printf("%6s %-16s %6" PRIu64 " %6" PRIu64 " %6" PRIu64 "\n", "", "TOTAL",
           BytesToKB(total_read) / delay_div,
           BytesToKB(total_write) / delay_div,
           BytesToKB(total_read_write) / delay_div);

       second = false;

       if (cycles > 0 && --cycles == 0) break;
     }
     first = false;
     sleep(delay);
   }

   return 0;
 }
	// Copyright (C) 2015 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.

	#include <getopt.h>
	#include <inttypes.h>
	#include <stdint.h>
	#include <stdlib.h>

	#include <algorithm>
	#include <map>
	#include <unordered_map>
	#include <vector>

	#include <android-base/logging.h>

	#include "tasklist.h"
	#include "taskstats.h"

	constexpr uint64_t NSEC_PER_SEC = 1000000000;

	static uint64_t BytesToKB(uint64_t bytes) {
	return (bytes + 1024-1) / 1024;
	}

	static float TimeToTgidPercent(uint64_t ns, int time, const TaskStatistics& stats) {
	float percent = ns / stats.threads() / (time * NSEC_PER_SEC / 100.0f);
	return std::min(percent, 99.99f);
	}

	static void usage(char* myname) {
	printf(
	"Usage: %s [-h] [-P] [-d <delay>] [-n <cycles>] [-s <column>]\n"
	" -a Show byte count instead of rate\n"
	" -d Set the delay between refreshes in seconds.\n"
	" -h Display this help screen.\n"
	" -m Set the number of processes or threads to show\n"
	" -n Set the number of refreshes before exiting.\n"
	" -P Show processes instead of the default threads.\n"
	" -s Set the column to sort by:\n"
	" pid, read, write, total, io, swap, sched, mem or delay.\n",
	myname);
	}

	using Sorter = std::function<void(std::vector<TaskStatistics>&)>;
	static Sorter GetSorter(const std::string& field) {
	// Generic comparator
	static auto comparator = [](auto& lhs, auto& rhs, auto field, bool ascending) -> bool {
	auto a = (lhs.*field)();
	auto b = (rhs.*field)();
	if (a != b) {
	// Sort by selected field
	return ascending ^ (a < b);
	} else {
	// And then fall back to sorting by pid
	return lhs.pid() < rhs.pid();
	}
	};

	auto make_sorter = [](auto field, bool ascending) {
	// Make closure for comparator on a specific field
	using namespace std::placeholders;
	auto bound_comparator = std::bind(comparator, _1, _2, field, ascending);

	// Return closure to std::sort with specialized comparator
	return [bound_comparator](auto& vector) {
	return std::sort(vector.begin(), vector.end(), bound_comparator);
	};
	};

	static const std::map<std::string, Sorter> sorters{
	{"pid", make_sorter(&TaskStatistics::pid, false)},
	{"read", make_sorter(&TaskStatistics::read, true)},
	{"write", make_sorter(&TaskStatistics::write, true)},
	{"total", make_sorter(&TaskStatistics::read_write, true)},
	{"io", make_sorter(&TaskStatistics::delay_io, true)},
	{"swap", make_sorter(&TaskStatistics::delay_swap, true)},
	{"sched", make_sorter(&TaskStatistics::delay_sched, true)},
	{"mem", make_sorter(&TaskStatistics::delay_mem, true)},
	{"delay", make_sorter(&TaskStatistics::delay_total, true)},
	};

	auto it = sorters.find(field);
	if (it == sorters.end()) {
	return nullptr;
	}
	return it->second;
	}

	int main(int argc, char* argv[]) {
	bool accumulated = false;
	bool processes = false;
	int delay = 1;
	int cycles = -1;
	int limit = -1;
	Sorter sorter = GetSorter("total");

	android::base::InitLogging(argv, android::base::StderrLogger);

	while (1) {
	int c;
	static const option longopts[] = {
	{"accumulated", 0, 0, 'a'},
	{"delay", required_argument, 0, 'd'},
	{"help", 0, 0, 'h'},
	{"limit", required_argument, 0, 'm'},
	{"iter", required_argument, 0, 'n'},
	{"sort", required_argument, 0, 's'},
	{"processes", 0, 0, 'P'},
	{0, 0, 0, 0},
	};
	c = getopt_long(argc, argv, "ad:hm:n:Ps:", longopts, NULL);
	if (c < 0) {
	break;
	}
	switch (c) {
	case 'a':
	accumulated = true;
	break;
	case 'd':
	delay = atoi(optarg);
	break;
	case 'h':
	usage(argv[0]);
	return(EXIT_SUCCESS);
	case 'm':
	limit = atoi(optarg);
	break;
	case 'n':
	cycles = atoi(optarg);
	break;
	case 's': {
	sorter = GetSorter(optarg);
	if (sorter == nullptr) {
	LOG(ERROR) << "Invalid sort column \"" << optarg << "\"";
	usage(argv[0]);
	return(EXIT_FAILURE);
	}
	break;
	}
	case 'P':
	processes = true;
	break;
	case '?':
	usage(argv[0]);
	return(EXIT_FAILURE);
	default:
	abort();
	}
	}

	std::map<pid_t, std::vector<pid_t>> tgid_map;

	TaskstatsSocket taskstats_socket;
	taskstats_socket.Open();

	std::unordered_map<pid_t, TaskStatistics> pid_stats;
	std::unordered_map<pid_t, TaskStatistics> tgid_stats;
	std::vector<TaskStatistics> stats;

	bool first = true;
	bool second = true;

	while (true) {
	stats.clear();
	if (!TaskList::Scan(tgid_map)) {
	LOG(FATAL) << "failed to scan tasks";
	}
	for (auto& tgid_it : tgid_map) {
	pid_t tgid = tgid_it.first;
	std::vector<pid_t>& pid_list = tgid_it.second;

	TaskStatistics tgid_stats_new;
	TaskStatistics tgid_stats_delta;

	if (processes) {
	// If printing processes, collect stats for the tgid which will
	// hold delay accounting data across all threads, including
	// ones that have exited.
	if (!taskstats_socket.GetTgidStats(tgid, tgid_stats_new)) {
	continue;
	}
	tgid_stats_delta = tgid_stats[tgid].Update(tgid_stats_new);
	}

	// Collect per-thread stats
	for (pid_t pid : pid_list) {
	TaskStatistics pid_stats_new;
	if (!taskstats_socket.GetPidStats(pid, pid_stats_new)) {
	continue;
	}

	TaskStatistics pid_stats_delta = pid_stats[pid].Update(pid_stats_new);

	if (processes) {
	tgid_stats_delta.AddPidToTgid(pid_stats_delta);
	} else {
	stats.push_back(pid_stats_delta);
	}
	}

	if (processes) {
	stats.push_back(tgid_stats_delta);
	}
	}

	if (!first) {
	sorter(stats);
	if (!second) {
	printf("\n");
	}
	if (accumulated) {
	printf("%6s %-16s %20s %34s\n", "", "",
	"---- IO (KiB) ----", "----------- delayed on ----------");
	} else {
	printf("%6s %-16s %20s %34s\n", "", "",
	"--- IO (KiB/s) ---", "----------- delayed on ----------");
	}
	printf("%6s %-16s %6s %6s %6s %-5s %-5s %-5s %-5s %-5s\n",
	"PID",
	"Command",
	"read",
	"write",
	"total",
	"IO",
	"swap",
	"sched",
	"mem",
	"total");
	int n = limit;
	const int delay_div = accumulated ? 1 : delay;
	uint64_t total_read = 0;
	uint64_t total_write = 0;
	uint64_t total_read_write = 0;
	for (const TaskStatistics& statistics : stats) {
	total_read += statistics.read();
	total_write += statistics.write();
	total_read_write += statistics.read_write();

	if (n == 0) {
	continue;
	} else if (n > 0) {
	n--;
	}

	printf("%6d %-16s %6" PRIu64 " %6" PRIu64 " %6" PRIu64 " %5.2f%% %5.2f%% %5.2f%% %5.2f%% %5.2f%%\n",
	statistics.pid(),
	statistics.comm().c_str(),
	BytesToKB(statistics.read()) / delay_div,
	BytesToKB(statistics.write()) / delay_div,
	BytesToKB(statistics.read_write()) / delay_div,
	TimeToTgidPercent(statistics.delay_io(), delay, statistics),
	TimeToTgidPercent(statistics.delay_swap(), delay, statistics),
	TimeToTgidPercent(statistics.delay_sched(), delay, statistics),
	TimeToTgidPercent(statistics.delay_mem(), delay, statistics),
	TimeToTgidPercent(statistics.delay_total(), delay, statistics));
	}
	printf("%6s %-16s %6" PRIu64 " %6" PRIu64 " %6" PRIu64 "\n", "", "TOTAL",
	BytesToKB(total_read) / delay_div,
	BytesToKB(total_write) / delay_div,
	BytesToKB(total_read_write) / delay_div);

	second = false;

	if (cycles > 0 && --cycles == 0) break;
	}
	first = false;
	sleep(delay);
	}

	return 0;
	}