2 files changed, 481 insertions, 4 deletions

diff --git a/SD-VBS/benchmarks/tracking/src/c/script_tracking.c b/SD-VBS/benchmarks/tracking/src/c/script_tracking.c
index 2938126..c0af2d7 100644
--- a/SD-VBS/benchmarks/tracking/src/c/script_tracking.c
+++ b/SD-VBS/benchmarks/tracking/src/c/script_tracking.c
@@ -93,9 +93,8 @@ int main(int argc, char* argv[])
 
     I2D* images[counter];
     /** Read input image **/
-    for(count=1; count<=counter; count++)
-    {
-        /** Read image **/
+    for(count=1; count<=counter; count++){
+        /** Read Image **/
         scanf("%s", im1);
         images[count - 1] = readImage(im1);
         if(count == 1) Ic = readImage(im1);
@@ -227,7 +226,6 @@ int main(int argc, char* argv[])
             fFreeHandle(newpoints);
         }
     }
-
 #ifdef CHECK
     /* Self checking */
     {
diff --git a/SD-VBS/common/c/extra.h b/SD-VBS/common/c/extra.h
new file mode 100644
index 0000000..8c67b33
--- /dev/null
+++ b/SD-VBS/common/c/extra.h
@@ -0,0 +1,479 @@
+/**
+ * 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
+
+#define LITMUS 1
+#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));\