* Copyright (C) 1996 Be, Inc.
* All Rights Reserved
*
* This source code was published by Be, Inc. in the file gnu_x86.tar.gz for R3,
* a mirror is at http://linux.inf.elte.hu/ftp/beos/development/gnu/r3.0/
* needs to link to termcap.
* The GPL should apply here, since AFAIK termcap is GPLed.
*/
* Top -- a program for finding the top cpu-eating threads
*/
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <OS.h>
#include <termios.h>
#include <list>
#include "termcap.h"
static const char IDLE_NAME[] = "idle thread ";
static bigtime_t lastMeasure = 0;
* Keeps track of a single thread's times
*/
struct ThreadTime {
thread_id thid;
bigtime_t user_time;
bigtime_t kernel_time;
bigtime_t total_time() const {
return user_time + kernel_time;
}
bool operator< (const ThreadTime& other) const {
return total_time() > other.total_time();
}
};
* Keeps track of all the threads' times
*/
typedef std::list<ThreadTime> ThreadTimeList;
static char *clear_string;
static char *enter_ca_mode;
static char *exit_ca_mode;
static char *cursor_home;
static char *restore_cursor;
static char *save_cursor;
static int columns;
static int rows;
static int screen_size_changed = 0;
static int cpus;
static void
winch_handler(int notused)
{
(void) notused;
screen_size_changed = 1;
}
static void
sigint_handler(int)
{
tputs(exit_ca_mode, 1, putchar);
tputs(restore_cursor, 1, putchar);
exit(1);
}
static void
init_term()
{
static char buf[2048];
char *entries = &buf[0];
tgetent(buf, getenv("TERM"));
exit_ca_mode = tgetstr("te", &entries);
enter_ca_mode = tgetstr("ti", &entries);
cursor_home = tgetstr("ho", &entries);
clear_string = tgetstr("cl", &entries);
restore_cursor = tgetstr("rc", &entries);
save_cursor = tgetstr("sc", &entries);
tputs(save_cursor, 1, putchar);
tputs(enter_ca_mode, 1, putchar);
tputs(clear_string, 1, putchar);
}
* Calculate the cpu percentage used by a given thread
* Remember: for multiple CPUs, multiply the interval by # cpus
* when calculating
*/
static float
cpu_perc(bigtime_t spent, bigtime_t interval)
{
return ((100.0 * spent) / (cpus * interval));
}
* Compare an old snapshot with the new one
*/
static void
compare(
ThreadTimeList *old,
ThreadTimeList *newList,
bigtime_t uinterval,
int refresh
)
{
bigtime_t oldtime;
bigtime_t newtime;
ThreadTimeList times;
thread_info t;
team_info tm;
bigtime_t total;
bigtime_t utotal;
bigtime_t ktotal;
bigtime_t gtotal;
bigtime_t idletime;
int newthread;
int ignore;
int linecount;
char *p;
* First, merge both old and new lists, computing the differences in time
* Threads in only one list are dropped.
* Threads with no elapsed time are dropped too.
*/
gtotal = 0;
utotal = 0;
ktotal = 0;
ThreadTimeList::iterator it;
ThreadTimeList::iterator itOld;
ThreadTime entry;
for (it = newList->begin(); it != newList->end(); it++) {
newthread = 1;
ignore = 0;
for (itOld = old->begin(); itOld != old->end(); itOld++) {
if (itOld->thid != it->thid) {
continue;
}
newthread = 0;
oldtime = itOld->total_time();
newtime = it->total_time();
if (oldtime == newtime) {
ignore = 1;
break;
}
entry.thid = it->thid;
entry.user_time = (it->user_time - itOld->user_time);
entry.kernel_time = (it->kernel_time - itOld->kernel_time);
}
if (newthread) {
entry.thid = it->thid;
entry.user_time = it->user_time;
entry.kernel_time = it->kernel_time;
}
if (!ignore) {
times.push_back(entry);
total = entry.total_time();
gtotal += total;
utotal += entry.user_time;
ktotal += entry.kernel_time;
}
}
* Sort what we found and print
*/
times.sort();
printf("%6s %7s %7s %7s %4s %16s %-16s \n", "THID", "TOTAL", "USER",
"KERNEL", "%CPU", "TEAM NAME", "THREAD NAME");
linecount = 1;
idletime = 0;
gtotal = 0;
ktotal = 0;
utotal = 0;
for (it = times.begin(); it != times.end(); it++) {
ignore = 0;
if (get_thread_info(it->thid, &t) < B_NO_ERROR) {
strcpy(t.name, "(unknown)");
strcpy(tm.args, "(unknown)");
} else {
if (strncmp(t.name, IDLE_NAME, strlen(IDLE_NAME)) == 0) {
ignore++;
}
if (get_team_info(t.team, &tm) < B_NO_ERROR) {
strcpy(tm.args, "(unknown)");
} else {
if ((p = strrchr(tm.args, '/'))) {
strlcpy(tm.args, p + 1, sizeof(tm.args));
}
}
}
tm.args[16] = 0;
if (columns <= 80)
t.name[16] = 0;
else if (columns - 64 < sizeof(t.name))
t.name[columns - 64] = 0;
total = it->total_time();
if (ignore) {
idletime += total;
} else {
gtotal += total;
ktotal += it->kernel_time;
utotal += it->user_time;
}
if (!ignore && (!refresh || (linecount < (rows - 1)))) {
printf("%6" B_PRId32 " %7.2f %7.2f %7.2f %4.1f %16s %s \n",
it->thid,
total / 1000.0,
(double)(it->user_time / 1000),
(double)(it->kernel_time / 1000),
cpu_perc(total, uinterval),
tm.args,
t.name);
linecount++;
}
}
printf("------ %7.2f %7.2f %7.2f %4.1f%% "
"TOTAL (%4.1f%% idle time, %4.1f%% unknown)",
(double) (gtotal / 1000),
(double) (utotal / 1000),
(double) (ktotal / 1000),
cpu_perc(gtotal, uinterval),
cpu_perc(idletime, uinterval),
cpu_perc(cpus * uinterval - (gtotal + idletime), uinterval));
fflush(stdout);
tputs(clear_string, 1, putchar);
tputs(cursor_home, 1, putchar);
}
static int
adjust_term(bool onlyRows)
{
struct winsize ws;
if (ioctl(1, TIOCGWINSZ, &ws) < 0) {
return (0);
}
if (ws.ws_row <= 0) {
return (0);
}
columns = ws.ws_col;
rows = ws.ws_row;
if (onlyRows)
return 1;
return (1);
}
* Gather up thread data since previous run
*/
static ThreadTimeList
gather(ThreadTimeList *old, int refresh)
{
int32 tmcookie;
int32 thcookie;
thread_info t;
team_info tm;
ThreadTimeList times;
bigtime_t oldLastMeasure;
tmcookie = 0;
oldLastMeasure = lastMeasure;
lastMeasure = system_time();
while (get_next_team_info(&tmcookie, &tm) == B_NO_ERROR) {
thcookie = 0;
while (get_next_thread_info(tm.team, &thcookie, &t) == B_NO_ERROR) {
ThreadTime entry;
entry.thid = t.thread;
entry.user_time = t.user_time;
entry.kernel_time = t.kernel_time;
times.push_back(entry);
}
}
if (old != NULL) {
if (screen_size_changed) {
adjust_term(true);
screen_size_changed = 0;
}
compare(old, ×, system_time() - oldLastMeasure, refresh);
old->clear();
}
return (times);
}
* print usage message and exit
*/
static void
usage(const char *myname)
{
fprintf(stderr, "usage: %s [-d] [-i interval] [-n ntimes]\n", myname);
fprintf(stderr,
" -d, do not clear the screen between displays\n");
fprintf(stderr,
" -i interval, wait `interval' seconds before displaying\n");
fprintf(stderr,
" -n ntimes, display `ntimes' times before exiting\n");
fprintf(stderr, "Default is clear screen, interval=5, ntimes=infinite\n");
exit(1);
}
int
main(int argc, char **argv)
{
ThreadTimeList baseline;
int i;
int iters = -1;
int interval = 5;
int refresh = 1;
system_info sysinfo;
bigtime_t uinterval;
bigtime_t elapsed;
char *myname;
get_system_info (&sysinfo);
cpus = sysinfo.cpu_count;
myname = argv[0];
for (argc--, argv++; argc > 0 && **argv == '-'; argc--, argv++) {
if (strcmp(argv[0], "-i") == 0) {
argc--, argv++;
if (argc == 0) {
usage(myname);
}
interval = atoi(argv[0]);
} else if (strcmp(argv[0], "-n") == 0) {
argc--, argv++;
if (argc == 0) {
usage(myname);
}
iters = atoi(argv[0]);
} else if (strcmp(argv[0], "-d") == 0) {
refresh = 0;
} else {
usage(myname);
}
}
if (argc) {
usage(myname);
}
init_term();
if (refresh) {
if (!adjust_term(false)) {
refresh = 0;
}
}
if (iters >= 0) {
printf("Starting: %d interval%s of %d second%s each\n", iters,
(iters == 1) ? "" : "s", interval,
(interval == 1) ? "" : "s");
}
signal(SIGWINCH, winch_handler);
signal(SIGINT, sigint_handler);
lastMeasure = system_time();
if (iters < 0) {
uinterval = 1 * 1000000 / 2;
baseline = gather(NULL, refresh);
elapsed = system_time() - lastMeasure;
if (elapsed < uinterval)
snooze(uinterval - elapsed);
baseline = gather(&baseline, refresh);
} else
baseline = gather(NULL, refresh);
uinterval = interval * 1000000;
for (i = 0; iters < 0 || i < iters; i++) {
elapsed = system_time() - lastMeasure;
if (elapsed < uinterval)
snooze(uinterval - elapsed);
baseline = gather(&baseline, refresh);
}
tputs(exit_ca_mode, 1, putchar);
tputs(restore_cursor, 1, putchar);
exit(0);
}
