#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>

/*
old time:
$ ./test
1000 mmaps 4 kB blocks: 16638 ms
1000 mmaps 64 kB blocks: 16557 ms
1000 mmaps 1024 kB blocks: 18319 ms

new time:
$ ./test
1000 mmaps 4 kB blocks: 177 ms
1000 mmaps 64 kB blocks: 410 ms
1000 mmaps 1024 kB blocks: 2146 ms

*/

#define BUFSZ 1000000000  // 10GB

void* mapping;
size_t mapping_size;

static int open_cheat_mapping(int fd) {
    off_t current = lseek(fd, 0, SEEK_CUR);
    mapping_size = lseek(fd, 0, SEEK_END);
    lseek(fd, current, SEEK_SET);

    mapping = mmap(NULL, mapping_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (mapping == MAP_FAILED) {
        mapping = NULL;
        return errno;
    }
    return 0;
}

static void* mmap_cheat(void* addr, size_t len, int prot, int flags, int fd, off_t offset) {
    if (mapping == NULL && open_cheat_mapping(fd) != 0) {
        return MAP_FAILED;
    }
    size_t end_size;
    if (__builtin_add_overflow(offset, len, &end_size) || end_size > mapping_size) {
        return MAP_FAILED;
    }
    return mapping + offset;
}

static int munmap_cheat(void* addr, size_t len) {
    return 0;
}

#ifdef CHEAT
#define mmap mmap_cheat
#define munmap munmap_cheat
#endif

int main(int argc, char *argv[])
{
        unsigned int total, msize, offset, secs;
        int fd, i, j, rslt;
        void * p;
        volatile char c;
        struct timeval start, end;

// Time 1000 mmaps and munmaps from random offsets for various
// sizes of mapped chunk.
        for (msize = 4096; msize <= 1048576; msize *= 16) {
                gettimeofday(&start, NULL);
                fd = open("io_benchmark.dat", O_RDONLY); // file
                if (fd  < 0 ) abort();
                for (i = 0; i < 1000; i++) {
                // Make sure the block to be mapped doesn't start in the
                // last meg and is multiply of 4096.
                offset = (off_t) random() % (BUFSZ - 1048576) /10000 * 4096;
                p = mmap(0, (size_t) msize, PROT_READ, MAP_PRIVATE, fd, offset);
                if (p == MAP_FAILED){
                        printf("map failed: %s offset: %i \n", strerror(errno), offset);
                }
                for (j = 1; j < msize; j++) {
                        c = *((char *)p+j);
                        }
                munmap(p, (size_t) msize);
                }
        gettimeofday(&end, NULL);
        secs = ((end.tv_sec * 1000) + (end.tv_usec /1000)) - ((start.tv_sec * 1000) + (start.tv_usec /1000)) ;
        printf("1000 mmaps %d kB blocks: %i ms\n", msize/1024, secs);
  rslt = close(fd);
  if (fd  < 0 ) abort();
  }
    return 0;
}