// 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;
}