memory_access_balljugglery

#include <time.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <sys/mman.h>

#define HALF_OF_BUFFER_SIZE 1024*1024*100
#define BUFFER_SIZE 1024*1024*201

int main(){

	struct timespec time1;
	struct timespec time2;
	int seconds, nanoseconds;

	uint8_t *buffer = mmap(0, 1024*1024*202, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

	/* to make sure that the buffer is actually allocated */
	memset(buffer, 3, 1024*1024*200);

	/* warmup */
	copy_aligned(buffer+HALF_OF_BUFFER_SIZE, buffer, HALF_OF_BUFFER_SIZE);
	copy_aligned(buffer+HALF_OF_BUFFER_SIZE, buffer, HALF_OF_BUFFER_SIZE);
	copy_aligned(buffer+HALF_OF_BUFFER_SIZE, buffer, HALF_OF_BUFFER_SIZE);

	clock_gettime(CLOCK_MONOTONIC_RAW, &time1);
	copy_aligned(buffer+HALF_OF_BUFFER_SIZE, buffer, HALF_OF_BUFFER_SIZE);
	clock_gettime(CLOCK_MONOTONIC_RAW, &time2);

	if ((time2.tv_nsec-time1.tv_nsec)<0) {
		seconds = time2.tv_sec-time1.tv_sec-1;
		nanoseconds = 1000000000+time2.tv_nsec-time1.tv_nsec;
	} else {
		seconds = time2.tv_sec-time1.tv_sec;
		nanoseconds = time2.tv_nsec-time1.tv_nsec;
	}
	printf("aligned: %u sec, %u nsec\n", seconds, nanoseconds);

	clock_gettime(CLOCK_MONOTONIC_RAW, &time1);
	copy_unaligned(buffer+HALF_OF_BUFFER_SIZE, buffer, HALF_OF_BUFFER_SIZE);
	clock_gettime(CLOCK_MONOTONIC_RAW, &time2);

	if ((time2.tv_nsec-time1.tv_nsec)<0) {
		seconds = time2.tv_sec-time1.tv_sec-1;
		nanoseconds = 1000000000+time2.tv_nsec-time1.tv_nsec;
	} else {
		seconds = time2.tv_sec-time1.tv_sec;
		nanoseconds = time2.tv_nsec-time1.tv_nsec;
	}
	printf("unaligned on aligned data: %u sec, %u nsec\n", seconds, nanoseconds);

	clock_gettime(CLOCK_MONOTONIC_RAW, &time1);
	copy_unaligned(buffer+HALF_OF_BUFFER_SIZE+1, buffer, HALF_OF_BUFFER_SIZE+1);
	clock_gettime(CLOCK_MONOTONIC_RAW, &time2);

	if ((time2.tv_nsec-time1.tv_nsec)<0) {
		seconds = time2.tv_sec-time1.tv_sec-1;
		nanoseconds = 1000000000+time2.tv_nsec-time1.tv_nsec;
	} else {
		seconds = time2.tv_sec-time1.tv_sec;
		nanoseconds = time2.tv_nsec-time1.tv_nsec;
	}
	printf("unaligned on one byte unaligned data: %u sec, %u nsec\n", seconds, nanoseconds);

	clock_gettime(CLOCK_MONOTONIC_RAW, &time1);
	copy_unaligned(buffer+HALF_OF_BUFFER_SIZE+3, buffer, HALF_OF_BUFFER_SIZE+3);
	clock_gettime(CLOCK_MONOTONIC_RAW, &time2);

	if ((time2.tv_nsec-time1.tv_nsec)<0) {
		seconds = time2.tv_sec-time1.tv_sec-1;
		nanoseconds = 1000000000+time2.tv_nsec-time1.tv_nsec;
	} else {
		seconds = time2.tv_sec-time1.tv_sec;
		nanoseconds = time2.tv_nsec-time1.tv_nsec;
	}
	printf("unaligned on three bytes unaligned data: %u sec, %u nsec\n", seconds, nanoseconds);

	clock_gettime(CLOCK_MONOTONIC_RAW, &time1);
	copy_aligned_nontemporal(buffer+HALF_OF_BUFFER_SIZE, buffer, HALF_OF_BUFFER_SIZE);
	clock_gettime(CLOCK_MONOTONIC_RAW, &time2);

	if ((time2.tv_nsec-time1.tv_nsec)<0) {
		seconds = time2.tv_sec-time1.tv_sec-1;
		nanoseconds = 1000000000+time2.tv_nsec-time1.tv_nsec;
	} else {
		seconds = time2.tv_sec-time1.tv_sec;
		nanoseconds = time2.tv_nsec-time1.tv_nsec;
	}
	printf("aligned nontemporal: %u sec, %u nsec\n", seconds, nanoseconds);

	clock_gettime(CLOCK_MONOTONIC_RAW, &time1);
	copy_naive(buffer+HALF_OF_BUFFER_SIZE, buffer, HALF_OF_BUFFER_SIZE);
	clock_gettime(CLOCK_MONOTONIC_RAW, &time2);

	if ((time2.tv_nsec-time1.tv_nsec)<0) {
		seconds = time2.tv_sec-time1.tv_sec-1;
		nanoseconds = 1000000000+time2.tv_nsec-time1.tv_nsec;
	} else {
		seconds = time2.tv_sec-time1.tv_sec;
		nanoseconds = time2.tv_nsec-time1.tv_nsec;
	}
	printf("naive: %u sec, %u nsec\n", seconds, nanoseconds);

	return 0;
}