#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/time.h>
#include <inttypes.h>
#include <libcpc.h>
#include <errno.h>

#include <jni.h>
#include "CPC.h"

// http://developers.sun.com/solaris/articles/optimizing_apps.html
// http://developers.sun.com/solaris/articles/hardware_counters.html

cpc_event_t *before, *after;
long long *timings;
hrtime_t start;

cpc_event_t event;
int cpuver;
const char *setting;

JNIEXPORT void JNICALL Java_CPC_initCPC(JNIEnv *env, jclass obj) {
  before = (cpc_event_t *)calloc(0, sizeof(cpc_event_t));
  after = (cpc_event_t *)calloc(0, sizeof(cpc_event_t));
  timings = (long long *)calloc(0, sizeof(long long));
}

JNIEXPORT jint JNICALL Java_CPC_setupCPC(JNIEnv *env, jclass obj, jstring events, jint size) {
  free(before);
  free(after);
  free(timings);
  before = (cpc_event_t *)calloc(size, sizeof(cpc_event_t));
  after = (cpc_event_t *)calloc(size, sizeof(cpc_event_t));
  timings = (long long *)calloc(size, sizeof(long long));

  setting = (*env)->GetStringUTFChars(env, events, 0);

  if ((cpuver = cpc_getcpuver()) == -1) {
    printf("no performance counters\n");
    return 1;
  }
  printf("hardware identifier %d\n", cpuver);

  if (cpc_strtoevent(cpuver, setting, &event) != 0) {
    printf("ev : cannot measure %s\n", setting);
    return 2;
  }

  setting = cpc_eventtostr(&event);
  if (cpc_bind_event(&event,0) == -1) {
    printf("cannot bind lwp %d %s\n", _lwp_self(),strerror(errno));
    return 3;
  }
  return 0;
}

JNIEXPORT void JNICALL Java_CPC_recordBefore(JNIEnv *env, jclass obj, jint index) {
  start = gethrtime();
  cpc_take_sample(&before[index]);
}

JNIEXPORT void JNICALL Java_CPC_recordAfter(JNIEnv *env, jclass obj, jint index) {
  cpc_take_sample(&after[index]);
  timings[index] = gethrtime() - start;
}

JNIEXPORT jlong JNICALL Java_CPC_getSample(JNIEnv *env, jclass obj, jint index, jint event) {
  return after[index].ce_pic[event] - before[index].ce_pic[event];
}

JNIEXPORT jlong JNICALL Java_CPC_getNanos(JNIEnv *env, jclass obj, jint index) {
 return timings[index];
}

public class CPC {
    private static String eventSpec = null;
    private static int samplePairSize = 0;
    private static boolean setupOkay = false;
    private static int sampleIndex = 0;

    static {
        try {
            System.loadLibrary("javacpc");
            initCPC();
        } catch (Exception E) {
            throw new Error(E);
        }
    }

    public static boolean setup(String events, int size) {
        eventSpec = events;
        samplePairSize = size;
        int okay = setupCPC(events, size);
        setupOkay = (okay == 0);
        return setupOkay;
    }

    public static void sampleBefore() {
        if (!setupOkay) return;
        recordBefore(sampleIndex);
    }

    public static void sampleAfter() {
        if (!setupOkay) return;
        recordAfter(sampleIndex);
        sampleIndex ++;
        if (sampleIndex >= samplePairSize) sampleIndex = samplePairSize-1;
    }

    public static long[][] getSamples() {
        long[][] samples = new long[sampleIndex+1][3];
        for (int i=0; i<=sampleIndex; i++) {
            samples[i][0] = getNanos(i);
            samples[i][1] = getSample(i, 0);
            samples[i][2] = getSample(i, 1);
        }
        sampleIndex = 0;
        return samples;
    }

    private static native void initCPC();
    private static native int setupCPC(String events, int size);
    private static native void recordBefore(int index);
    private static native void recordAfter(int index);
    private static native long getSample(int index, int event);
    private static native long getNanos(int index);
}

/usr/j2sdk1.4.2_01/bin/javah -jni CPC
gcc -O -fPIC -c javacpc.c -I/usr/j2sdk1.4.2_01/include/ -I/usr/j2sdk1.4.2_01/include/solaris/
ld -l c -l cpc -B direct -z defs -G javacpc.o -o libjavacpc.so

public class time {
    public static void main(String[] args) {
        int size = 15;
        boolean ok = CPC.setup("pic0=Cycle_cnt,pic1=Instr_cnt", size);
        if (!ok) return;

        int asize = 2000;
        int a[] = new int[asize], b[] = new int[asize];
        if (args.length == 0) {
            for (int i=0; i<size; i++) {
                CPC.sampleBefore();
                for (int j=0; j<a.length; j++) {
                    a[j] = add(a[j], b[j]);
                }
                CPC.sampleAfter();
            }
        } else {
            for (int i=0; i<size; i++) {
                CPC.sampleBefore();
                for (int j=0; j<a.length; j++) {
                    a[j] = a[j] + b[j];
                }
                CPC.sampleAfter();
            }
        }

        long[][] samps = CPC.getSamples();
        for (int i=0; i<samps.length; i++) {
            System.out.println(i+"\t"+samps[i][1]+"\t"+samps[i][2]+"\t"+samps[i][0]);
        }
    }
    private static int add(int a, int b) { return a+b; }
}