#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <fcntl.h>
#include <getopt.h>

#define TEST_DURATION_SEC 2.0
#define MAX_TOTAL_GB 16

typedef enum {
    MODE_MMAP_SHARED,
    MODE_MMAP_PRIVATE,
    MODE_MEMFD_NORMAL,
    MODE_MEMFD_DONTNEED,
    MODE_MEMFD_UNMAP
} bench_mode_t;

const char* get_mode_name(bench_mode_t mode) {
    switch(mode) {
        case MODE_MMAP_SHARED:    return "mmap-MAP_SHARED";
        case MODE_MMAP_PRIVATE:   return "mmap-MAP_PRIVATE";
        case MODE_MEMFD_NORMAL:   return "memfd_normal";
        case MODE_MEMFD_DONTNEED: return "memfd_MADV_DONTNEED";
        case MODE_MEMFD_UNMAP:    return "memfd_unmap";
        default: return "unknown";
    }
}

double get_now() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
}

double run_benchmark(bench_mode_t mode, int num_segs, int size_gb, int use_huge) {
    size_t segment_size = (size_t)size_gb * 1024 * 1024 * 1024ULL;
    int *fds = malloc(num_segs * sizeof(int));
    void **ptrs = malloc(num_segs * sizeof(void *));
    
    for (int i = 0; i < num_segs; i++) {
        int shared_flag = (mode == MODE_MMAP_PRIVATE) ? MAP_PRIVATE : MAP_SHARED;
        
        if (mode >= MODE_MEMFD_NORMAL) {
            char name[32];
            sprintf(name, "bench_%d", i);
            int mfd_flags = MFD_CLOEXEC | (use_huge ? MFD_HUGETLB : 0);
            fds[i] = memfd_create(name, mfd_flags);
            if (fds[i] < 0) return -1.0;
            if (ftruncate(fds[i], segment_size) < 0) return -1.0;
            ptrs[i] = mmap(NULL, segment_size, PROT_READ | PROT_WRITE, shared_flag, fds[i], 0);
        } else {
            int flags = shared_flag | MAP_ANONYMOUS | (use_huge ? MAP_HUGETLB : 0);
            ptrs[i] = mmap(NULL, segment_size, PROT_READ | PROT_WRITE, flags, -1, 0);
        }

        if (ptrs[i] == MAP_FAILED) return -1.0;
        memset(ptrs[i], 'A', segment_size);

        if (mode == MODE_MEMFD_DONTNEED) madvise(ptrs[i], segment_size, MADV_DONTNEED);
        if (mode == MODE_MEMFD_UNMAP) munmap(ptrs[i], segment_size);
    }

    long fork_count = 0;
    double start_time = get_now();
    while ((get_now() - start_time) < TEST_DURATION_SEC) {
        pid_t pid = fork();
        if (pid < 0) break;
        if (pid == 0) {
            if (mode == MODE_MEMFD_UNMAP) {
                for (int j = 0; j < num_segs; j++) 
                    mmap(NULL, segment_size, PROT_READ | PROT_WRITE, MAP_SHARED, fds[j], 0);
            }
            _exit(0);
        } else {
            waitpid(pid, NULL, 0);
            fork_count++;
        }
    }
    double total_time = get_now() - start_time;

    for (int i = 0; i < num_segs; i++) {
        if (mode != MODE_MEMFD_UNMAP) munmap(ptrs[i], segment_size);
        if (mode >= MODE_MEMFD_NORMAL) close(fds[i]);
    }
    free(fds); free(ptrs);
    return (double)fork_count / total_time;
}

void print_usage(char* prog) {
    printf("Usage: %s [--huge-pages | --no-huge-pages]\n", prog);
    exit(1);
}

int main(int argc, char **argv) {
    int huge_flag = -1;
    
    static struct option long_options[] = {
        {"huge-pages", no_argument, 0, 'h'},
        {"no-huge-pages", no_argument, 0, 'n'},
        {0, 0, 0, 0}
    };

    int opt;
    while ((opt = getopt_long(argc, argv, "hn", long_options, NULL)) != -1) {
        switch (opt) {
            case 'h': huge_flag = 1; break;
            case 'n': huge_flag = 0; break;
            default: print_usage(argv[0]);
        }
    }

    if (huge_flag == -1) print_usage(argv[0]);

    printf("Starting Sweep (HugePages: %s, Max Mem: %dGB, Max Time/Test: %.1fs)\n", 
            huge_flag ? "ENABLED" : "DISABLED", MAX_TOTAL_GB, TEST_DURATION_SEC);
    printf("%-20s | %-5s | %-6s | %-12s\n", "Mode", "Segs", "SizeGB", "Forks/sec");
    printf("----------------------------------------------------------------------\n");

    bench_mode_t modes[] = {MODE_MMAP_SHARED, MODE_MMAP_PRIVATE, MODE_MEMFD_NORMAL, MODE_MEMFD_DONTNEED, MODE_MEMFD_UNMAP};

    for (int m = 0; m < 5; m++) {
        for (int s = 1; s <= 16; s *= 2) {
            for (int n = 1; n <= 16; n *= 2) {
                if (n * s > MAX_TOTAL_GB) continue;

                double rate = run_benchmark(modes[m], n, s, huge_flag);
                
                if (rate < 0) {
                    printf("%-20s | %-5d | %-6d | [ERR: OOM/POOL]\n", get_mode_name(modes[m]), n, s);
                } else {
                    printf("%-20s | %-5d | %-6d | %-12.2f\n", get_mode_name(modes[m]), n, s, rate);
                }
            }
        }
        printf("----------------------------------------------------------------------\n");
    }

    return 0;
}
