Commit old version of extra.h

1 files changed, 208 insertions, 0 deletions

diff --git a/rtss19/extra.h b/rtss19/extra.h
new file mode 100644
index 0000000..f089373
--- /dev/null
+++ b/rtss19/extra.h
@@ -0,0 +1,208 @@
+#include <time.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <limits.h>
+#include <fcntl.h>
+#include <semaphore.h>
+
+// Benchmarks use SET_UP, START_LOOP, STOP_LOOP, and WRITE_TO_FILE
+#define SET_UP if (argc < 8) {\
+        printf("Usage: %s <name> <runs> <my core> <other core> <other program> <runID> <lockID>", argv[0]);\
+        exit(1);\
+    }\
+    char * thisProgram = argv[1];\
+    unsigned int maxJobs = atoi(argv[2]);\
+    char * thisCore = argv[3];\
+    char * otherCore = argv[4];\
+    char * otherProgram = argv[5];\
+    char * runID = argv[6];\
+    int lockID = atoi(argv[7]);\
+    struct timespec start, end;\
+    unsigned int jobsComplete = 0;\
+    long * startS = malloc(sizeof(long) *maxJobs);\
+    long * startN = malloc(sizeof(long) *maxJobs);\
+    long * endS = malloc(sizeof(long) *maxJobs);\
+    long * endN = malloc(sizeof(long) *maxJobs);\
+    char * bigArray;\
+    char fileName[strlen(runID) + 5];\
+    strcpy(fileName, runID);\
+    strcat(fileName, ".txt");\
+    mlockall(MCL_CURRENT || MCL_FUTURE);\
+    sem_t *firstSem=sem_open("/firstTacleSem", O_CREAT, 644, 0);\
+    if (firstSem == SEM_FAILED) {\
+        perror("Error opening/creating first semaphore");\
+        exit(1);\
+    }\
+    sem_t *secondSem=sem_open("/secondTacleSem", O_CREAT, 644, 0);\
+    if (secondSem == SEM_FAILED) {\
+        perror("Error opening/creating second semaphore");\
+        exit(1);\
+    }\
+    int barrier_file = shm_open("/TacleBarrier", O_CREAT | O_RDWR, 644);\
+    if (barrier_file == -1) {\
+        perror("Error creating shared memory");\
+        exit(1);\
+    }\
+    /* This sets our shared file to be one byte of '\0'*/ \
+    if (ftruncate(barrier_file, 1) == -1) {\
+        perror("Error setting size of shared memory");\
+        exit(1);\
+    }\
+    char * barrier = mmap(NULL, 1, PROT_WRITE, MAP_SHARED, barrier_file, 0);\
+    if (barrier == MAP_FAILED) {\
+        perror("Error mapping shared memory");\
+        exit(1);\
+    }\
+    int error;\
+    int val;
+
+#define SAVE_RESULTS if (jobsComplete > 0){\
+            startS[jobsComplete]=start.tv_sec;\
+            startN[jobsComplete]=start.tv_nsec;\
+            endS[jobsComplete]=end.tv_sec;\
+            endN[jobsComplete]=end.tv_nsec;}
+
+#define WRITE_TO_FILE {\
+    munlockall();\
+    FILE *fp = fopen(fileName, "a");\
+    if (fp == NULL) {\
+        perror("Error opening file. \n");\
+        exit(1);\
+    }\
+    for(jobsComplete=0; jobsComplete<maxJobs; jobsComplete++){\
+        fprintf(fp, "%s %s %s %s %d %ld %ld %ld %ld %s %d \n",\
+        thisProgram, otherProgram, thisCore, otherCore, maxJobs,\
+        startS[jobsComplete], startN[jobsComplete], endS[jobsComplete], endN[jobsComplete],\
+        runID, jobsComplete);\
+    }\
+    fclose(fp);\
+    /* Clean up the barrier synchronization shared memory */\
+    munmap(barrier, 1);\
+    shm_unlink("/TacleBarrier");\
+    free(startS);\
+    free(startN);\
+    free(endS);\
+    free(endN);\
+}
+
+// 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;\
+    fread(&dummy, 1, 1, fp);\
+    fclose(fp);
+
+//invoke start timer twice, stop timer to make sure timer and vars are in cache
+#define START_TIMER clock_gettime(CLOCK_MONOTONIC, &start);
+    //clock_gettime(CLOCK_MONOTONIC, &end);\
+    //clock_gettime(CLOCK_MONOTONIC, &start);\
+        
+#define STOP_TIMER clock_gettime(CLOCK_MONOTONIC, &end);
+
+#define LOCK2_LOCKED //printf("Lock2 locked. \n");
+#define LOCK1_LOCKED //printf("Lock1 locked. \n");
+#define LOCK1_UNLOCKED //printf("Lock1 unlocked. \n");
+#define LOCK2_UNLOCKED //printf("Lock2 unlocked. \n");
+
+//check value of sem
+//if sem=0, unlock
+//if sem=1, spin
+
+#define SLEEP nanosleep((const struct timespec[]){{0, 1000000}}, NULL);
+
+//#define SAFE_UNLOCK(whichSem) sem_getvalue(whichSem, &val); while(val==1) {  printf("Attpt. to unlock unlocked lock. \n"); sem_getvalue(whichSem, &val);  } sem_post(whichSem);
+
+
+//#define SAFE_UNLOCK(whichSem) sem_post(whichSem); SLEEP ; printf("Used SAFE_UNLOCK. \n");
+
+#define FIRST_UNLOCK if (lockID == 1) {\
+        if (sem_post(secondSem) != 0) {\
+            perror("Unable to unlock second semaphore");\
+            exit(1);\
+        }\
+    } \
+    else {\
+        if (sem_post(firstSem) != 0) {\
+            perror("Unable to unlock first semaphore");\
+            exit(1);\
+        }\
+    } \
+
+#define FIRST_LOCK if (lockID == 1) {\
+        if (sem_wait(firstSem) != 0) {\
+            perror("Unable to wait on first semaphore");\
+            exit(1);\
+        }\
+    }\
+    else {\
+        if (sem_wait(secondSem) != 0) {\
+            perror("Unable to wait on second semaphore");\
+            exit(1);\
+        }\
+    }
+
+
+#define SECOND_UNLOCK   if (lockID==1){sem_post(fourthSem) ; }\
+            else {sem_post(thirdSem) ; }
+
+#define SECOND_LOCK if (lockID==1){sem_wait(thirdSem); }\
+            else {sem_wait(fourthSem); }
+
+#define BARRIER_SYNC if (__sync_bool_compare_and_swap(barrier, 0, 1)) {\
+        while (!__sync_bool_compare_and_swap(barrier, 0, 0)) {};\
+    }\
+    else {\
+        __sync_bool_compare_and_swap(barrier, 1, 0);\
+    }
+
+
+//#define SECOND_UNLOCK if (lockID==1){sem_post(firstSem) ; LOCK1_UNLOCKED }\
+            else {sem_post(secondSem) ; LOCK2_UNLOCKED }
+
+//#define SECOND_LOCK   if (lockID==1){sem_wait(secondSem); LOCK2_LOCKED }\
+            else {sem_wait(firstSem); LOCK1_LOCKED }
+
+
+#define START_LOOP FIRST_UNLOCK FIRST_LOCK FLUSH_CACHES BARRIER_SYNC START_TIMER
+
+
+/*
+First task to reach TRY_CACHE will fail, but unlock the lock.
+Second task will get the lock and kill the cache.
+Lock remains in place until this point is reached again in code.
+*/
+
+//#define TRY_CACHE if (sem_trywait(cacheSem)==0){KILL_CACHE}\
+        else {sem_post(cacheSem);}
+
+//#define STOP_LOOP STOP_TIMER SAVE_RESULTS //TRY_CACHE
+
+#define STOP_LOOP STOP_TIMER SAVE_RESULTS //SECOND_UNLOCK SECOND_LOCK KILL_CACHE
+
+
+/*
+Intended structure
+
+main
+SET_UP
+notice that STOP LOOP negates the ++ if outout=0
+for (jobsComplete=-1; jobsComplete<maxJobs; jobsComplete++){
+        KILL_CACHE
+        START_TIMER
+        tacleInit();
+        tacleMain();
+        STOP_TIMER
+        SAVE_RESULTS
+}
+WRITE_TO_FILE
+tacleReturn 
+*/