/**
 * Copyright 2019 Sims Hill Osborne and 2020 Joshua Bakita
 *
 * This header provides facilities by which to separably run and time TACLeBench
 * To use this for paired task timing, define PAIRED (pass CFLAGS=-DPAIRED to make)
 **/
#define _GNU_SOURCE
#include <fcntl.h>     // For O_CREAT and O_RDWR
#include <sched.h>     // For sched_yield()
#include <semaphore.h> // For sem_{open, post, wait}()
#include <stdio.h>
#include <stdlib.h>    // For exit()
#include <string.h>    // For strlen()
#include <sys/mman.h>  // For mlockall()
#include <unistd.h>    // For ftruncate()
#include <time.h>

// This is only visible if _GNU_SOURCE is defined, and that define does not
// come along to places where this file is included. Address this by manually
// forcing it into the global namespace.
extern int sched_getcpu();

// These constants correspond to the imx6q-sabredb platform
#define LINE_SIZE 32
#define L2_SIZE 16*2048*32

#if __arm__
#include <unistd.h>
#include <sys/syscall.h>
#endif

<<<<<<< HEAD
#define LITMUS 1
#define MC2 0
=======
// This is a proxy for "case study mode" now
#define LITMUS 0
>>>>>>> rtas20-wip
#define MMDC_PROF 0

#if LITMUS
#include <litmus.h>
#endif

#if MMDC_PROF
#include  "/media/speedy/litmus/tools/mmdc/mmdc.h"
#endif

// Store state globally so that the job can be outside main()
// Arrays use float as a comprimise between overflow and size
// Paired arrays use long longs as precision is more important for those times
#ifdef PAIRED
long long *_rt_start_time;
long long *_rt_end_time;
#else
float *_rt_exec_time;
#endif
#if MMDC_PERF
float *_rt_mmdc_read;
float *_rt_mmdc_write;
#endif
long _rt_jobs_complete;
long _rt_max_jobs;
int _rt_core;
int _rt_will_output;
struct timespec _rt_start, _rt_end;

char *_rt_run_id;
char *_rt_our_prog_name;
char *_rt_other_prog_name;
char *_rt_other_core;
#define _RT_FILENAME_LEN 64
#define _BILLION (1000*1000*1000)
#ifdef PAIRED
char *_rt_barrier;
sem_t *_rt_first_sem, *_rt_second_sem;
int _rt_lock_id;
#define _ID_SZ 128
char _rt_sem1_name[_ID_SZ] = "/_libextra_first_sem-";
char _rt_sem2_name[_ID_SZ] = "/_libextra_second_sem-";
char _rt_shm_name[_ID_SZ] = "/_libextra_barrier-";
#endif /* PAIRED */

#if LITMUS
long unsigned int _rt_period;
#endif

static void _rt_load_params_itrl(int argc, char **argv) {
#ifdef PAIRED
    if (argc != (8 + LITMUS*2) && argc != (9 + LITMUS*2)) {
        fprintf(stderr, "Usage: %s <name> <loops> <my core> <other core> <other name> <runID> <save results?>", argv[0]);
#else
    if (argc != (6 + LITMUS*2)) {
        fprintf(stderr, "Usage: %s <name> <loops> <my core> <runID> <save results?>\n", argv[0]);
#endif /* PAIRED */
        fprintf(stderr, " <name> string for logging. Name of this task.\n");
        fprintf(stderr, " <loops> integer number of iterations. -1 for infinite.\n");
        fprintf(stderr, " <my core> integer core number. Only used for LITMUS-RT.\n");
#ifdef PAIRED
        fprintf(stderr, " <other core> integer for logging. Core of paired task.\n");
        fprintf(stderr, " <other name> string for logging. Name of paired task.\n");
#endif /* PAIRED */
        fprintf(stderr, " <runID> string to append with .txt to yield output file name.\n");
        fprintf(stderr, " <save results?> 1 to save results, 0 to discard.\n");
#ifdef PAIRED
        fprintf(stderr, " <pairID> (optional).\n");
#endif
#if LITMUS
        fprintf(stderr, " <task period> in ms\n");
        fprintf(stderr, " <task criticality level> 0 for Level-A, 1 for Level-B, 2 for Level-C\n");
#endif /* LITMUS */
        exit(1);
    }
    _rt_our_prog_name = argv[1];
    _rt_max_jobs = atol(argv[2]);
#if !LITMUS
    _rt_core = sched_getcpu();
#else
    _rt_core = atoi(argv[3]);
#endif
#ifdef PAIRED
    _rt_other_core = argv[4];
    _rt_other_prog_name = argv[5];
    _rt_run_id = argv[6];
    _rt_will_output = atoi(argv[7]);
    char *pairId;
    int end;
    if (argc > 8) {
        pairId = argv[8];
        end = 8;
    } else {
        pairId = "none";
        end = 9;
    }
#else
    _rt_other_core = "none";
    _rt_other_prog_name = "none";
    _rt_run_id = argv[4];
    _rt_will_output = atoi(argv[5]);
    int end = 6;
#endif /* PAIRED */
    if (_rt_max_jobs < 0 && _rt_will_output != 0) {
        fprintf(stderr, "Infinite loops only supported when output is disabled!\n");
        exit(1);
    }
    if (strlen(_rt_run_id) + 5 > _RT_FILENAME_LEN) {
        fprintf(stderr, "Run ID is too large! Keep it to less than %d characters.\n", _RT_FILENAME_LEN);
        exit(1);
    }
#ifdef PAIRED
    // __rt_sem2_name happens to be the longest
    if (strlen(pairId) + strlen(_rt_sem2_name) > _ID_SZ) {
        fprintf(stderr, "PairID is too long! Maximum length is %ld characters.\n", _ID_SZ - strlen(_rt_sem2_name));
        exit(1);
    }
    _rt_start_time = calloc(_rt_max_jobs * _rt_will_output, sizeof(long long));
    _rt_end_time = calloc(_rt_max_jobs * _rt_will_output, sizeof(long long));
    if (!_rt_end_time || !_rt_start_time) {
        perror("Unable to allocate buffers for execution times");
        exit(1);
    }
    // Use PairID to create unique semaphore and shared memory paths
    strcat(_rt_sem1_name, pairId);
    strcat(_rt_sem2_name, pairId);
    strcat(_rt_shm_name, pairId);
    _rt_first_sem = sem_open(_rt_sem1_name, O_CREAT, 644, 0);
    _rt_second_sem = sem_open(_rt_sem2_name, O_CREAT, 644, 0);
    if (_rt_first_sem == SEM_FAILED || _rt_second_sem == SEM_FAILED) {
        perror("Error while creating semaphores");
        exit(1);
    }
    // Create shared memory for barrier synchronization and infer lock ID
    int barrier_file = shm_open(_rt_shm_name, O_CREAT | O_RDWR | O_EXCL, 644);
    if (barrier_file == -1) {
        // File already existed - we're the 2nd program and thus lock ID 2
        _rt_lock_id = 2;
        barrier_file = shm_open(_rt_shm_name, O_CREAT | O_RDWR, 644);
    } else {
        _rt_lock_id = 1;
    }
    if (barrier_file == -1) {
        perror("Error while creating shared memory for barrier synchronization");
        exit(1);
    }
    if (ftruncate(barrier_file, 2) == -1) {
        perror("Error while setting size of shared memory for barrier synchronization");
        exit(1);
    }
    _rt_barrier = mmap(NULL, 2, PROT_WRITE, MAP_SHARED, barrier_file, 0);
    if (_rt_barrier == MAP_FAILED) {
        perror("Error while mapping shared memory for barrier synchronization");
        exit(1);
    }
    // If we're the 2nd user of this barrier, mark it as in-use
    if (_rt_lock_id == 2 && !__sync_bool_compare_and_swap(_rt_barrier+1, 0, 1)) {
        fprintf(stderr, "Pair ID already in use!\n");
        exit(1);
    }
    *_rt_barrier = 0;
#else
    _rt_exec_time = calloc(_rt_max_jobs * _rt_will_output, sizeof(float));
    if (!_rt_exec_time) {
        perror("Unable to allocate buffer for execution times");
        exit(1);
    }
#endif /* PAIRED */
    _rt_jobs_complete = 0;
    mlockall(MCL_CURRENT || MCL_FUTURE);
#if LITMUS
    _rt_period = strtoul(argv[end], NULL, 10);
    unsigned int crit = atoi(argv[end+1]);
    unsigned int wait = 1;
    if (be_migrate_to_domain(_rt_core) < 0) {
        perror("Unable to migrate to specified CPU");
        exit(1);
    }
    struct rt_task rt_param;
    init_rt_task_param(&rt_param);
    rt_param.exec_cost = 0; // We disable budget enforcement, so this doesn't matter
    rt_param.period = ms2ns(_rt_period);
    rt_param.relative_deadline = 0;
    rt_param.phase = 0;
    rt_param.priority = LITMUS_LOWEST_PRIORITY;
    rt_param.cls = crit;
    rt_param.release_policy = TASK_PERIODIC;
    rt_param.budget_policy = NO_ENFORCEMENT;
    rt_param.cpu = _rt_core;
    if (set_rt_task_param(gettid(), &rt_param) < 0) {
        perror("Unable to set real-time parameters");
        exit(1);
    }
    if (init_litmus() != 0) {
        perror("init_litmus failed");
        exit(1);
    }
    if (task_mode(LITMUS_RT_TASK) != 0) {
        perror("Unable to become real-time task");
        exit(1);
    }
    if (wait && wait_for_ts_release() != 0) {
        perror("Unable to wait for taskset release");
        exit(1);
    }
#endif /* LITMUS */
#if MMDC_PROF
    SETUP_MMDC
#endif
}

#define SETUP_MMDC \
    _rt_mmdc_read = calloc(_rt_max_jobs * _rt_will_output, sizeof(float));\
    _rt_mmdc_write = calloc(_rt_max_jobs * _rt_will_output, sizeof(float));\
    if (!_rt_mmdc_read || !_rt_mmdc_write) {\
        perror("Unable to allocate buffer for MMDC data");\
        exit(1);\
    }\
    MMDC_PROFILE_RES_t mmdc_res;\
    memset(&mmdc_res, 0, sizeof(MMDC_PROFILE_RES_t));\
    int fd = open("/dev/mem", O_RDWR, 0);\
    if (fd < 0) {\
        perror("Unable to open /dev/mem");\
        exit(1);\
    }\
    pMMDC_t mmdc = mmap(NULL, 0x4000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, MMDC_P0_IPS_BASE_ADDR);\
    if (mmdc == MAP_FAILED) {\
        perror("Unable to map MMDC address space");\
        exit(1);\
    }\
    mmdc->madpcr1 = axi_arm1;\
    msync(&(mmdc->madpcr1),4,MS_SYNC);

<<<<<<< HEAD
#define SETUP_LITMUS \
    unsigned int wait = 0; \
    if (be_migrate_to_domain(_rt_core) < 0) { \
        perror("Unable to migrate to specified CPU"); \
        exit(1); \
    } \
    struct rt_task rt_param; \
    init_rt_task_param(&rt_param); \
    /* Supposedly the next two parameters are irrelevant when reservations are enabled, but I'm leaving them anyway... */ \
    rt_param.exec_cost = ms2ns(999); \
    rt_param.period = ms2ns(1000); \
    rt_param.priority = LITMUS_HIGHEST_PRIORITY; \
    rt_param.cls = RT_CLASS_HARD; \
    rt_param.release_policy = TASK_PERIODIC; \
    rt_param.budget_policy = NO_ENFORCEMENT; \
    rt_param.cpu = _rt_core; \
    if (set_rt_task_param(gettid(), &rt_param) < 0) { \
        perror("Unable to set real-time parameters"); \
        exit(1); \
    } \
    if (init_litmus() != 0) { \
        perror("init_litmus failed"); \
        exit(1); \
    } \
    MC2_SETUP \
    if (task_mode(LITMUS_RT_TASK) != 0) { \
        perror("Unable to become real-time task"); \
        exit(1); \
    } \
    if (wait && wait_for_ts_release() != 0) { \
        perror("Unable to wait for taskset release"); \
        exit(1); \
    }

#if MC2
#define MC2_SETUP \

    set_page_color(rt_param.cpu);
#else
#define MC2_SETUP
#endif

#define CLEANUP_LITMUS \
    if (task_mode(BACKGROUND_TASK) != 0) { \
        perror("Unable to become a real-time task"); \
        exit(1); \
    } \

=======
>>>>>>> rtas20-wip
#if __arm__
// On ARM, manually flush the cache
#define FLUSH_CACHES \
    volatile uint8_t buffer[L2_SIZE * 4]; \
    for (uint32_t j = 0; j < 4; j++) \
        for (uint32_t i = 0; i < L2_SIZE * 4; i += LINE_SIZE) \
            buffer[i]++;
#else
// On x86 call the wbinvld instruction (it's in a kernel module due to it being ring-0)
#define FLUSH_CACHES \
    FILE *fp = fopen("/proc/wbinvd", "r");\
    if (fp == NULL) {\
        perror("Cache flush module interface cannot be opened");\
        exit(1);\
    }\
    char dummy;\
    if (fread(&dummy, 1, 1, fp) == 0) {\
        perror("Unable to access cache flush module interface");\
        exit(1);\
    }\
    fclose(fp);
#endif

// This semaphore-based synchronization is from Sims
#define FIRST_UNLOCK \
    if (_rt_lock_id == 1) {\
        if (sem_post(_rt_second_sem) != 0) {\
            perror("Unable to unlock second semaphore");\
            exit(1);\
        }\
    } \
    else {\
        if (sem_post(_rt_first_sem) != 0) {\
            perror("Unable to unlock first semaphore");\
            exit(1);\
        }\
    } \

#define FIRST_LOCK \
    if (_rt_lock_id == 1) {\
        if (sem_wait(_rt_first_sem) != 0) {\
            perror("Unable to wait on first semaphore");\
            exit(1);\
        }\
    }\
    else {\
        if (sem_wait(_rt_second_sem) != 0) {\
            perror("Unable to wait on second semaphore");\
            exit(1);\
        }\
    }

// This ensures a very low difference between pair member start times
#define BARRIER_SYNC \
    if (__sync_bool_compare_and_swap(_rt_barrier, 0, 1)) {\
        while (!__sync_bool_compare_and_swap(_rt_barrier, 0, 0)) {};\
    }\
    else {\
        __sync_bool_compare_and_swap(_rt_barrier, 1, 0);\
    }

// Buffer timing result from a single job
static void _rt_save_job_result() {
    if (!_rt_will_output)
        return;
    if (_rt_jobs_complete >= _rt_max_jobs) {
        fprintf(stderr, "Max jobs setting too small! Trying to record job #%ld when we only have space for %ld jobs. Exiting...\n", _rt_jobs_complete, _rt_max_jobs);
        exit(1);
    }
#ifdef PAIRED
    _rt_start_time[_rt_jobs_complete] = _rt_start.tv_sec;
    _rt_start_time[_rt_jobs_complete] *= _BILLION;
    _rt_start_time[_rt_jobs_complete] += _rt_start.tv_nsec;
    _rt_end_time[_rt_jobs_complete] = _rt_end.tv_sec;
    _rt_end_time[_rt_jobs_complete] *= _BILLION;
    _rt_end_time[_rt_jobs_complete] += _rt_end.tv_nsec;
#else
    _rt_exec_time[_rt_jobs_complete] = _rt_end.tv_sec - _rt_start.tv_sec;
    _rt_exec_time[_rt_jobs_complete] *= _BILLION;
    _rt_exec_time[_rt_jobs_complete] += _rt_end.tv_nsec - _rt_start.tv_nsec;
#endif /* PAIRED */
#if MMDC_PROF
    _rt_mmdc_read[_rt_jobs_complete] = mmdc_res.read_bytes;
    _rt_mmdc_write[_rt_jobs_complete] = mmdc_res.write_bytes;
#endif /* MMDC_PROF */
}

// Save all buffered timing results to disk
static void _rt_write_to_file() {
    char fileName[_RT_FILENAME_LEN];
    FILE *fp;
    munlockall();
    if (!_rt_will_output)
        goto out;
    strcpy(fileName, _rt_run_id);
    strcat(fileName, ".txt");
    fp = fopen(fileName, "a");
    if (fp == NULL) {
        perror("Unable to open output file");
        exit(1);
    }
    // Baseline output uses a similar format with "none" for unused fields
    for (int i = 0; i < _rt_jobs_complete; i++){
        fprintf(fp, "%s %s %u %s %ld", _rt_our_prog_name, _rt_other_prog_name,
            _rt_core, _rt_other_core, _rt_max_jobs);
#ifdef PAIRED
        // For unclear legacy reasons, paired tasks emit sec and ns separately
        fprintf(fp, " %lld %lld %lld %lld",
            _rt_start_time[i] / _BILLION, _rt_start_time[i] % _BILLION,
            _rt_end_time[i] / _BILLION, _rt_end_time[i] % _BILLION);
#else
        fprintf(fp, " %.f", _rt_exec_time[i]);
#endif /* PAIRED */
        fprintf(fp, " %s %d %.f %.f\n",  _rt_run_id, i,
#if MMDC_PROF
            _rt_mmdc_read[i], _rt_mmdc_write[i]);
#else
            0.0, 0.0);
#endif /* MMDC_PROF */
    }
    fclose(fp);
out:
#if LITMUS
    if (task_mode(BACKGROUND_TASK) != 0) {
        perror("Unable to become a real-time task");
        exit(1);
    }
#endif /* LITMUS */
#ifdef PAIRED
    munmap(_rt_barrier, 2);
    sem_unlink(_rt_sem1_name);
    sem_unlink(_rt_sem2_name);
    shm_unlink(_rt_shm_name);
    free(_rt_start_time);
    free(_rt_end_time);
#else
    free(_rt_exec_time);
#endif /* PAIRED */
#if MMDC_PROF
    free(_rt_mmdc_read);
    free(_rt_mmdc_write);
#endif /* MMDC_PROF */
}

// Start a job
static void _rt_start_loop() {
#if LITMUS
    if (sleep_next_period() != 0) {
        perror("Unable to sleep for next period");
    }
#else
    sched_yield();
#endif /* LITMUS */
#ifdef PAIRED
    FIRST_UNLOCK
    FIRST_LOCK
#endif /* PAIRED */
#if !LITMUS
    FLUSH_CACHES
#endif
#ifdef PAIRED
    BARRIER_SYNC
#endif /* PAIRED */
#if MMDC_PROF
    /* This disables profiling, resets the counters, clears the overflow bit, and enables profiling */
    start_mmdc_profiling(mmdc);
#endif /* MMDC_PROF */
    clock_gettime(CLOCK_MONOTONIC, &_rt_start);
}

// Complete a job
static void _rt_stop_loop() {
    clock_gettime(CLOCK_MONOTONIC, &_rt_end);
#if MMDC_PROF
    /* This freezes the profiling and makes results available */
    pause_mmdc_profiling(mmdc);
    get_mmdc_profiling_results(mmdc, &mmdc_res);
#endif /* MMDC_PROF */
    _rt_save_job_result();
    _rt_jobs_complete++;
}

/****** New API ******
 * Intended structure:
 *
 * |int main(int argc, char **argv) {
 * |  SET_UP
 * |  ...
 * |  for_each_job {
 * |    tacleInit();
 * |    tacleMain();
 * |  }
 * |  WRITE_TO_FILE
 * |}
 *
 * The main() function must call its parameters argc and argv for SET_UP to be
 * able to read them.
 * Only SET_UP necessarily has to be in main().
 *
 * We use some niche C features, here's a quick explaination:
 * 1. The && operator doesn't evaluate the right-hand side of the expression
 *    unless the left side evaluated to true. We use this to only execute 
 *    _rt_start_loop() when the loop will actually run.
 * 2. The comma operator executes the first expression and then throws away the
 *    result. We use this to call our void function from inside a comparison.
 */
#define for_each_job \
    for (; (_rt_max_jobs == -1 || _rt_jobs_complete < _rt_max_jobs) && (_rt_start_loop(),1); \
         _rt_stop_loop())

/****** Legacy API ******
 * Intended structure:
 *
 * |int main(int argc, char **argv) {
 * |  SET_UP
 * |  for (jobsComplete=0; jobsComplete<maxJobs; jobsComplete++){
 * |    START_LOOP
 * |    tacleInit();
 * |    tacleMain();
 * |    STOP_LOOP
 * |  }
 * |  WRITE_TO_FILE
 * |  tacleReturn
 * |}
 *
 * The main() function must call its parameters argc and argv for SET_UP to be
 * able to read them.
 */
static int jobsComplete = 0;
#define SET_UP _rt_load_params_itrl(argc, argv);
#define START_LOOP _rt_start_loop();
#define STOP_LOOP _rt_stop_loop();
#define WRITE_TO_FILE _rt_write_to_file();
#define maxJobs _rt_max_jobs
// Has been part of STOP_LOOP for quite some time
#define SAVE_RESULTS \
    #warning "The SAVE_RESULTS macro is deprecated and will soon be removed!";
// Unclear if SLEEP is used anywhere.
#define SLEEP \
    #warning "The SLEEP macro is deprecated and may be removed!" \
    nanosleep((const struct timespec[]){{0, 1000000}}, NULL);