/*

 * self_count.c - example of a simple self monitoring using mmapped page

 *

 * Copyright (c) 2009 Google, Inc

 * Contributed by Stephane Eranian <eranian@gmail.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.

 *

 * This file is part of libpfm, a performance monitoring support library for

 * applications on Linux.

 */

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

#include <sys/mman.h>

#include <sys/ioctl.h>

#include <err.h>

#include "perf_util.h"

static const char *gen_events[]={

	"cycles",

	NULL

};

static volatile int quit;

void sig_handler(int n)

{

	quit = 1;

}

#if defined(__x86_64__) || defined(__i386__)

#ifdef __x86_64__

#define DECLARE_ARGS(val, low, high)	unsigned low, high

#define EAX_EDX_VAL(val, low, high)	((low) | ((uint64_t )(high) << 32))

#define EAX_EDX_ARGS(val, low, high)	"a" (low), "d" (high)

#define EAX_EDX_RET(val, low, high)	"=a" (low), "=d" (high)

#else

#define DECLARE_ARGS(val, low, high)	unsigned long long val

#define EAX_EDX_VAL(val, low, high)	(val)

#define EAX_EDX_ARGS(val, low, high)	"A" (val)

#define EAX_EDX_RET(val, low, high)	"=A" (val)

#endif

#define barrier() __asm__ __volatile__("": : :"memory")

static inline int rdpmc(struct perf_event_mmap_page *hdr, uint64_t *value)

{

	int counter = hdr->index - 1;

	DECLARE_ARGS(val, low, high);

	if (counter < 0)

		return -1;

	asm volatile("rdpmc" : EAX_EDX_RET(val, low, high) : "c" (counter));

	*value = EAX_EDX_VAL(val, low, high);

	return 0;

}

#else

/*

 *  Default barrier macro.

 *  Given this is architecture specific, it must be defined when

 *  libpfm is ported to new architecture. The default macro below

 *  simply does nothing.

 */

#define barrier() {}

/*

 *  Default function to read counter directly from user level mode.

 *  Given this is architecture specific, it must be defined when

 *  libpfm is ported to new architecture. The default routine below

 *  simply fails and the caller falls backs to syscall.

 */

static inline int rdpmc(struct perf_event_mmap_page *hdr, uint64_t *value)

{

	int counter = hdr->index - 1;

	if (counter < 0)

		return -1;

	printf("your architecture does not have a way to read counters from user mode\n");

	return -1;

}

#endif

/*

 * our test code (function cannot be made static otherwise it is optimized away)

 */

unsigned long 

fib(unsigned long n)

{

	if (n == 0)

		return 0;

	if (n == 1)

		return 2;

	return fib(n-1)+fib(n-2);

}

uint64_t

read_count(perf_event_desc_t *fds)

{

	struct perf_event_mmap_page *hdr;

	uint64_t values[3];

	uint64_t count = 0;

	uint32_t width;

	unsigned int seq;

	ssize_t ret;

	int idx = -1;

	hdr = fds->buf;

	width = hdr->pmc_width;

	do {

		seq = hdr->lock;

		barrier();

		/* try reading directly from user mode */

		if (!rdpmc(hdr, &values[0])) {

			values[1] = hdr->time_enabled;

			values[2] = hdr->time_running;

			ret = 0;

		} else {

			idx = -1;

			ret = read(fds->fd, values, sizeof(values));

			if (ret < (ssize_t)sizeof(values))

				errx(1, "cannot read values");

			printf("using read\n");

			break;

		}

		barrier();

	} while (hdr->lock != seq);

	printf("raw=0x%"PRIx64 " width=%d ena=%"PRIu64 " run=%"PRIu64" idx=%d\n",

		values[0],

		width,

		values[1],

		values[2],

		idx);

	count = values[0];

	count <<= 64 - width;

	count >>= 64 - width;

	values[0] = count;

	return perf_scale(values);

}

int

main(int argc, char **argv)

{

	perf_event_desc_t *fds = NULL;

	long lret;

	size_t pgsz;

	uint64_t val, prev_val;

	int i, ret, num_fds = 0;

	lret = sysconf(_SC_PAGESIZE);

	if (lret < 0)

		err(1, "cannot get page size");

	pgsz = (size_t)lret;

	/*

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

	 */

	ret = pfm_initialize();

	if (ret != PFM_SUCCESS)

		errx(1, "Cannot initialize library: %s", pfm_strerror(ret));

	ret = perf_setup_argv_events(argc > 1 ? (const char **)argv+1 : gen_events, &fds, &num_fds);

	if (ret || !num_fds)

		errx(1, "cannot setup events");

	fds[0].fd = -1;

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

		/* request timing information necesaary for scaling */

		fds[i].hw.read_format = PERF_FORMAT_SCALE;

		fds[i].hw.disabled = 0;

		//fds[i].fd = perf_event_open(&fds[i].hw, 0, -1, fds[0].fd, 0);

		fds[i].fd = perf_event_open(&fds[i].hw, 0, -1, -1, 0);

		if (fds[i].fd == -1)

			err(1, "cannot open event %d", i);

		fds[i].buf = mmap(NULL, pgsz, PROT_READ, MAP_SHARED, fds[i].fd, 0);

		if (fds[i].buf == MAP_FAILED)

			err(1, "cannot mmap page");

	}

	signal(SIGALRM, sig_handler);

	/*

	 * enable all counters attached to this thread

	 */

	ioctl(fds[0].fd, PERF_EVENT_IOC_ENABLE, 0);

	alarm(10);

	prev_val = 0;

	for(;quit == 0;) {

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

			val = read_count(&fds[i]);

			/* print evnet deltas */

			printf("%20"PRIu64" %s\n", val - prev_val, fds[i].name);

			prev_val = val;

		}

		fib(35);

	}

	/*

	 * disable all counters attached to this thread

	 */

	ioctl(fds[0].fd, PERF_EVENT_IOC_DISABLE, 0);

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

		munmap(fds[i].buf, pgsz);

		close(fds[i].fd);

	}

	perf_free_fds(fds, num_fds);

	/* free libpfm resources cleanly */

	pfm_terminate();

	return 0;

}