#include <stdio.h>
#include <stdlib.h>

#define NAME(a) \
unsigned int a##csum(const unsigned char * buff, int len, \
			unsigned int sum); \
unsigned int a##copy(const char *src, char *dst, \
                        int len, int sum, int *src_err_ptr, int *dst_err_ptr)
			
/* This makes adding/removing test functions easier */
/* asm ones... */
NAME(kernel_);
NAME(kernelpii_);
NAME(kernelpiipf_);
/* and C */
#include "pfm_csum.c"
#include "pfm2_csum.c"
#include "ntq_copy.c"
#include "ntqpf_copy.c"
#include "ntqpf2_copy.c"
#include "ntqpfm_copy.c"

const int TRY_TIMES = 1024;
const int NBUFS = 512;
const int BUFSIZE = 1024;
const int POISON = 0; // want to check correctness?

typedef unsigned int csum_func(const unsigned char * buff, int len,
		unsigned int sum);
typedef unsigned int copy_func(const char *src, char *dst,
		int len, int sum, int *src_err_ptr, int *dst_err_ptr);

static inline long long rdtsc()
{
	unsigned int low,high;
	__asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high));
	return low + (((long long)high)<<32);
}

int die(const char *msg) {
	puts(msg);
	abort();
	return 1;
}

unsigned test_one_csum(csum_func *func, char *name, char *buffer)
{
	int i;
	unsigned long long before,after,min,max;
	unsigned sum;
	
	// pick fastest run
	min = ~0ULL;
	max = 0;
	for (i=0;i<TRY_TIMES;i++) {
		before = rdtsc();
		unsigned sum2 = func(buffer + (rand () % NBUFS) * BUFSIZE,
				     BUFSIZE, 0);
		after = rdtsc();
		if (before>after) die("timer overflow");
		else {
			after-=before;
			if(min>after) min=after;
			if(max<after) max=after;
		}		
	}
	printf("%32s - took %5lli max,%5lli min cycles per kb. sum=0x%08x\n",
		name,
		max / (BUFSIZE/1024),
		min / (BUFSIZE/1024),
		sum
		);
}
     
unsigned test_one_copy(copy_func *func, char *name, char *buffer)
{
	int i;
	unsigned long long before,after,min,max;
	unsigned sum;
	int err;

	// pick fastest run
	min = ~0ULL;
	max = 0;
	for (i=0; i<TRY_TIMES; i++) {
		if(POISON) memset(buffer,          0x55,BUFSIZE/2);
		if(POISON) memset(buffer+BUFSIZE/2,0xaa,BUFSIZE/2);
		buffer[0] = 0x77;
		buffer[BUFSIZE/2-1] = 0x44;
		before = rdtsc();
		char *buf = buffer + rand () % (NBUFS - 1);
		unsigned sum2 = func(buf,buf+BUFSIZE/2,BUFSIZE/2,0,&err,&err);
		after = rdtsc();
		if(POISON) if(memcmp(buffer,buffer+BUFSIZE/2,BUFSIZE/2)!=0) die("BAD copy!");
		if (before>after) die("timer overflow");
		else {
			after-=before;
			if(min>after) min=after;
			if(max<after) max=after;
		}		
	}
	printf("%32s - took %5lli max,%5lli min cycles per kb. sum=0x%08x\n",
		name,
		max / (BUFSIZE/1024) / 2,
		min / (BUFSIZE/1024) / 2,
		sum
	);
	return sum;
}
     
     
void test_csum(char *buffer)
{
	unsigned sum;
	puts("csum tests:");

#define	TEST_CSUM(a) test_one_csum(a,#a,buffer)
	TEST_CSUM(kernel_csum	);
	TEST_CSUM(kernel_csum	);
	TEST_CSUM(kernel_csum	);
	TEST_CSUM(kernelpii_csum	);
	TEST_CSUM(kernelpiipf_csum);
	TEST_CSUM(pfm_csum	);
	TEST_CSUM(pfm2_csum	);
#undef TEST_CSUM
}   

void test_copy(char *buffer)
{
	unsigned sum;
	puts("copy tests:");

#define	TEST_COPY(a) test_one_copy(a,#a,buffer)
	sum =  TEST_COPY(kernel_copy	);
	sum == TEST_COPY(kernel_copy	) || die("Bad sum");
	sum == TEST_COPY(kernel_copy	) || die("Bad sum");
	sum == TEST_COPY(kernelpii_copy	) || die("Bad sum");
	sum == TEST_COPY(ntqpf_copy	) || die("Bad sum");
	sum == TEST_COPY(ntqpfm_copy	) || die("Bad sum");
	sum == TEST_COPY(ntq_copy	) || die("Bad sum");
	sum == TEST_COPY(ntqpf2_copy	) || die("Bad sum");
#undef TEST_COPY
}

int main()
{
	char *buffer_raw,*buffer;
	printf("Csum benchmark program\n"
		"buffer size: %i K\n"
		"Each test tried %i times, max and min CPU cycles are reported.\n"
		"Please disregard max values. They are due to system interference only.\n",
		BUFSIZE/1024,
		TRY_TIMES
	);
	
	buffer_raw = malloc(NBUFS * BUFSIZE+16);
	if(!buffer_raw) die("Malloc failed");
		
	buffer = (char*) ((((int)buffer_raw)+15) & (~0xF));
	
	test_csum(buffer);
	test_copy(buffer);

	puts("Done");
	free(buffer_raw);
	return 0;
}