latencytop/latencytop.c - platform/system/extras - Git at Google

 /*
  * Copyright (C) 2008 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 <ctype.h>
 #include <dirent.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>

 #define MAX_LINE 512
 #define MAX_FILENAME 64

 const char *EXPECTED_VERSION = "Latency Top version : v0.1\n";
 const char *SYSCTL_FILE = "/proc/sys/kernel/latencytop";
 const char *GLOBAL_STATS_FILE = "/proc/latency_stats";
 const char *THREAD_STATS_FILE_FORMAT = "/proc/%d/task/%d/latency";

 struct latency_entry {
     struct latency_entry *next;
     unsigned long count;
     unsigned long max;
     unsigned long total;
     char reason[MAX_LINE];
 };

 static inline void check_latencytop() { }

 static struct latency_entry *read_global_stats(struct latency_entry *list, int erase);
 static struct latency_entry *read_process_stats(struct latency_entry *list, int erase, int pid);
 static struct latency_entry *read_thread_stats(struct latency_entry *list, int erase, int pid, int tid, int fatal);

 static struct latency_entry *alloc_latency_entry(void);
 static void free_latency_entry(struct latency_entry *e);

 static void set_latencytop(int on);
 static struct latency_entry *read_latency_file(FILE *f, struct latency_entry *list);
 static void erase_latency_file(FILE *f);

 static struct latency_entry *find_latency_entry(struct latency_entry *e, char *reason);
 static void print_latency_entries(struct latency_entry *head);

 static void signal_handler(int sig);
 static void disable_latencytop(void);

 static int numcmp(const long long a, const long long b);
 static int lat_cmp(const void *a, const void *b);

 static void clear_screen(void);
 static void usage(const char *cmd);

 struct latency_entry *free_entries;

 int main(int argc, char *argv[]) {
     struct latency_entry *e;
     int delay, iterations;
     int pid, tid;
     int count, erase;
     int i;

     delay = 1;
     iterations = 0;
     pid = tid = 0;

     for (i = 1; i < argc; i++) {
         if (!strcmp(argv[i], "-d")) {
             if (i >= argc - 1) {
                 fprintf(stderr, "Option -d expects an argument.\n");
                 exit(EXIT_FAILURE);
             }
             delay = atoi(argv[++i]);
             continue;
         }
         if (!strcmp(argv[i], "-n")) {
             if (i >= argc - 1) {
                 fprintf(stderr, "Option -n expects an argument.\n");
                 exit(EXIT_FAILURE);
             }
             iterations = atoi(argv[++i]);
             continue;
         }
         if (!strcmp(argv[i], "-h")) {
             usage(argv[0]);
             exit(EXIT_SUCCESS);
         }
         if (!strcmp(argv[i], "-p")) {
             if (i >= argc - 1) {
                 fprintf(stderr, "Option -p expects an argument.\n");
                 exit(EXIT_FAILURE);
             }
             pid = atoi(argv[++i]);
             continue;
         }
         if (!strcmp(argv[i], "-t")) {
             if (i >= argc - 1) {
                 fprintf(stderr, "Option -t expects an argument.\n");
                 exit(EXIT_FAILURE);
             }
             tid = atoi(argv[++i]);
             continue;
         }
         fprintf(stderr, "Invalid argument \"%s\".\n", argv[i]);
         usage(argv[0]);
         exit(EXIT_FAILURE);
     }

     if (tid && !pid) {
         fprintf(stderr, "If you provide a thread ID with -t, you must provide a process ID with -p.\n");
         exit(EXIT_FAILURE);
     }

     check_latencytop();

     free_entries = NULL;

     signal(SIGINT, &signal_handler);
     signal(SIGTERM, &signal_handler);

     atexit(&disable_latencytop);

     set_latencytop(1);

     count = 0;
     erase = 1;

     while ((iterations == 0) || (count++ < iterations)) {

         sleep(delay);

         e = NULL;
         if (pid) {
             if (tid) {
                 e = read_thread_stats(e, erase, pid, tid, 1);
             } else {
                 e = read_process_stats(e, erase, pid);
             }
         } else {
             e = read_global_stats(e, erase);
         }
         erase = 0;

         clear_screen();
         if (pid) {
             if (tid) {
                 printf("Latencies for thread %d in process %d:\n", tid, pid);
             } else {
                 printf("Latencies for process %d:\n", pid);
             }
         } else {
             printf("Latencies across all processes:\n");
         }
         print_latency_entries(e);
     }

     set_latencytop(0);

     return 0;
 }

 static struct latency_entry *read_global_stats(struct latency_entry *list, int erase) {
     FILE *f;
     struct latency_entry *e;

     if (erase) {
         f = fopen(GLOBAL_STATS_FILE, "w");
         if (!f) {
             fprintf(stderr, "Could not open global latency stats file: %s\n", strerror(errno));
             exit(EXIT_FAILURE);
         }
         fprintf(f, "erase\n");
         fclose(f);
     }

     f = fopen(GLOBAL_STATS_FILE, "r");
     if (!f) {
         fprintf(stderr, "Could not open global latency stats file: %s\n", strerror(errno));
         exit(EXIT_FAILURE);
     }

     e = read_latency_file(f, list);

     fclose(f);

     return e;
 }

 static struct latency_entry *read_process_stats(struct latency_entry *list, int erase, int pid) {
     char dirname[MAX_FILENAME];
     DIR *dir;
     struct dirent *ent;
     struct latency_entry *e;
     int tid;

     sprintf(dirname, "/proc/%d/task", pid);
     dir = opendir(dirname);
     if (!dir) {
         fprintf(stderr, "Could not open task dir for process %d.\n", pid);
         fprintf(stderr, "Perhaps the process has terminated?\n");
         exit(EXIT_FAILURE);
     }

     e = list;
     while ((ent = readdir(dir))) {
         if (!isdigit(ent->d_name[0]))
             continue;

         tid = atoi(ent->d_name);

         e = read_thread_stats(e, erase, pid, tid, 0);
     }

     closedir(dir);

     return e;
 }

 static struct latency_entry *read_thread_stats(struct latency_entry *list, int erase, int pid, int tid, int fatal) {
     char filename[MAX_FILENAME];
     FILE *f;
     struct latency_entry *e;

     sprintf(filename, THREAD_STATS_FILE_FORMAT, pid, tid);

     if (erase) {
         f = fopen(filename, "w");
         if (!f) {
             if (fatal) {
                 fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
                 fprintf(stderr, "Perhaps the process or thread has terminated?\n");
                 exit(EXIT_FAILURE);
             } else {
                 return list;
             }
         }
         fprintf(f, "erase\n");
         fclose(f);
     }

     f = fopen(GLOBAL_STATS_FILE, "r");
     if (!f) {
         if (fatal) {
             fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
             fprintf(stderr, "Perhaps the process or thread has terminated?\n");
             exit(EXIT_FAILURE);
         } else {
             return list;
         }
     }

     e = read_latency_file(f, list);

     fclose(f);

     return e;
 }

 static struct latency_entry *alloc_latency_entry(void) {
     struct latency_entry *e;

     if (free_entries) {
         e = free_entries;
         free_entries = free_entries->next;
     } else {
         e = calloc(1, sizeof(struct latency_entry));
         if (!e) {
             fprintf(stderr, "Could not allocate latency entry: %s\n", strerror(errno));
             exit(EXIT_FAILURE);
         }
     }

     return e;
 }

 static void free_latency_entry(struct latency_entry *e) {
     e->next = free_entries;
     free_entries = e;
 }

 static struct latency_entry *find_latency_entry(struct latency_entry *head, char *reason) {
     struct latency_entry *e;

     e = head;

     while (e) {
         if (!strcmp(e->reason, reason))
             return e;
         e = e->next;
     }

     return NULL;
 }

 static void set_latencytop(int on) {
     FILE *f;

     f = fopen(SYSCTL_FILE, "w");
     if (!f) {
         fprintf(stderr, "Could not open %s: %s\n", SYSCTL_FILE, strerror(errno));
         exit(EXIT_FAILURE);
     }

     fprintf(f, "%d\n", on);

     fclose(f);
 }

 static void erase_latency_file(FILE *f) {
     fprintf(f, "erase\n");
 }

 static struct latency_entry *read_latency_file(FILE *f, struct latency_entry *list) {
     struct latency_entry *e, *head;
     char line[MAX_LINE];
     unsigned long count, max, total;
     char reason[MAX_LINE];

     head = list;

     if (!fgets(line, MAX_LINE, f)) {
         fprintf(stderr, "Could not read latency file version: %s\n", strerror(errno));
         exit(EXIT_FAILURE);
     }

     if (strcmp(line, EXPECTED_VERSION) != 0) {
         fprintf(stderr, "Expected version: %s\n", EXPECTED_VERSION);
         fprintf(stderr, "But got version: %s", line);
         exit(EXIT_FAILURE);
     }

     while (fgets(line, MAX_LINE, f)) {
         sscanf(line, "%ld %ld %ld %s", &count, &total, &max, reason);
         if (max > 0 || total > 0) {
             e = find_latency_entry(head, reason);
             if (e) {
                 e->count += count;
                 if (max > e->max)
                     e->max = max;
                 e->total += total;
             } else {
                 e = alloc_latency_entry();
                 e->count = count;
                 e->max = max;
                 e->total = total;
                 strcpy(e->reason, reason);
                 e->next = head;
                 head = e;
             }
         }
     }

     return head;
 }

 static void print_latency_entries(struct latency_entry *head) {
     struct latency_entry *e, **array;
     unsigned long average;
     int i, count;

     e = head;
     count = 0;
     while (e) {
         count++;
         e = e->next;
     }

     e = head;
     array = calloc(count, sizeof(struct latency_entry *));
     if (!array) {
         fprintf(stderr, "Error allocating array: %s\n", strerror(errno));
         exit(EXIT_FAILURE);
     }
     for (i = 0; i < count; i++) {
         array[i] = e;
         e = e->next;
     }

     qsort(array, count, sizeof(struct latency_entry *), &lat_cmp);

     printf("%10s  %10s  %7s  %s\n", "Maximum", "Average", "Count", "Reason");
     for (i = 0; i < count; i++) {
         e = array[i];
         average = e->total / e->count;
         printf("%4lu.%02lu ms  %4lu.%02lu ms  %7ld  %s\n",
             e->max / 1000, (e->max % 1000) / 10,
             average / 1000, (average % 1000) / 10,
             e->count,
             e->reason);
     }

     free(array);
 }

 static void signal_handler(int sig) {
     exit(EXIT_SUCCESS);
 }

 static void disable_latencytop(void) {
     set_latencytop(0);
 }

 static void clear_screen(void) {
     printf("\n\n");
 }

 static void usage(const char *cmd) {
     fprintf(stderr, "Usage: %s [ -d delay ] [ -n iterations ] [ -p pid [ -t tid ] ] [ -h ]\n"
                     "    -d delay       Time to sleep between updates.\n"
                     "    -n iterations  Number of updates to show (0 = infinite).\n"
                     "    -p pid         Process to monitor (default is all).\n"
                     "    -t tid         Thread (within specified process) to monitor (default is all).\n"
                     "    -h             Display this help screen.\n",
         cmd);
 }

 static int numcmp(const long long a, const long long b) {
     if (a < b) return -1;
     if (a > b) return 1;
     return 0;
 }

 static int lat_cmp(const void *a, const void *b) {
     const struct latency_entry *pa, *pb;

     pa = (*((struct latency_entry **)a));
     pb = (*((struct latency_entry **)b));

     return numcmp(pb->max, pa->max);
 }
	/*
	* Copyright (C) 2008 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 <ctype.h>
	#include <dirent.h>
	#include <errno.h>
	#include <signal.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>

	#define MAX_LINE 512
	#define MAX_FILENAME 64

	const char *EXPECTED_VERSION = "Latency Top version : v0.1\n";
	const char *SYSCTL_FILE = "/proc/sys/kernel/latencytop";
	const char *GLOBAL_STATS_FILE = "/proc/latency_stats";
	const char *THREAD_STATS_FILE_FORMAT = "/proc/%d/task/%d/latency";

	struct latency_entry {
	struct latency_entry *next;
	unsigned long count;
	unsigned long max;
	unsigned long total;
	char reason[MAX_LINE];
	};

	static inline void check_latencytop() { }

	static struct latency_entry read_global_stats(struct latency_entry list, int erase);
	static struct latency_entry read_process_stats(struct latency_entry list, int erase, int pid);
	static struct latency_entry read_thread_stats(struct latency_entry list, int erase, int pid, int tid, int fatal);

	static struct latency_entry *alloc_latency_entry(void);
	static void free_latency_entry(struct latency_entry *e);

	static void set_latencytop(int on);
	static struct latency_entry read_latency_file(FILE f, struct latency_entry *list);
	static void erase_latency_file(FILE *f);

	static struct latency_entry find_latency_entry(struct latency_entry e, char *reason);
	static void print_latency_entries(struct latency_entry *head);

	static void signal_handler(int sig);
	static void disable_latencytop(void);

	static int numcmp(const long long a, const long long b);
	static int lat_cmp(const void a, const void b);

	static void clear_screen(void);
	static void usage(const char *cmd);

	struct latency_entry *free_entries;

	int main(int argc, char *argv[]) {
	struct latency_entry *e;
	int delay, iterations;
	int pid, tid;
	int count, erase;
	int i;

	delay = 1;
	iterations = 0;
	pid = tid = 0;

	for (i = 1; i < argc; i++) {
	if (!strcmp(argv[i], "-d")) {
	if (i >= argc - 1) {
	fprintf(stderr, "Option -d expects an argument.\n");
	exit(EXIT_FAILURE);
	}
	delay = atoi(argv[++i]);
	continue;
	}
	if (!strcmp(argv[i], "-n")) {
	if (i >= argc - 1) {
	fprintf(stderr, "Option -n expects an argument.\n");
	exit(EXIT_FAILURE);
	}
	iterations = atoi(argv[++i]);
	continue;
	}
	if (!strcmp(argv[i], "-h")) {
	usage(argv[0]);
	exit(EXIT_SUCCESS);
	}
	if (!strcmp(argv[i], "-p")) {
	if (i >= argc - 1) {
	fprintf(stderr, "Option -p expects an argument.\n");
	exit(EXIT_FAILURE);
	}
	pid = atoi(argv[++i]);
	continue;
	}
	if (!strcmp(argv[i], "-t")) {
	if (i >= argc - 1) {
	fprintf(stderr, "Option -t expects an argument.\n");
	exit(EXIT_FAILURE);
	}
	tid = atoi(argv[++i]);
	continue;
	}
	fprintf(stderr, "Invalid argument \"%s\".\n", argv[i]);
	usage(argv[0]);
	exit(EXIT_FAILURE);
	}

	if (tid && !pid) {
	fprintf(stderr, "If you provide a thread ID with -t, you must provide a process ID with -p.\n");
	exit(EXIT_FAILURE);
	}

	check_latencytop();

	free_entries = NULL;

	signal(SIGINT, &signal_handler);
	signal(SIGTERM, &signal_handler);

	atexit(&disable_latencytop);

	set_latencytop(1);

	count = 0;
	erase = 1;

	while ((iterations == 0) \|\| (count++ < iterations)) {

	sleep(delay);

	e = NULL;
	if (pid) {
	if (tid) {
	e = read_thread_stats(e, erase, pid, tid, 1);
	} else {
	e = read_process_stats(e, erase, pid);
	}
	} else {
	e = read_global_stats(e, erase);
	}
	erase = 0;

	clear_screen();
	if (pid) {
	if (tid) {
	printf("Latencies for thread %d in process %d:\n", tid, pid);
	} else {
	printf("Latencies for process %d:\n", pid);
	}
	} else {
	printf("Latencies across all processes:\n");
	}
	print_latency_entries(e);
	}

	set_latencytop(0);

	return 0;
	}

	static struct latency_entry read_global_stats(struct latency_entry list, int erase) {
	FILE *f;
	struct latency_entry *e;

	if (erase) {
	f = fopen(GLOBAL_STATS_FILE, "w");
	if (!f) {
	fprintf(stderr, "Could not open global latency stats file: %s\n", strerror(errno));
	exit(EXIT_FAILURE);
	}
	fprintf(f, "erase\n");
	fclose(f);
	}

	f = fopen(GLOBAL_STATS_FILE, "r");
	if (!f) {
	fprintf(stderr, "Could not open global latency stats file: %s\n", strerror(errno));
	exit(EXIT_FAILURE);
	}

	e = read_latency_file(f, list);

	fclose(f);

	return e;
	}

	static struct latency_entry read_process_stats(struct latency_entry list, int erase, int pid) {
	char dirname[MAX_FILENAME];
	DIR *dir;
	struct dirent *ent;
	struct latency_entry *e;
	int tid;

	sprintf(dirname, "/proc/%d/task", pid);
	dir = opendir(dirname);
	if (!dir) {
	fprintf(stderr, "Could not open task dir for process %d.\n", pid);
	fprintf(stderr, "Perhaps the process has terminated?\n");
	exit(EXIT_FAILURE);
	}

	e = list;
	while ((ent = readdir(dir))) {
	if (!isdigit(ent->d_name[0]))
	continue;

	tid = atoi(ent->d_name);

	e = read_thread_stats(e, erase, pid, tid, 0);
	}

	closedir(dir);

	return e;
	}

	static struct latency_entry read_thread_stats(struct latency_entry list, int erase, int pid, int tid, int fatal) {
	char filename[MAX_FILENAME];
	FILE *f;
	struct latency_entry *e;

	sprintf(filename, THREAD_STATS_FILE_FORMAT, pid, tid);

	if (erase) {
	f = fopen(filename, "w");
	if (!f) {
	if (fatal) {
	fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
	fprintf(stderr, "Perhaps the process or thread has terminated?\n");
	exit(EXIT_FAILURE);
	} else {
	return list;
	}
	}
	fprintf(f, "erase\n");
	fclose(f);
	}

	f = fopen(GLOBAL_STATS_FILE, "r");
	if (!f) {
	if (fatal) {
	fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
	fprintf(stderr, "Perhaps the process or thread has terminated?\n");
	exit(EXIT_FAILURE);
	} else {
	return list;
	}
	}

	e = read_latency_file(f, list);

	fclose(f);

	return e;
	}

	static struct latency_entry *alloc_latency_entry(void) {
	struct latency_entry *e;

	if (free_entries) {
	e = free_entries;
	free_entries = free_entries->next;
	} else {
	e = calloc(1, sizeof(struct latency_entry));
	if (!e) {
	fprintf(stderr, "Could not allocate latency entry: %s\n", strerror(errno));
	exit(EXIT_FAILURE);
	}
	}

	return e;
	}

	static void free_latency_entry(struct latency_entry *e) {
	e->next = free_entries;
	free_entries = e;
	}

	static struct latency_entry find_latency_entry(struct latency_entry head, char *reason) {
	struct latency_entry *e;

	e = head;

	while (e) {
	if (!strcmp(e->reason, reason))
	return e;
	e = e->next;
	}

	return NULL;
	}

	static void set_latencytop(int on) {
	FILE *f;

	f = fopen(SYSCTL_FILE, "w");
	if (!f) {
	fprintf(stderr, "Could not open %s: %s\n", SYSCTL_FILE, strerror(errno));
	exit(EXIT_FAILURE);
	}

	fprintf(f, "%d\n", on);

	fclose(f);
	}

	static void erase_latency_file(FILE *f) {
	fprintf(f, "erase\n");
	}

	static struct latency_entry read_latency_file(FILE f, struct latency_entry *list) {
	struct latency_entry e, head;
	char line[MAX_LINE];
	unsigned long count, max, total;
	char reason[MAX_LINE];

	head = list;

	if (!fgets(line, MAX_LINE, f)) {
	fprintf(stderr, "Could not read latency file version: %s\n", strerror(errno));
	exit(EXIT_FAILURE);
	}

	if (strcmp(line, EXPECTED_VERSION) != 0) {
	fprintf(stderr, "Expected version: %s\n", EXPECTED_VERSION);
	fprintf(stderr, "But got version: %s", line);
	exit(EXIT_FAILURE);
	}

	while (fgets(line, MAX_LINE, f)) {
	sscanf(line, "%ld %ld %ld %s", &count, &total, &max, reason);
	if (max > 0 \|\| total > 0) {
	e = find_latency_entry(head, reason);
	if (e) {
	e->count += count;
	if (max > e->max)
	e->max = max;
	e->total += total;
	} else {
	e = alloc_latency_entry();
	e->count = count;
	e->max = max;
	e->total = total;
	strcpy(e->reason, reason);
	e->next = head;
	head = e;
	}
	}
	}

	return head;
	}

	static void print_latency_entries(struct latency_entry *head) {
	struct latency_entry e, *array;
	unsigned long average;
	int i, count;

	e = head;
	count = 0;
	while (e) {
	count++;
	e = e->next;
	}

	e = head;
	array = calloc(count, sizeof(struct latency_entry *));
	if (!array) {
	fprintf(stderr, "Error allocating array: %s\n", strerror(errno));
	exit(EXIT_FAILURE);
	}
	for (i = 0; i < count; i++) {
	array[i] = e;
	e = e->next;
	}

	qsort(array, count, sizeof(struct latency_entry *), &lat_cmp);

	printf("%10s %10s %7s %s\n", "Maximum", "Average", "Count", "Reason");
	for (i = 0; i < count; i++) {
	e = array[i];
	average = e->total / e->count;
	printf("%4lu.%02lu ms %4lu.%02lu ms %7ld %s\n",
	e->max / 1000, (e->max % 1000) / 10,
	average / 1000, (average % 1000) / 10,
	e->count,
	e->reason);
	}

	free(array);
	}

	static void signal_handler(int sig) {
	exit(EXIT_SUCCESS);
	}

	static void disable_latencytop(void) {
	set_latencytop(0);
	}

	static void clear_screen(void) {
	printf("\n\n");
	}

	static void usage(const char *cmd) {
	fprintf(stderr, "Usage: %s [ -d delay ] [ -n iterations ] [ -p pid [ -t tid ] ] [ -h ]\n"
	" -d delay Time to sleep between updates.\n"
	" -n iterations Number of updates to show (0 = infinite).\n"
	" -p pid Process to monitor (default is all).\n"
	" -t tid Thread (within specified process) to monitor (default is all).\n"
	" -h Display this help screen.\n",
	cmd);
	}

	static int numcmp(const long long a, const long long b) {
	if (a < b) return -1;
	if (a > b) return 1;
	return 0;
	}

	static int lat_cmp(const void a, const void b) {
	const struct latency_entry pa, pb;

	pa = (((struct latency_entry *)a));
	pb = (((struct latency_entry *)b));

	return numcmp(pb->max, pa->max);
	}