/*

 * multiplex2.c - example of kernel-level time-based or overflow-based event multiplexing

 *

 * Copyright (c) 2004-2006 Hewlett-Packard Development Company, L.P.

 * Contributed by Stephane Eranian <eranian@hpl.hp.com>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of the

 * License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

 * 02111-1307 USA

 */

#ifndef _GNU_SOURCE

  #define _GNU_SOURCE /* for getline */

#endif

#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 <syscall.h>

#include <getopt.h>

#include <signal.h>

#include <math.h>

#include <limits.h>

#include <fcntl.h>

#include <setjmp.h>

#include <sys/ioctl.h>

#include <sys/wait.h>

#include <sys/poll.h>

#include <sys/ptrace.h>

#include <perfmon/pfmlib.h>

#include <perfmon/perfmon.h>

#include "detect_pmcs.h"

#define MIN_FULL_PERIODS	2

#define MAX_EVT_NAME_LEN	128

#define MULTIPLEX_VERSION	"0.2"

#define SMPL_FREQ_IN_HZ	300

#define NUM_PMCS PMU_MAX_PMCS

#define NUM_PMDS PMU_MAX_PMDS

#define MAX_NUM_COUNTERS	NUM_PMDS

#define MAX_PMU_NAME_LEN	32

typedef struct {

	struct {

		int opt_plm;	/* which privilege level to monitor (more than one possible) */

		int opt_debug;	/* print debug information */

		int opt_verbose;	/* verbose output */

		int opt_us_format;	/* print large numbers with comma for thousands */

		int opt_ovfl_switch;	/* overflow-based switching */

		int opt_is_system;	/* use system-wide */

		int opt_intr_only;	/* interrupts only*/

		int opt_no_cmd_out;	/* redirect cmd output to /dev/null */

		int opt_no_header;	/* no header */

	} program_opt_flags;

	unsigned long	max_counters;	/* maximum number of counter for the platform */

	unsigned long	session_timeout;

	uint64_t	smpl_period;

	uint32_t	smpl_freq;

	unsigned long	cpu_mhz;

	pid_t		attach_pid;

	int		pin_cmd_cpu;

	int		pin_cpu;

	struct timespec switch_timeout;

} program_options_t;

#define opt_plm			program_opt_flags.opt_plm

#define opt_debug		program_opt_flags.opt_debug

#define opt_verbose		program_opt_flags.opt_verbose

#define opt_us_format		program_opt_flags.opt_us_format

#define opt_ovfl_switch		program_opt_flags.opt_ovfl_switch

#define opt_is_system		program_opt_flags.opt_is_system

#define opt_intr_only		program_opt_flags.opt_intr_only

#define opt_no_cmd_out		program_opt_flags.opt_no_cmd_out

#define opt_no_header		program_opt_flags.opt_no_header

typedef struct _event_set_t {

	struct _event_set_t	*next;

	unsigned short		id;

	unsigned int		n_events;

	unsigned int		pmcs_base;

	unsigned int		pmds_base;

	int			npmcs;

	int			npmds;

	unsigned long		set_runs;

	char			*event_str;

} event_set_t;

static program_options_t options;

static pfarg_pmc_t	*all_pmcs;

static pfarg_pmd_t	*all_pmds;

static uint64_t		*all_values;

static event_set_t	*current_set, *all_sets;

static unsigned int 	num_pmds, num_pmcs, num_sets, total_events;

static unsigned long	full_periods;

static volatile int	time_to_quit;

static jmp_buf jbuf;

static void fatal_error(char *fmt,...) __attribute__((noreturn));

static void

vbprintf(char *fmt, ...)

{

	va_list ap;

	if (options.opt_verbose == 0) return;

	va_start(ap, fmt);

	vprintf(fmt, ap);

	va_end(ap);

}

static void

fatal_error(char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	vfprintf(stderr, fmt, ap);

	va_end(ap);

	exit(1);

}

/*

 * unreliable for CPU with variable clock speed

 */

static unsigned long

get_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 (!strncmp("cpu MHz", buffer, 7)) {

			float fl;

			sscanf(value, "%f", &fl);

			f1 = lroundf(fl);

			break;

		}

		if (!strncmp("BogoMIPS", buffer, 8)) {

			float fl;

			sscanf(value, "%f", &fl);

			f2 = lroundf(fl);

		}

	}

	fclose(fp1);

	return f1 == 0 ? f2 : f1;

}

/*

 * pin task to CPU

 */

#ifndef __NR_sched_setaffinity

#error "you need to define __NR_sched_setaffinity"

#endif

#define MAX_CPUS	2048

#define NR_CPU_BITS	(MAX_CPUS>>3)

int

pin_cpu(pid_t pid, unsigned int cpu)

{

	uint64_t my_mask[NR_CPU_BITS];

	if (cpu >= MAX_CPUS)

		fatal_error("this program supports only up to %d CPUs\n", MAX_CPUS);

	my_mask[cpu>>6] = 1ULL << (cpu&63);

	return syscall(__NR_sched_setaffinity, pid, sizeof(my_mask), &my_mask);

}

int

child(char **arg)

{

	ptrace(PTRACE_TRACEME, 0, NULL, NULL);

	if (options.pin_cmd_cpu != -1) {

		pin_cpu(getpid(), options.pin_cmd_cpu);

		vbprintf("command running on CPU core %d\n", options.pin_cmd_cpu);

	}

	if (options.opt_no_cmd_out) {

		close(1);

		close(2);

	}

	execvp(arg[0], arg);

	/* not reached */

	exit(1);

}

static void

dec2sep(char *str2, char *str, char sep)

{

	int i, l, b, j, c=0;

	l = strlen(str2);

	if (l <= 3) {

		strcpy(str, str2);

		return;

	}

	b = l +  l /3 - (l%3 == 0); /* l%3=correction to avoid extraneous comma at the end */

	for(i=l, j=0; i >= 0; i--, j++) {

		if (j) c++;

		str[b-j] = str2[i];

		if (c == 3 && i>0) {

			str[b-++j] = sep;

			c = 0;

		}

	}

}

static void

print_results(void)

{

	unsigned int i, j, cnt;

	int ovfl_adj;

	uint64_t value, set_runs;

	event_set_t *e;

	char *p;

	char tmp1[32], tmp2[32], *str;

	char mtotal_str[32], *mtotal;

	char stotal_str[32], *stotal;

	if (full_periods < num_sets)

		fatal_error("not all sets have been activated, need to run longer %lu\n", full_periods);

	/*

	 * print the results

	 *

	 * It is important to realize, that the first event we specified may not

	 * be in PMD4. Not all events can be measured by any monitor. That's why

	 * we need to use the pc[] array to figure out where event i was allocated.

	 *

	 */

	if (options.opt_no_header == 0) {

		printf("# %u Hz period = %u usecs\n# %"PRIu64" cycles @ %lu MHz\n", 

			options.smpl_freq, 

			1000000 / options.smpl_freq, 

			options.smpl_period,

			options.cpu_mhz);

		if (options.opt_ovfl_switch == 0)

			printf("# using time-based multiplexing\n"

				"# %uus effective switch timeout\n", 

				1000000 / options.smpl_freq);

		else

			printf("# using overflow-based multiplexing\n");

		if (options.opt_is_system)

			printf("# system-wide mode on CPU core %d\n",options.pin_cpu);

		printf("# %d sets\n", num_sets);

		printf("# %.2f average run per set\n", (double)full_periods/num_sets);

		printf("# set       measured total     #runs         scaled total event name\n");

		printf("# ------------------------------------------------------------------\n");

	}

	ovfl_adj= options.opt_ovfl_switch ? 1 : 0;

	for (i=0, e = all_sets, cnt = 0; i < num_sets; i++, e = e->next) {

		set_runs = e->set_runs;

		str = e->event_str;

		for(j=0; j < e->npmds-ovfl_adj; j++, cnt++) {

			value = all_values[j+e->pmds_base];

			sprintf(tmp1, "%"PRIu64, value);

			if (options.opt_us_format) {

				dec2sep(tmp1, mtotal_str, ',');

			} else {

				strcpy(mtotal_str, tmp1);

			}

			mtotal = mtotal_str;

			/* 

			 * scaling

			 */

			sprintf(tmp2, "%"PRIu64, ((value*full_periods)/set_runs));  

			if (options.opt_us_format) {

				dec2sep(tmp2, stotal_str, ',');

			} else {

				strcpy(stotal_str, tmp2);

			}

			stotal  = stotal_str;

			printf("  %03d %20s  %8"PRIu64" %20s %s\n",

				i,

				mtotal,

				set_runs,

				stotal,

				str);

			p = strchr(str, '\0');

			if (p)

				str = p+1;

		}

		/*

		 * skip first event

		 */

		if (options.opt_ovfl_switch) cnt++;

	}

}

static void

update_set(int ctxid)

{

	int count;

	int base;

	int ret;

	int i;

	base = current_set->pmds_base;

	/*

	 * we do not read the last counter (cpu_cycles) to avoid overwriting

	 * the reg_value field which will be used for next round

	 *

	 * We need to retry the read in case we get EBUSY because it means that

	 * the child task context is not yet available from inspection by PFM_READ_PMDS2.

	 *

	 */

	count = current_set->npmds;

	if (options.opt_ovfl_switch)

		count--;

	ret = pfm_read_pmds(ctxid, all_pmds + base, count);

	if (ret == -1)

		fatal_error("error reading set: %s\n", strerror(errno));

	/* update counts for this set */

	for (i=0; i < count; i++) {

		all_values[base+i] += all_pmds[base+i].reg_value;

		/* reset for next round */

		all_pmds[base+i].reg_value = 0UL;

	}

}

static void

switch_sets(int ctxid)

{

	update_set(ctxid);

	current_set = current_set->next;

	if (current_set == NULL)

		current_set = all_sets;

	current_set->set_runs++;

	vbprintf("starting set %d run %lu\n",

		current_set->id,

		current_set->set_runs);

	/*

	 * we must reprogram all avaibale PMCs (or PMDS) to ensure that no

	 * state is left over from the previous set and which could conflict

	 * on restart

	 */

	if (pfm_write_pmcs(ctxid, all_pmcs+current_set->pmcs_base, current_set->npmcs) == -1) {

		fatal_error("error writing pmcs: %s\n", strerror(errno));

	}

	if (pfm_write_pmds(ctxid, all_pmds+current_set->pmds_base, current_set->npmds) == -1) {

		fatal_error("error writing pmds: %s\n", strerror(errno));

	}

	full_periods++;

	if (options.opt_ovfl_switch && pfm_restart(ctxid) == -1) {

		if (errno != EBUSY)

			fatal_error("error pfm_restart: %s\n", strerror(errno));

		/*

		 * in case of EBUSY, it probably means the task has exited now

		 */

	}

}

static void

sigintr_handler(int sig)

{

	if (sig == SIGALRM) 

		time_to_quit = 1;

	else

		time_to_quit = 2;

	longjmp(jbuf, 1);

}

static void

sigchld_handler(int sig)

{

	time_to_quit = 1;

}

static int

measure_one_task(char **argv)

{

	int ctxid;

	pfarg_ctx_t ctx[1];

	pfarg_load_t load_arg;

	struct pollfd pollfd;

	pid_t pid;

	int status, ret;

	memset(ctx, 0, sizeof(ctx));

	memset(&load_arg, 0, sizeof(load_arg));

	/*

	 * create the context

	 */

	ctxid = pfm_create_context(ctx, NULL, NULL, 0);

	if (ctxid == -1 ) {

		if (errno == ENOSYS) {

			fatal_error("Your kernel does not have performance monitoring support!\n");

		}

		fatal_error("Can't create PFM context %s\n", strerror(errno));

	}

	/*

	 * set close-on-exec to ensure we will be getting the PFM_END_MSG, i.e.,

	 * fd not visible to child.

	 */

	if (fcntl(ctxid, F_SETFD, FD_CLOEXEC))

		fatal_error("cannot set CLOEXEC: %s\n", strerror(errno));

	/*

	 * write registers for first set

	 */

	if (pfm_write_pmcs(ctxid, all_pmcs+current_set->pmcs_base, current_set->npmcs) == -1) {

		fatal_error("error pfm_write_pmcs: %s\n", strerror(errno));

	}

	if (pfm_write_pmds(ctxid, all_pmds+current_set->pmds_base, current_set->npmds) == -1) {

		fatal_error("error pfm_write_pmds: %s\n", strerror(errno));

	}

	/*

	 * now launch the child code

	 */

	if (options.attach_pid == 0) {

		if ((pid= fork()) == -1) fatal_error("Cannot fork process\n");

		if (pid == 0) exit(child(argv));

	} else {

		pid = options.attach_pid;

		ret = ptrace(PTRACE_ATTACH, pid, NULL, 0);

		if (ret) {

			fatal_error("cannot attach to task %d: %s\n",options.attach_pid, strerror(errno));

		}

	}

	ret = waitpid(pid, &status, WUNTRACED);

	if (ret < 0 || WIFEXITED(status))

		fatal_error("error command already terminated, exit code %d\n", WEXITSTATUS(status));

	vbprintf("child created and stopped\n");

	/*

	 * now attach the context

	 */

	load_arg.load_pid = pid;

	if (pfm_load_context(ctxid, &load_arg) == -1) {

		fatal_error("pfm_load_context error errno %d\n",errno);

	}

	current_set->set_runs = 1;

	/*

	 * start monitoring

	 */

	if (pfm_start(ctxid, NULL) == -1) {

		fatal_error("pfm_start error errno %d\n",errno);

	}

	ptrace(PTRACE_DETACH, pid, NULL, 0);

	if (setjmp(jbuf) == 1) {

		if (time_to_quit == 1) {

			printf("timeout expired\n");

		}

		if (time_to_quit == 2)

			printf("session interrupted\n");

		goto finish_line;

	}

	if (options.session_timeout) {

		printf("<monitoring for %lu seconds>\n", options.session_timeout);

		alarm(options.session_timeout);

	}

	pollfd.fd = ctxid;

	pollfd.events = POLLIN;

	pollfd.revents = 0;

	while(time_to_quit == 0) {

		/*

		 * mainloop. poll timeout is in msecs

		 */

		ret = poll(&pollfd, 1, 1000 / options.smpl_freq);

		switch(ret) {

			case  0:

				ret = ptrace(PTRACE_ATTACH, pid, NULL, 0);

				if (ret) {

					time_to_quit = 1;

					break;

				}

				ret = waitpid(pid, &status, WUNTRACED);

				/*

				 * exit with time_to_quit = 0

				 * to avoid unloading from dead thread

				 */

				if (WIFEXITED(status))

					goto finish_line;

				switch_sets(ctxid);

				ptrace(PTRACE_DETACH, pid, NULL, 0);

				break;

			case -1: fatal_error("poll error: %s\n", strerror(errno));

			default: /* we don't even read END_MSG */

				 time_to_quit = 1;

		}

	}

finish_line:

	/*

	 * cleanup after an alarm timeout

	 */

	if (time_to_quit) {

		/* stop monitored task */

		ptrace(PTRACE_ATTACH, pid, NULL, 0);

		waitpid(pid, NULL, WUNTRACED);

		/* detach context */

		pfm_unload_context(ctxid);

	}

	if (options.attach_pid == 0) {

		kill(pid, SIGKILL);

		waitpid(pid, &status, 0);

	} else {

		ptrace(PTRACE_DETACH, pid, NULL, 0);

	}

	if (time_to_quit < 2) print_results();

	close(ctxid);

	return 0;

}

static int

measure_one_cpu(char **argv)

{

	int ctxid, status;

	pfarg_ctx_t ctx[1];

	pfarg_load_t load_arg;

	struct pollfd pollfd;

	pid_t pid = 0;

	int ret, timeout;

	memset(ctx, 0, sizeof(ctx));

	memset(&load_arg, 0, sizeof(load_arg));

	if (options.pin_cpu == -1) {

		options.pin_cpu = 0;

		printf("forcing monitoring onto CPU core 0\n");

		pin_cpu(getpid(), 0);

	}

	ctx[0].ctx_flags = PFM_FL_SYSTEM_WIDE;

	/*

	 * create the context

	 */

	ctxid = pfm_create_context(ctx, NULL, NULL, 0);

	if (ctxid == -1) {

		if (errno == ENOSYS) {

			fatal_error("Your kernel does not have performance monitoring support!\n");

		}

		fatal_error("Can't create PFM context %s\n", strerror(errno));

	}

	/*

	 * set close-on-exec to ensure we will be getting the PFM_END_MSG, i.e.,

	 * fd not visible to child.

	 */

	if (fcntl(ctxid, F_SETFD, FD_CLOEXEC))

		fatal_error("cannot set CLOEXEC: %s\n", strerror(errno));

	/*

	 * Now program the all the registers in one call

	 *

	 * Note that there is a limitation on the size of the argument vector

	 * that can be passed. It is usually set to a page size (16KB).

	 */

	if (pfm_write_pmcs(ctxid, all_pmcs+current_set->pmcs_base, current_set->npmcs) == -1)

		fatal_error("error: pfm_write_pmcs errno: %s\n", strerror(errno));

	/*

	 * initialize the PMD registers.

	 *

	 * To be read, each PMD must be either written or declared

	 * as being part of a sample (reg_smpl_pmds)

	 */

	if (pfm_write_pmds(ctxid, all_pmds+current_set->pmds_base, current_set->npmds) == -1)

		fatal_error("pfm_write_pmds error errno %d\n", strerror(errno));

	/*

	 * now launch the child code

	 */

	if (*argv) {

		if ((pid = fork()) == -1) fatal_error("Cannot fork process\n");

		if (pid == 0) exit(child(argv));

	} 

	/*

	 * wait for the child to exec or be stopped

	 * We do this even in system-wide mode to ensure

	 * that the task does not start until we are ready

	 * to monitor.

	 */

	if (pid) {

		ret = waitpid(pid, &status, WUNTRACED);

		if (ret < 0 || WIFEXITED(status))

			fatal_error("error command already terminated, exit code %d\n", WEXITSTATUS(status));

		vbprintf("child created and stopped\n");

	}

	/*

	 * now attach the context

	 */

	load_arg.load_pid = options.pin_cpu;

	if (pfm_load_context(ctxid, &load_arg) == -1)

		fatal_error("pfm_load_context error errno %d\n",errno);

	/*

	 * start monitoring

	 */

	if (pfm_start(ctxid, NULL) == -1)

		fatal_error("pfm_start error errno %d\n",errno);

	if (pid) {

		signal(SIGCHLD, sigchld_handler);

		ptrace(PTRACE_DETACH, pid, NULL, 0);

	}

	/*

	 * mainloop

	 */

	pollfd.fd = ctxid;

	pollfd.events = POLLIN;

	pollfd.revents = 0;

	timeout = options.opt_ovfl_switch ?  -1 : (1000 / options.smpl_freq);

	while (time_to_quit == 0) {

		ret = poll(&pollfd, 1, timeout);

		switch(ret) {

			case 1:

			case 0:

				/*

 				 *we are consuming the message.

				 * to avoid this phase we could use PFM_FL_OVFL_NO_MSG

				 * and use signal based notification

				 */

				if (options.opt_ovfl_switch) {

					ssize_t r;

					pfarg_msg_t msg;

					r = read(ctxid, &msg, sizeof(msg));

					(void) r;

				}

				switch_sets(ctxid);

				break;

			default: 

				if (errno != EINTR)

					fatal_error("poll fails\n");

		}

	}

	if (full_periods < MIN_FULL_PERIODS)

		fatal_error("Not enough periods (%lu) to print results\n", full_periods);

	if (pid)

		waitpid(pid, &status, 0);

	print_results();

	close(ctxid);

	return 0;

}

int

mainloop(char **argv)

{

	event_set_t *e;

	pfmlib_input_param_t inp;

	pfmlib_output_param_t outp;

	pfmlib_regmask_t impl_counters, used_pmcs;

	pfmlib_event_t cycle_event;

	unsigned int i, j;

	char *p, *str;

	unsigned int max_counters, allowed_counters;

	int ret;

	pfm_get_num_counters(&max_counters);

	if (max_counters < 2 && options.opt_ovfl_switch) 

		fatal_error("not enough counter to get overflow switching to work\n");

	allowed_counters = max_counters;

	/*

	 * account for overflow counter (cpu cycles)

	 */

	if (options.opt_ovfl_switch) allowed_counters--;

	memset(&used_pmcs, 0, sizeof(used_pmcs));

	memset(&impl_counters, 0, sizeof(impl_counters));

	pfm_get_impl_counters(&impl_counters);

	options.smpl_period = (options.cpu_mhz*1000000)/options.smpl_freq;

	vbprintf("%lu Hz period = %"PRIu64" cycles @ %lu Mhz\n", options.smpl_freq, options.smpl_period, options.cpu_mhz);

	for (e = all_sets; e; e = e->next) {

		for (p = str = e->event_str; p ; ) {

			p = strchr(str, ',');

			if (p) str = p +1;

			total_events++;

		}

	}

	/*

	 * account for extra event per set (cycle event)

	 */

	if (options.opt_ovfl_switch) {

		total_events += num_sets;

		/*

		 * look for our trigger event

		 */

		if (pfm_get_cycle_event(&cycle_event) != PFMLIB_SUCCESS) {

			fatal_error("Cannot find cycle event\n");

		}

	}

	vbprintf("total_events=%u\n", total_events);

	all_pmcs   = calloc(1, sizeof(pfarg_pmc_t)*total_events);

	all_pmds   = calloc(1, sizeof(pfarg_pmd_t)*total_events);

	all_values = calloc(1, sizeof(uint64_t)*total_events);

	if (all_pmcs == NULL || all_pmds == NULL || all_values == NULL)

		fatal_error("cannot allocate event tables\n");

	/*

	 * use the library to figure out assignments for all events of all sets

	 */

	for (i=0, e = all_sets; i < num_sets; i++, e = e->next) {

		memset(&inp,0, sizeof(inp));

		memset(&outp,0, sizeof(outp));

		/*

	 	 * build the pfp_unavail_pmcs bitmask by looking

	 	 * at what perfmon has available. It is not always

	 	 * the case that all PMU registers are actually available

	 	 * to applications. For instance, on IA-32 platforms, some

	 	 * registers may be reserved for the NMI watchdog timer.

	 	 *

	 	 * With this bitmap, the library knows which registers NOT to

	 	 * use. Of source, it is possible that no valid assignement may

	 	 * be possible if certina PMU registers  are not available.

	 	 */

		detect_unavail_pmcs(-1, &inp.pfp_unavail_pmcs);

		str = e->event_str;

		for(j=0, p = str; p && j < allowed_counters; j++) {

			p = strchr(str, ',');

			if (p) *p = '\0';

			if (pfm_find_full_event(str, &inp.pfp_events[j]) != PFMLIB_SUCCESS) {

				fatal_error("Cannot find %s event for set %d event %d\n", str, i, j);

			}

			if (p) {

				*p = ',';

				str = p + 1;

			}

		}

		if (p) {

			fatal_error("error in set %d: cannot have more than %d event(s) per set %s\n",

				    i,

				    allowed_counters,

				    options.opt_ovfl_switch ? "(overflow switch mode)": "(hardware limit)");

		}

		/*

		 * add the cycle event as the last event when we switch on overflow

		 */

		if (options.opt_ovfl_switch) {

			inp.pfp_events[j]   = cycle_event;

			inp.pfp_event_count = j+1;

			e->n_events	    = j+1;

		} else {

			e->n_events         = j;

			inp.pfp_event_count = j;

		}

		inp.pfp_dfl_plm = options.opt_plm;

		if (options.opt_is_system) 

			inp.pfp_flags = PFMLIB_PFP_SYSTEMWIDE;

		vbprintf("PMU programming for set %d\n", i);

		/*

		 * let the library do the hard work

		 */

		if ((ret=pfm_dispatch_events(&inp, NULL, &outp, NULL)) != PFMLIB_SUCCESS) {