/* rtop.c - a simple PMU-based CPU utilization tool
 *
 * Copyright (c) 2009 Google, Inc
 * Contributed by Stephane Eranian <eranian@gmail.com>
 *
 * Based on:
 * Copyright (c) 2004-2006 Hewlett-Packard Development Company, L.P.
 * Contributed by Stephane Eranian <eranian@hpl.hp.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include <sys/types.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <getopt.h>
#include <curses.h>
#include <termios.h>
#include <signal.h>
#include <ctype.h>
#include <math.h>
#include <limits.h>
#include <err.h>

#include "perf_util.h"

#define RTOP_VERSION "0.2"
/* 
 * max number of cpus (threads) supported
 */
#define RTOP_MAX_CPUS		2048 /* MUST BE power of 2 */
#define RTOP_CPUMASK_BITS	(sizeof(unsigned long)<<3)
#define RTOP_CPUMASK_COUNT	(RTOP_MAX_CPUS/RTOP_CPUMASK_BITS)

#define RTOP_CPUMASK_SET(m, g)		((m)[(g)/RTOP_CPUMASK_BITS] |=  (1UL << ((g) % RTOP_CPUMASK_BITS)))
#define RTOP_CPUMASK_CLEAR(m, g)	((m)[(g)/RTOP_CPUMASK_BITS] &= ~(1UL << ((g) % RTOP_CPUMASK_BITS)))
#define RTOP_CPUMASK_ISSET(m, g)	((m)[(g)/RTOP_CPUMASK_BITS] &   (1UL << ((g) % RTOP_CPUMASK_BITS)))

typedef unsigned long rtop_cpumask_t[RTOP_CPUMASK_COUNT];

typedef struct {
	struct {
		int	opt_verbose;
		int	opt_delay;	/* refresh delay in second */
		int	opt_delay_set;
	} program_opt_flags;
	rtop_cpumask_t	cpu_mask;	  /* which CPUs to use in system wide mode */
	long		online_cpus;
	long		selected_cpus;
	unsigned long	cpu_mhz;
} program_options_t;

#define opt_verbose program_opt_flags.opt_verbose
#define opt_delay program_opt_flags.opt_delay
#define opt_delay_set program_opt_flags.opt_delay_set


static program_options_t 	options;
static struct termios		saved_tty;
static int			time_to_quit;
static int			term_rows, term_cols;

static void
get_term_size(void)
{
	int ret;
        struct winsize ws;

	ret = ioctl(1, TIOCGWINSZ, &ws);
	if (ret) 
		err(1, "cannot determine screen size");

	if (ws.ws_row > 10) {
                term_cols = ws.ws_col;
                term_rows = ws.ws_row;
        } else {
                term_cols = 80;
                term_rows = 24;
        }

	if (term_rows < options.selected_cpus)
		errx(1, "you need at least %ld rows on your terminal to display all CPUs", options.selected_cpus);
}

static void
sigwinch_handler(int n)
{
	get_term_size();
}

static void
setup_screen(void)
{
	int ret;

	ret = tcgetattr(0, &saved_tty);
	if (ret == -1)
		errx(1, "cannot save tty settings\n");

	get_term_size();

	initscr();
	nocbreak();
	resizeterm(term_rows, term_cols);
}

static void
close_screen(void)
{
	endwin();

	tcsetattr(0, TCSAFLUSH, &saved_tty);
}

static void
fatal_errorw(char *fmt, ...)
{
	va_list ap;

	close_screen();

	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);

	exit(1);
}

static void
sigint_handler(int n)
{
	time_to_quit = 1;
}

static unsigned long
find_cpu_speed(void)
{
	FILE *fp1;	
	unsigned long f1 = 0, f2 = 0;
	char buffer[128], *p, *value;

	memset(buffer, 0, sizeof(buffer));

	fp1 = fopen("/proc/cpuinfo", "r");
	if (fp1 == NULL)
		return 0;

	for (;;) {
		buffer[0] = '\0';

		p  = fgets(buffer, 127, fp1);
		if (p == NULL)
			break;

		/* skip  blank lines */
		if (*p == '\n') continue;

		p = strchr(buffer, ':');
		if (p == NULL)
			break;

		/*
		 * p+2: +1 = space, +2= firt character
		 * strlen()-1 gets rid of \n
		 */
		*p = '\0';
		value = p+2;

		value[strlen(value)-1] = '\0';

		if (!strncasecmp("cpu MHz", buffer, 7)) {
			float fl;
			sscanf(value, "%f", &fl);
			f1 = lroundf(fl);
			break;
		}
		if (!strncasecmp("BogoMIPS", buffer, 8)) {
			float fl;
			sscanf(value, "%f", &fl);
			f2 = lroundf(fl);
		}
	}
	fclose(fp1);
	return f1 == 0 ? f2 : f1;
}

static void
setup_signals(void)
{
	struct sigaction act;
	sigset_t my_set;

	/*
	 * SIGINT is a asynchronous signal
	 * sent to the process (not a specific thread). POSIX states
	 * that one and only one thread will execute the handler. This
	 * could be any thread that does not have the signal blocked.
	 */

	/*
	 * install SIGINT handler
	 */
	memset(&act,0,sizeof(act));
	sigemptyset(&my_set);
	act.sa_handler = sigint_handler;
	sigaction (SIGINT, &act, 0);

	/*
	 * install SIGWINCH handler
	 */
	memset(&act,0,sizeof(act));
	sigemptyset(&my_set);
	act.sa_handler = sigwinch_handler;
	sigaction (SIGWINCH, &act, 0);
}

static struct option rtop_cmd_options[]={
	{ "help", 0, 0, 1 },
	{ "version", 0, 0, 2 },
	{ "delay", 0, 0, 3 },
	{ "cpu-list", 1, 0, 4 },

	{ "verbose", 0, &options.opt_verbose, 1 },
	{ 0, 0, 0, 0}
};

#define MAX_EVENTS	2

typedef struct {
	uint64_t prev_values[MAX_EVENTS];
	int fd[MAX_EVENTS];
	int cpu;
} cpudesc_t;

/*
 * 	{ u64		nr;
 * 	  { u64		time_enabled; } && PERF_FORMAT_ENABLED
 * 	  { u64		time_running; } && PERF_FORMAT_RUNNING
 * 	  { u64		value;
 * 	    { u64	id;           } && PERF_FORMAT_ID
 * 	  }		cntr[nr];
 */
typedef struct {
	uint64_t nr;
	uint64_t time_enabled;
	uint64_t time_running;
	uint64_t values[2];
} rtop_grp_t;

static void
mainloop(void)
{
	struct perf_event_attr ev[MAX_EVENTS];
	unsigned long itc_delta;
	cpudesc_t *cpus;
	int i, j = 0, k, ncpus = 0;
	int num, ret;

	ncpus = options.selected_cpus;

	cpus = calloc(ncpus, sizeof(cpudesc_t));
	if (!cpus)
		err(1, "cannot allocate file descriptors");

	memset(ev, 0, sizeof(ev));

	/* measure user cycles */
	ev[0].type = PERF_TYPE_HARDWARE;
	ev[0].config = PERF_COUNT_HW_CPU_CYCLES;
	ev[0].read_format = PERF_FORMAT_SCALE|PERF_FORMAT_GROUP;
	ev[0].exclude_kernel = 1;
	ev[0].disabled = 1;
	ev[0].pinned = 0;

	/* measure kernel cycles */
	ev[1].type = PERF_TYPE_HARDWARE;
	ev[1].config = PERF_COUNT_HW_CPU_CYCLES;
	ev[1].exclude_user = 1;
	ev[1].disabled = 1;
	ev[1].pinned = 0;

	num = 2;

	for(i=0, k = 0; ncpus; i++) {
		if (RTOP_CPUMASK_ISSET(options.cpu_mask, i) == 0)
			continue;

		cpus[k].cpu = i;
		cpus[k].fd[0] = -1;
		for(j=0 ; j < num; j++) {
			cpus[k].fd[j] = perf_event_open(ev+j, -1, i, cpus[k].fd[0], 0);
			if (cpus[k].fd[j] == -1)
				fatal_errorw("cannot open event %d on CPU%d: %s\n", j, i, strerror(errno));
		}
		ncpus--;
		k++;
	}
	ncpus = options.selected_cpus;

	itc_delta = options.opt_delay * options.cpu_mhz * 1000000;

	for(i=0; i < ncpus; i++)
		for(j=0; j < num; j++)
			ioctl(cpus[i].fd[j], PERF_EVENT_IOC_ENABLE, 0);
	
	for(;time_to_quit == 0;) {

		sleep(options.opt_delay);

		move(0, 0);

		for(i=0; i < ncpus; i++) {
			uint64_t values[MAX_EVENTS];
			uint64_t raw_values[5];
			double k_cycles, u_cycles, i_cycles, ratio;

			/*
			 * given our events are in the same group, we can do a
			 * group read and get both counts + scaling information
			 */
			ret = read(cpus[i].fd[0], raw_values, sizeof(raw_values));
			if (ret != sizeof(raw_values))
				fatal_errorw("cannot read count for event %d on CPU%d\n", j, cpus[i].cpu);

			printw("nr=%"PRIu64"\n", raw_values[0]);
			printw("ena=%"PRIu64"\n", raw_values[1]);
			printw("run=%"PRIu64"\n", raw_values[2]);

			raw_values[0] = raw_values[3];
			values[0] = perf_scale(raw_values);

			raw_values[0] = raw_values[4];
			values[1] = perf_scale(raw_values);

			ratio = perf_scale_ratio(raw_values);

			k_cycles   = (double)(values[1] - cpus[i].prev_values[1])*100.0/ (double)itc_delta;
			u_cycles   = (double)(values[0] - cpus[i].prev_values[0])*100.0/ (double)itc_delta;
			i_cycles   = 100.0 - (k_cycles + u_cycles);

			cpus[i].prev_values[0] = values[0];
			cpus[i].prev_values[1] = values[1];
			/*
			 * adjust for rounding errors
			 */
			if (i_cycles < 0.0) i_cycles = 0.0;
			if (i_cycles > 100.0) i_cycles = 100.0;
			if (k_cycles > 100.0) k_cycles = 100.0;
			if (u_cycles > 100.0) u_cycles = 100.0;

			printw("CPU%-2ld %6.2f%% usr %6.2f%% sys %6.2f%% idle (scaling ratio %.2f%%)\n",
				i,
				u_cycles,
				k_cycles,
				i_cycles,
				ratio*100.0);
		}
		refresh();


	}
	for(i=0; i < ncpus; i++)
		for(j=0; j < num; j++)
			close(cpus[i].fd[j]);
	free(cpus);
}

void
populate_cpumask(char *cpu_list)
{
	char *p;
	unsigned long start_cpu, end_cpu = 0;
	unsigned long i, count = 0;

	options.online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
	if (options.online_cpus == -1) 
		errx(1, "cannot figure out the number of online processors");

	if (cpu_list == NULL)  {
		if (options.online_cpus >= RTOP_MAX_CPUS)
			errx(1, "rtop can only handle to %u CPUs", RTOP_MAX_CPUS);

		for(i=0; i < options.online_cpus; i++)
			RTOP_CPUMASK_SET(options.cpu_mask, i);

		options.selected_cpus = options.online_cpus;

		return;
	} 

	while(isdigit(*cpu_list)) { 
		p = NULL;
		start_cpu = strtoul(cpu_list, &p, 0); /* auto-detect base */

		if (start_cpu == ULONG_MAX || (*p != '\0' && *p != ',' && *p != '-'))
			goto invalid;

		if (p && *p == '-') {
			cpu_list = ++p;
			p = NULL;

			end_cpu = strtoul(cpu_list, &p, 0); /* auto-detect base */
			
			if (end_cpu == ULONG_MAX || (*p != '\0' && *p != ','))
				goto invalid;
			if (end_cpu < start_cpu)
				goto invalid_range; 
		} else {
			end_cpu = start_cpu;
		}

		if (start_cpu >= RTOP_MAX_CPUS || end_cpu >= RTOP_MAX_CPUS)
			goto too_big;

		for (; start_cpu <= end_cpu; start_cpu++) {

			if (start_cpu >= options.online_cpus)
				goto not_online; /* XXX: assume contiguous range of CPUs */

			if (RTOP_CPUMASK_ISSET(options.cpu_mask, start_cpu))
				continue;

			RTOP_CPUMASK_SET(options.cpu_mask, start_cpu);

			count++;
		}

		if (*p) ++p;

		cpu_list = p;
	}

	options.selected_cpus = count;

	return;
invalid:
	errx(1, "invalid cpu list argument: %s", cpu_list);
	/* no return */
not_online:
	errx(1, "cpu %lu is not online", start_cpu);
	/* no return */
invalid_range:
	errx(1, "cpu range %lu - %lu is invalid", start_cpu, end_cpu);
	/* no return */
too_big:
	errx(1, "rtop is limited to %u CPUs", RTOP_MAX_CPUS);
	/* no return */
}


static void
usage(void)
{
	printf(	"usage: rtop [options]:\n"
		"-h, --help\t\t\tdisplay this help and exit\n"
		"-v, --verbose\t\t\tverbose output\n"
		"-V, --version\t\t\tshow version and exit\n"
		"-d nsec, --delay=nsec\t\tnumber of seconds between refresh (default=1s)\n"
		"--cpu-list=cpu1,cpu2\t\tlist of CPUs to monitor(default=all)\n"
	);

}

int
main(int argc, char **argv)
{
	int c;
	char *cpu_list = NULL;

	//if (geteuid()) err(1, "perf_event requires root privileges to create system-wide measurments\n");

	while ((c=getopt_long(argc, argv,"+vhVd:", rtop_cmd_options, 0)) != -1) {
		switch(c) {
			case   0: continue; /* fast path for options */
			case 'v': options.opt_verbose = 1;
				  break;
			case 1:
			case 'h':
				usage();
				exit(0);
			case 2:
			case 'V':
				printf("rtop version " RTOP_VERSION " Date: " __DATE__ "\n"
					"Copyright (C) 2009 Google, Inc\n");
				exit(0);
			case 3:
			case 'd':
				options.opt_delay = atoi(optarg);
				if (options.opt_delay < 0)
					errx(1, "invalid delay, must be >= 0");
				options.opt_delay_set = 1;
				break;
			case 4:
				if (*optarg == '\0')
					errx(1, "--cpu-list needs an argument\n");
				cpu_list = optarg;
				break;
			default:
				errx(1, "unknown option\n");
		}
	}
	/*
	 * default refresh delay
	 */
	if (options.opt_delay_set == 0)
		options.opt_delay = 1;

	options.cpu_mhz = find_cpu_speed();

	populate_cpumask(cpu_list);

	setup_signals();
	setup_screen();
	mainloop();
	close_screen();

	return 0;
}