Unify all the versions of extra.h into a single multipurpose header

There was previously a huge amount of shared code that had to be
copied back and forth. This should reduce the maintenance burden
by containing all future changes to a single file.

New unified library is fully backwards-compatible but also
introduces and the easy-to-use `for_each_job` macro which
replaces the specific `for(...) START_LOOP ... STOP_LOOP`
format requirement and is generally much harder to abuse.

New unified library also automatically cleans up its shared memory
and semaphores, so this commit also removes the separate
`cleanupSemaphores` binary.

I also found a precursor of `extra.h` written by Sims in
`litmusStuff.h`. This code is only interesting for historical
purposes, so it is also removed in this commit.

This commit also adds debug options to all the Makefiles and
silences rm's complaints about non-existent files in make clean.

1 files changed, 0 insertions, 350 deletions

diff --git a/baseline/source/extra.h b/baseline/source/extra.h
deleted file mode 100644
index e8f3d18..0000000
--- a/baseline/source/extra.h
+++ /dev/null
@@ -1,350 +0,0 @@
-/**
- * Copyright 2019 Sims Hill Osborne and Joshua Bakita
- *
- * This header provides facilities by which to separably run and time TACLeBench
- **/
-#define _GNU_SOURCE
-#include <time.h>
-#include <sys/mman.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <signal.h>
-#include <limits.h>
-#include <fcntl.h>
-#include <stdint.h>
-#include <sched.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
-
-#define LITMUS 0
-#define MC2 0
-#define MMDC_PROF 0
-
-#if LITMUS
-#include <litmus.h>
-#endif
-
-#if MMDC_PROF
-#include  "/media/speedy/litmus/tools/mmdc/mmdc.h"
-#endif
-
-#if LITMUS
-#define SET_UP LOAD_PARAMS SETUP_LITMUS
-#else
-#define SET_UP LOAD_PARAMS
-#endif
-
-#if MMDC_PROF
-#define LOAD_PARAMS LOAD_PARAMS_ITRL SETUP_MMDC
-#else
-#define LOAD_PARAMS LOAD_PARAMS_ITRL
-#endif
-
-// Store state globally so that the job can be outside main()
-// Arrays use float as a comprimise between overflow and size
-float *_rt_exec_time;
-#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;
-#define _RT_FILENAME_LEN 64
-
-#define LOAD_PARAMS_ITRL \
-    if (argc != 6) { \
-        fprintf(stderr, "Usage: %s <name> <loops> <my core> <runID> <save results?>\n", argv[0]);\
-        fprintf(stderr, " <loops> integer number of iterations. -1 for infitite.\n");\
-        fprintf(stderr, " <save results?> 1 to save results, 0 to discard.\n");\
-        fprintf(stderr, " <my core> UNUSED. Core is now auto-detected.\n");\
-        exit(1);\
-    }\
-    _rt_our_prog_name = argv[1];\
-    _rt_max_jobs = atol(argv[2]);\
-    _rt_core = sched_getcpu();\
-    _rt_run_id = argv[4];\
-    _rt_will_output = atoi(argv[5]);\
-    if (_rt_max_jobs < 0 && _rt_will_output != 0) {\
-        fprintf(stderr, "Infinite loops only supported when _rt_will_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);\
-    }\
-    _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);\
-    }\
-    _rt_jobs_complete = 0;\
-    mlockall(MCL_CURRENT || MCL_FUTURE);
-
-#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);
-
-#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 reservation_config res; \
-    res.id = gettid(); \
-    res.cpu = cpu; \
-    res.priority = LITMUS_HIGHEST_PRIORITY; \
-    /* we take over half the CPU time (these are ns) */ \
-    res.polling_params.budget = ms2ns(3000); \
-    res.polling_params.period = ms2ns(3000); \
-    res.polling_params.offset = 0; \
-    res.polling_params.relative_deadline = ms2ns(3000); \
-    /* Not 100% sure that we should use periodic polling */ \
-    if (reservation_create(PERIODIC_POLLING, &res) < 0) { \
-        perror("Unable to create reservation"); \
-        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 = cpu; \
-    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 \
-    struct mc2_task mc2_param; \
-    mc2_param.res_id = gettid(); \
-    mc2_param.crit = CRIT_LEVEL_A; \
-    if (set_mc2_task_param(gettid(), &mc2_param) < 0) { \
-        perror("Unable to set MC^2 task params"); \
-        exit(1); \
-    } \
-    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); \
-    } \
-    reservation_destroy(gettid(), rt_param.cpu);
-
-#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
-
-// Buffer timing result from a single job
-static void _rt_save_job_result() {
-    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);
-    }
-    if (_rt_jobs_complete > -1 && _rt_will_output) {
-        _rt_exec_time[_rt_jobs_complete] = _rt_end.tv_sec - _rt_start.tv_sec;
-        _rt_exec_time[_rt_jobs_complete] *= 1e9;
-        _rt_exec_time[_rt_jobs_complete] += _rt_end.tv_nsec - _rt_start.tv_nsec;
-#if MMDC_PROF
-        _rt_mmdc_read[_rt_jobs_complete] = mmdc_res.read_bytes;
-        _rt_mmdc_write[_rt_jobs_complete] = mmdc_res.write_bytes;
-#endif
-    }
-}
-
-// Save all buffered timing results to disk
-static void _rt_write_to_file() {
-    char fileName[_RT_FILENAME_LEN];
-    FILE *fp;
-    if (!_rt_will_output)
-        return;
-    munlockall();
-    strcpy(fileName, _rt_run_id);
-    strcat(fileName, ".txt");
-    fp = fopen(fileName, "a");
-    if (fp == NULL) {
-        perror("Unable to open _rt_will_output file");
-        exit(1);
-    }
-    // Same format as the paired results with "none" for unused fields
-    for (int i = 0; i < _rt_jobs_complete; i++){
-        fprintf(fp, "%s none %u none %ld %.f %s %d %.f %.f \n",
-        _rt_our_prog_name, _rt_core, _rt_max_jobs,
-        _rt_exec_time[i], _rt_run_id, i,
-#if MMDC_PROF
-        _rt_mmdc_read[i], _rt_mmdc_write[i]);
-#else
-        0.0, 0.0);
-#endif
-    }
-    fclose(fp);
-#if LITMUS
-    CLEANUP_LITMUS
-#endif
-}
-
-// 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
-    FLUSH_CACHES
-#if MMDC_PROF
-    /* This disables profiling, resets the counters, clears the overflow bit, and enables profiling */
-    start_mmdc_profiling(mmdc);
-#endif
-    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
-    _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_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 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);