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, 500 insertions, 0 deletions

diff --git a/extra.h b/extra.h
new file mode 100644
index 0000000..3215951
--- /dev/null
+++ b/extra.h
@@ -0,0 +1,500 @@
+/**
+ * Copyright 2019 Sims Hill Osborne and 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
+
+#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
+// 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;
+#endif
+
+static void _rt_load_params_itrl(int argc, char **argv) {
+#ifdef PAIRED
+    if (argc != 8) {
+        fprintf(stderr, "Usage: %s <name> <loops> <my core> <other core> <other name> <runID> <lockID>", argv[0]);
+        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> UNUSED. Core is now auto-detected.\n");
+        fprintf(stderr, " <other core> integer for logging. Core of paired task.\n");
+        fprintf(stderr, " <other name> string for logging. Name of paired task.\n");
+        fprintf(stderr, " <runID> string to append with .txt to yield output file name.\n");
+        fprintf(stderr, " <lockID> 1 to indicate this is pair member 1, otherwise pair member 2.\n");
+        exit(1);
+    }
+#else
+    if (argc != 6) {
+        fprintf(stderr, "Usage: %s <name> <loops> <my core> <runID> <save results?>\n", argv[0]);
+        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> UNUSED. Core is now auto-detected.\n");
+        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");
+        exit(1);
+    }
+#endif
+    _rt_our_prog_name = argv[1];
+    _rt_max_jobs = atol(argv[2]);
+    _rt_core = sched_getcpu();
+#ifdef PAIRED
+    _rt_other_core = argv[4];
+    _rt_other_prog_name = argv[5];
+    _rt_run_id = argv[6];
+    _rt_lock_id = atoi(argv[7]);
+    // The paired version doesn't support disabling output (legacy compatibility)
+    _rt_will_output = 1;
+#else
+    _rt_other_core = "none";
+    _rt_other_prog_name = "none";
+    _rt_run_id = argv[4];
+    _rt_will_output = atoi(argv[5]);
+#endif /* PAIRED */
+    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);
+    }
+#ifdef PAIRED
+    _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);
+    }
+    _rt_first_sem = sem_open("/_libextra_first_sem", O_CREAT, 644, 0);
+    _rt_second_sem = sem_open("/_libextra_second_sem", O_CREAT, 644, 0);
+    if (_rt_first_sem == SEM_FAILED || _rt_second_sem == SEM_FAILED) {
+        perror("Error while creating semaphores");
+        exit(1);
+    }
+    int barrier_file = shm_open("/_libextra_barrier", O_CREAT | O_RDWR, 644);
+    if (barrier_file == -1) {
+        perror("Error while creating shared memory for barrier synchronization");
+        exit(1);
+    }
+    if (ftruncate(barrier_file, 1) == -1) {
+        perror("Error while setting size of shared memory for barrier synchronization");
+        exit(1);
+    }
+    _rt_barrier = mmap(NULL, 1, PROT_WRITE, MAP_SHARED, barrier_file, 0);
+    if (_rt_barrier == MAP_FAILED) {
+        perror("Error while mapping shared memory for barrier synchronization");
+        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);
+}
+#define LOAD_PARAMS_ITRL _rt_load_params_itrl(argc, argv);
+
+#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) { \