/* rtop.c - a simple PMU-based CPU utilization tool

 *

 * 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.

 */

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

#include <termios.h>

#include <signal.h>

#include <ctype.h>

#include <math.h>

#include <pthread.h>

#include <semaphore.h>

#include <limits.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <sys/poll.h>

#include <perfmon/pfmlib.h>

#include <perfmon/perfmon.h>

#include "detect_pmcs.h"

#define SWITCH_TIMEOUT	1000000000 /* in nanoseconds */

#define RTOP_VERSION "0.1"

#define RTOP_MAX_CPUS		1024	/* maximum number of CPU supported */

#define MAX_EVT_NAME_LEN	128

#define RTOP_NUM_PMCS 		4

#define RTOP_NUM_PMDS 		4

/* 

 * max number of cpus (threads) supported

 */

#define RTOP_MAX_CPUS		1024 /* 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;

	char		*outfile;

} 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

typedef struct {

	char *name;

	unsigned int plm;

} eventdesc_t;

typedef enum {

	THREAD_STARTED,

	THREAD_RUN,

	THREAD_DONE,

	THREAD_ERROR

} thread_state_t;

typedef struct {

	pthread_t	tid;		/* logical thread identification */

	long		cpuid;

	unsigned int	id;

	thread_state_t	state;

	int		is_last;

	sem_t		his_sem;

	sem_t		my_sem;

	FILE		*fp;

	uint64_t	nsamples;

	int		has_msg;

} thread_desc_t;

typedef struct _setdesc_t {

	pfarg_pmc_t		pc[RTOP_NUM_PMDS];

	pfarg_pmd_t		pd[RTOP_NUM_PMCS];

	pfmlib_input_param_t	inp;

	pfmlib_output_param_t	outp;

	uint16_t		set_id;

	uint32_t		set_flags;

	uint32_t		set_timeout; /* actual timeout */

	int			(*handler)(int fd, FILE *fp, thread_desc_t *td, struct _setdesc_t *my_sdesc);

	void 			*data;

	eventdesc_t		*evt_desc;

} setdesc_t;

typedef struct _barrier {

	pthread_mutex_t mutex;

	pthread_cond_t	cond;

	unsigned long	counter;

	unsigned long	max;

	unsigned long   generation; /* avoid race condition on wake-up */

} barrier_t;

typedef enum {

	SESSION_INIT,

	SESSION_RUN,

	SESSION_STOP,

	SESSION_ABORTED

} session_state_t;

typedef struct {

	uint64_t prev_k_cycles;

	uint64_t prev_u_cycles;

} set0_data_t;

static barrier_t 		barrier;

static session_state_t		session_state;

static program_options_t 	options;

static pfarg_ctx_t 		master_ctx;

static thread_desc_t		*thread_info;

static struct termios		saved_tty;

static int			time_to_quit;

static int			term_rows, term_cols;

static eventdesc_t	set0_evt[]={

	{ .name  = "*", .plm = PFM_PLM0 },

	{ .name  = "*", .plm = PFM_PLM3 },

	{ .name  = NULL}

 };

static int handler_set0(int fd, FILE *fp, thread_desc_t *td, setdesc_t *my_sdesc);

static setdesc_t setdesc_tab[]={

	{ .set_id    = 0,

	  .evt_desc  = set0_evt,

	  .handler   = handler_set0

	}

};

#define RTOP_NUM_SDESC (sizeof(setdesc_tab)/sizeof(setdesc_t))

static int

barrier_init(barrier_t *b, unsigned long count)

{

	int r;

	r = pthread_mutex_init(&b->mutex, NULL);

	if (r == -1) return -1;

	r = pthread_cond_init(&b->cond, NULL);

	if (r == -1) return -1;

	b->max = b->counter = count;

	b->generation = 0;

	return 0;

}

static void

cleanup_barrier(void *arg)

{

	int r;

	barrier_t *b = (barrier_t *)arg;

	r = pthread_mutex_unlock(&b->mutex);

	(void)r;

}

static int

barrier_wait(barrier_t *b)

{

	unsigned long generation;

	int oldstate;

	pthread_cleanup_push(cleanup_barrier, b);

	pthread_mutex_lock(&b->mutex);

	pthread_testcancel();

	if (--b->counter == 0) {

		/* reset barrier */

		b->counter = b->max;

		/*

		 * bump generation number, this avoids thread getting stuck in the

		 * wake up loop below in case a thread just out of the barrier goes

		 * back in right away before all the thread from the previous "round"

		 * have "escaped".

		 */

		b->generation++;

		pthread_cond_broadcast(&b->cond);

	} else {

		generation = b->generation;

		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);

		while (b->counter != b->max && generation == b->generation) {

			pthread_cond_wait(&b->cond, &b->mutex);

		}

		pthread_setcancelstate(oldstate, NULL);

	}

	pthread_mutex_unlock(&b->mutex);

	pthread_cleanup_pop(0);

	return 0;

}

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

static void

warning(char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	vfprintf(stderr, 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);

}

int

gettid(void)

{

	int tmp;

	tmp = syscall(__NR_gettid);

	return tmp;

}

#ifndef __NR_sched_setaffinity

#error "you need to define __NR_sched_setaffinity"

#endif

/*

 * Hack to get this to work without libc support

 */

int

pin_self_cpu(unsigned int cpu)

{

	unsigned long my_mask;

	my_mask = 1UL << cpu;

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

}

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

get_term_size(void)

{

	int ret;

        struct winsize ws;

	ret = ioctl(1, TIOCGWINSZ, &ws);

	if (ret == -1) 

		fatal_error("cannot determine screen size\n");

	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)

		fatal_error("you need at least %ld rows on your terminal to display all CPUs\n", 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)

		fatal_error("cannot save tty settings\n");

	get_term_size();

	initscr();

	nocbreak();

	resizeterm(term_rows, term_cols);

}

static void

close_screen(void)

{

	int ret;

	endwin();

	ret = tcsetattr(0, TCSAFLUSH, &saved_tty);

	if (ret == -1)

		warning("cannot restore tty settings\n");

}

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 = (__sighandler_t)sigint_handler;

	sigaction (SIGINT, &act, 0);

	/*

	 * install SIGWINCH handler

	 */

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

	sigemptyset(&my_set);

	act.sa_handler = (__sighandler_t)sigwinch_handler;

	sigaction (SIGWINCH, &act, 0);

}

static void

setup_worker_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.

	 */

	/*

	 * block SIGINT, forcing it to master thread only

	 */

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

	sigemptyset(&my_set);

        sigaddset(&my_set, SIGINT);

        sigaddset(&my_set, SIGWINCH);

	pthread_sigmask(SIG_BLOCK, &my_set, NULL);

}

static struct option rtop_cmd_options[]={

	{ "help", 0, 0, 1 },

	{ "version", 0, 0, 2 },

	{ "delay", 0, 0, 3 },

	{ "cpu-list", 1, 0, 4 },

	{ "outfile", 1, 0, 5 },

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

	{ 0, 0, 0, 0}

};

int

handler_set0(int fd, FILE *fp, thread_desc_t *td, setdesc_t *my_sdesc)

{

	double k_cycles, u_cycles, i_cycles;

	set0_data_t *sd1;

	uint64_t itc_delta;

	long mycpu;

	mycpu = td->cpuid;

	if (my_sdesc->data == NULL) {

		my_sdesc->data = sd1 = calloc(1, sizeof(set0_data_t));

		if (sd1 == NULL)

			return -1;

	}

	sd1 = my_sdesc->data;

	/*

	 * now read the results

	 */

	if (pfm_read_pmds(fd, my_sdesc->pd, my_sdesc->inp.pfp_event_count) == -1) {

		warning( "CPU%ld pfm_read_pmds error errno %d\n", mycpu, errno);

		return -1;

	}

	/*

	 * expected maximum duration with monitoring active for this set

	 * set_timeout is in nanoseconds, we need to divide mhz by 1000

	 * to get cycles.

	 */

	itc_delta =  (my_sdesc->set_timeout*(uint64_t)options.cpu_mhz)/1000;

	k_cycles   = (double)(my_sdesc->pd[0].reg_value - sd1->prev_k_cycles)*100.0/ (double)itc_delta;

	u_cycles   = (double)(my_sdesc->pd[1].reg_value - sd1->prev_u_cycles)*100.0/ (double)itc_delta;

	i_cycles   = 100.0 - (k_cycles + u_cycles);

	/*

	 * 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\n",

		mycpu,

		u_cycles,

		k_cycles,

		i_cycles);

	sd1->prev_k_cycles      = my_sdesc->pd[0].reg_value;

	sd1->prev_u_cycles      = my_sdesc->pd[1].reg_value;

	if (fp)

		fprintf(fp, "%"PRIu64" %6.2f %6.2f %6.2f\n",

			td->nsamples,

			u_cycles,

			k_cycles,

			i_cycles);

	td->nsamples++;

	return 0;

}

static void

do_measure_one_cpu(void *data)

{

	thread_desc_t	*arg= (thread_desc_t *)data;

	pfarg_ctx_t	ctx;

	pfarg_load_t	load_args;

	pfarg_setdesc_t	setd;

	setdesc_t 	*my_sdesc, *my_sdesc_tab = NULL;

	long		mycpu;

	sem_t		*his_sem;

	unsigned int	id;

	int		fd, ret, j;

	int		old_rows;

	char		cpu_str[16];

	char		*fn;

	FILE		*fp = NULL;

	setup_worker_signals();

	mycpu    = arg->cpuid;

	id       = arg->id;

	his_sem    = &arg->his_sem;

	old_rows = term_rows;

	if (options.outfile) {

		sprintf(cpu_str,".cpu%ld", mycpu);

		fn = malloc(strlen(options.outfile)+1+strlen(cpu_str));

		if (fn == NULL) goto error;

		strcpy(fn, options.outfile);

		strcat(fn, cpu_str);

		fp = fopen(fn, "w");

		if (fp == NULL) {

			warning("cannot open %s\n", fn);

			free(fn);

			goto error;

		}

		free(fn);

		fprintf(fp, "# Results for CPU%ld\n"

				"# sample delay %d seconds\n"

				"# Column1 : sample number\n"

				"# Column2 : %% user time\n"

				"# Column3 : %% system time\n"

				"# Column4 : %% idle\n"

				"# Column5 : kernel entry-exit\n",

				mycpu,

				options.opt_delay);

	}

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

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

	ret = pin_self_cpu(mycpu);

	if (ret) {

		warning("CPU%ld cannot pin\n");

	}

	ctx = master_ctx;

	my_sdesc_tab = malloc(sizeof(setdesc_t)*RTOP_NUM_SDESC);

	if (my_sdesc_tab == NULL) {

		warning("CPU%ld cannot allocate sdesc\n", mycpu);

		goto error;

	}

	memcpy(my_sdesc_tab, setdesc_tab, sizeof(setdesc_t)*RTOP_NUM_SDESC);

	fd = pfm_create_context(&ctx, NULL, NULL, 0);

	if (fd == -1) {

		if (errno == ENOSYS) {

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

		}

		warning("CPU%ld cannot create context: %d\n", mycpu, errno);

		goto error;

	}

	/*

	 * WARNING: on processors where the idle loop goes into some power-saving

	 * state, the results of this program may be incorrect

	 */

	for(j=0; j < RTOP_NUM_SDESC; j++) {

		my_sdesc       = my_sdesc_tab+j; 

		setd.set_id    = my_sdesc->set_id;

		setd.set_flags = my_sdesc->set_flags;

		setd.set_timeout =  SWITCH_TIMEOUT; /* in nsecs */

		/*

 		 * do not bother if we have only one set

 		 */

		if (RTOP_NUM_SDESC > 1 && pfm_create_evtsets(fd, &setd, 1) == -1) {

			warning("CPU%ld cannot create set%u: %d\n", mycpu, j, errno);

			goto error;

		}

		my_sdesc->set_timeout = setd.set_timeout;

		if (pfm_write_pmcs(fd, my_sdesc->pc, my_sdesc->outp.pfp_pmc_count) == -1) {

			warning("CPU%ld pfm_write_pmcs error errno %d\n", mycpu, errno);

			goto error;

		}

		/*

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

	 	 * as being part of a sample (reg_smpl_pmds)

	 	 */

		if (pfm_write_pmds(fd, my_sdesc->pd, my_sdesc->inp.pfp_event_count) == -1) {

			warning("CPU%ld pfm_write_pmds error errno %d\n", mycpu, errno);

			goto error;

		}

	}

	/*

	 * in system-wide mode, this field must provide the CPU the caller wants

	 * to monitor. The kernel checks and if calling from the wrong CPU, the

	 * call fails. The affinity is not affected.

	 */

	load_args.load_pid = mycpu;

	if (pfm_load_context(fd, &load_args) == -1) {

		warning("CPU%ld pfm_load_context error errno %d\n", mycpu, errno);

		goto error;

	}

	thread_info[id].state = THREAD_RUN;

	barrier_wait(&barrier);

	/*

	 * must wait until we are sure the master is out of its thread_create loop

	 */

	barrier_wait(&barrier);

	for(;session_state == SESSION_RUN;) {

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

			warning("CPU%ld pfm_start error errno %d\n", mycpu, errno);

			goto error;

		}

		/*

		 * wait for order from master

		 */

		sem_wait(his_sem);

		if (pfm_stop(fd) == -1) {

			warning("CPU%ld pfm_stop error %d\n", mycpu, errno);

			goto error;

		}

		if (old_rows != term_rows) {

			resizeterm(term_rows, term_cols);

			old_rows = term_rows;

		}

		for(j=0; j < RTOP_NUM_SDESC; j++) {

			move(id*RTOP_NUM_SDESC+j, 0);

			if (my_sdesc_tab[j].handler)

				(*my_sdesc_tab[j].handler)(fd, fp, arg, my_sdesc_tab+j);

		}

		if (session_state == SESSION_RUN) {

			sem_post(&arg->my_sem);

			barrier_wait(&barrier);

		}

	}

	if (fp) fclose(fp);

	close(fd);

	thread_info[id].state = THREAD_DONE;

	pthread_exit((void *)(0));

error:

	thread_info[id].state = THREAD_ERROR;

	barrier_wait(&barrier);

	if (fp) fclose(fp);

	if (my_sdesc_tab) free(my_sdesc_tab);

	pthread_exit((void *)(~0));

}

static void

mainloop(void)

{

	long i, j, ncpus = 0;

	int ret;

	void *retval;

	struct pollfd	fds;

	ncpus = options.selected_cpus;

	barrier_init(&barrier, ncpus+1);

	thread_info = malloc(sizeof(thread_desc_t)*ncpus);

	if (thread_info == NULL) {

		fatal_error("cannot allocate thread_desc for %ld CPUs\n", ncpus);

	}

	for(i=0, j = 0; ncpus; i++) {

		if (RTOP_CPUMASK_ISSET(options.cpu_mask, i) == 0) continue;

		thread_info[j].id    = j;

		thread_info[j].cpuid = i;

		sem_init(&thread_info[j].his_sem, 0, 0);

		sem_init(&thread_info[j].my_sem, 0, 0);

		ret = pthread_create(&thread_info[j].tid, 

				     NULL, 

				     (void *(*)(void *))do_measure_one_cpu, 

				     (void *)(thread_info+j));

		if (ret != 0) goto abort;

		ncpus--;

		j++;

	}

	/* set last marker */

	thread_info[j-1].is_last = 1;

	ncpus = j;

	barrier_wait(&barrier);

	/*

	 * check if some threads got problems

	 */

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

		if (thread_info[i].state == THREAD_ERROR) {

			printw("aborting\n"); refresh();

			goto abort;

		}

	}

	session_state = SESSION_RUN;

	barrier_wait(&barrier);

	fds.fd      = 0;

	fds.events  = POLLIN;

	fds.revents = 0;

	for(;time_to_quit == 0;) {

		ret = poll(&fds, 1, options.opt_delay*1000);

		switch(ret) {

			case 0:

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

					/* give order to print */

					sem_post(&thread_info[i].his_sem);

					/* wait for thread to be done */

					sem_wait(&thread_info[i].my_sem);

				}

				/* give order to start measuring again */

				refresh();

				barrier_wait(&barrier);

				break;

			case -1:

				/* restart in case of signal */

				if (errno == EINTR)

					continue;

				warning("polling error: %s\n", strerror(errno));

				 /* fall through */

			default: time_to_quit = 1;

		}

	}

	session_state = SESSION_STOP;

	/*

	 * get worker thread out of their mainloop

	 */

	for (i=0; i < ncpus; i++)

		sem_post(&thread_info[i].his_sem);

join_all:

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

		ret = pthread_join(thread_info[i].tid, &retval);

		if (ret !=0) fatal_error("cannot join thread %ld\n", i);

	}

	free(thread_info);

	return;

abort:

	session_state = SESSION_ABORTED;

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

		pthread_cancel(thread_info[i].tid);

	}

	goto join_all;

}

static void

setup_measurement(void)

{

	pfmlib_options_t pfmlib_options;

	eventdesc_t *evt;

	setdesc_t *sdesc;

	pfmlib_event_t trigger_event;

	unsigned int i, j;

	int ret;

	/*

	 * pass options to library (optional)

	 */

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

	pfmlib_options.pfm_debug = 0;

	pfmlib_options.pfm_verbose = 0;

	pfm_set_options(&pfmlib_options);

	/*

	 * Initialize pfm library (required before we can use it)

	 */

	ret = pfm_initialize();

	if (ret != PFMLIB_SUCCESS)

		fatal_error("Cannot initialize library: %s\n", pfm_strerror(ret));

	/*

	 * In system wide mode, the perfmon context cannot be inherited.

	 * Also in this mode, we cannot use the blocking form of user level notification.

	 */

	master_ctx.ctx_flags = PFM_FL_SYSTEM_WIDE;

	if (pfm_get_cycle_event(&trigger_event) != PFMLIB_SUCCESS)

		fatal_error("cannot find cycle event for trigger\n");

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

		sdesc = setdesc_tab+i;

		sdesc->inp.pfp_dfl_plm   = PFM_PLM3|PFM_PLM0;