Move the DIS benchmarks up a directory and update hardcoded paths

Note that this repo does not attempt to keep a copy of the original
DIS benchmark distributions. UNC real-time has another repo for that.

2 files changed, 328 insertions, 0 deletions

diff --git a/dis/Update/DISstressmarkRNG.h b/dis/Update/DISstressmarkRNG.h
new file mode 100644
index 0000000..4aa2620
--- /dev/null
+++ b/dis/Update/DISstressmarkRNG.h
@@ -0,0 +1,190 @@
+#include <math.h>
+
+#define IA 16807
+#define IM 2147483647
+#define AM (1.0/IM)
+#define IQ 127773
+#define IR 2836
+#define NTAB 32
+#define NDIV (1+(IM-1)/NTAB)
+#define EPS 1.2e-7
+#define RNMX (1.0-EPS)
+
+static long iy=0;
+static long iv[NTAB];
+static long iseed;
+
+int ABS(int x){
+  if (x>= 0) return x;
+  else
+    return (-x);
+}
+
+int sign(int x){
+  if (x >= 0) return 1;
+  else
+    return (-1);
+}
+
+int MAX(int x, int y){
+  if (x>= y) return x;
+  else
+    return y;
+}
+
+int MIN(int x, int y){
+  if (x<= y) return x;
+  else
+    return y;
+}
+
+void randInit(long idum)
+{
+  long j;
+  long k;
+
+  assert (idum <= 0);
+  assert (iy == 0);
+
+  iseed = idum;
+  if (-(iseed)<1){
+    iseed = 1;
+  }
+  else {
+    iseed = -(iseed);
+  }
+  for (j=NTAB+7; j>=0; j--){
+    k = (iseed)/IQ;
+    iseed = IA*(iseed-k*IQ)-IR*k;
+    if (iseed < 0){
+      iseed += IM;
+    }
+    if (j < NTAB){
+      iv[j] = iseed;
+    }
+  }
+  iy = iv[0];
+}
+
+float randNum()
+{
+  long j;
+  long k;
+  float temp;
+
+  assert (iy != 0);
+  
+  k = (iseed)/IQ;
+  iseed = IA*(iseed-k*IQ)-IR*k;
+
+  if (iseed < 0){
+    iseed += IM;
+  }
+  j = iy/NDIV; 
+  iy = iv[j];
+  iv[j] = iseed;
+
+  temp = AM * iy;
+
+  if (temp > RNMX){
+    return RNMX;
+  }
+  else {
+    return temp;
+  }
+}
+
+
+float randomFloat(float lowest_float, float highest_float)
+{
+ float value;
+ float range;
+
+assert (lowest_float < highest_float);
+
+range = highest_float - lowest_float;
+value = randNum()*(highest_float - lowest_float) + lowest_float;
+assert(value >= lowest_float);
+assert(value <= highest_float);
+
+return value;
+
+}
+
+float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon)
+{
+
+  double range;
+  float value;
+
+
+  assert (lowest_float < 0);
+  assert (highest_float > 0);
+  assert (epsilon > 0);
+  assert ((epsilon < -lowest_float) && (epsilon < highest_float));
+  
+  range = highest_float - lowest_float;
+  value = (randNum() * range)+lowest_float;
+  
+  if (ABS(value) < epsilon) 
+    {
+      if (value > 0) value = value + epsilon;
+      else if (value < 0) value = value - epsilon;
+      
+    }
+
+  assert (value >= lowest_float);
+  assert (value <= highest_float);
+
+  return value;
+}
+
+unsigned int randomUInt(int lowest_uint, int highest_uint)
+{
+  float range;
+  unsigned int value;
+  float temp;
+
+  range =(float)(highest_uint - lowest_uint + 1);
+  temp = randNum();
+  value =(unsigned int)( floor(temp * range) + lowest_uint); 
+
+  assert (value >= lowest_uint);
+  assert (value <= highest_uint);
+
+  return value;
+}
+
+unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint)
+{
+  float range;
+  unsigned int value;
+  float temp;
+
+  range =(float)(highest_uint - lowest_uint + 1);
+  value = 0;
+  while(value == 0){
+  temp = randNum();
+
+  value =(unsigned int)( floor(temp * range) + lowest_uint); 
+  }
+  
+  assert (value >= lowest_uint);
+  assert (value <= highest_uint);
+
+  return value;
+}
+
+int randInt(int lowest_uint,  int highest_uint)
+{
+  float range;
+  int value;
+  
+  range = highest_uint - lowest_uint + 1;
+  value = (int)(floor(randNum() * range) + lowest_uint);
+  
+  assert (value >= lowest_uint);
+  assert (value <= highest_uint);
+
+  return value;
+}                            
diff --git a/dis/Update/update.c b/dis/Update/update.c
new file mode 100644
index 0000000..1fd8197
--- /dev/null
+++ b/dis/Update/update.c
@@ -0,0 +1,138 @@
+/*
+ *  Sample code for the DIS Update Stressmark
+ *
+ * This source code is the completely correct source code based on 
+ * the example codes provided by Atlantic Aerospace Division, Titan 
+ * Systems Corporation, 2000.
+ * 
+ * If you just compile and generate the executables from this source 
+ * code, this code would be enough. However, if you wish to get a complete 
+ * understanding of this stressmark, it is strongly suggested that you
+ * read the Benchmark Analysis and Specifications Document Version 1.0
+ * before going on since the detailed comments are given in this documents.
+ * the comments are not repeated here.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include<assert.h>
+#include "DISstressmarkRNG.h"
+#include "extra.h"
+
+#define MIN_FIELD_SIZE 16
+
+#define MAX_FIELD_SIZE 16777216
+
+#define MIN_WINDOW_SIZE 1
+
+#define MAX_WINDOW_SIZE 15
+
+#define MIN_HOP_LIMIT 1
+
+#define MAX_HOP_LIMIT 4294967295U
+
+#define MIN_SEED -2147483647
+
+#define MAX_SEED -1
+
+/* 
+ *main() 
+ */
+   
+int main(int argc, char** argv){
+
+  unsigned int *field;
+  unsigned int f;
+  unsigned int index;
+  unsigned short int w;
+  unsigned int maxhops;
+  int seed;
+  time_t startTime;
+  unsigned int initial;
+  unsigned int minStop;
+  unsigned int maxStop;
+  unsigned int hops;
+  unsigned int l;
+
+  assert(fscanf(stdin, "%u %u %u %d %u %u %u", 
+        &f, &l, &maxhops, &seed, &initial, &minStop, &maxStop) == 7);
+
+  assert((f >= MIN_FIELD_SIZE) && (f <= MAX_FIELD_SIZE));
+  w = (unsigned int )l;
+  assert((w >= MIN_WINDOW_SIZE) && (w <= MAX_WINDOW_SIZE));
+  assert(w%2 == 1);
+  assert(f > w);
+  assert((maxhops >= MIN_HOP_LIMIT) && (maxhops <= MAX_HOP_LIMIT));
+  assert((seed >= MIN_SEED) && (seed <= MAX_SEED));
+  assert((initial >= 0) && (initial < f));
+  assert((minStop >= 0) && (minStop < f));
+  assert((maxStop >= 0) && (maxStop < f));
+
+  if ((field = (unsigned int *)malloc(f*sizeof(int))) == NULL)
+    return (-1);
+ 
+  randInit(seed);
+  for (l=0; l<f; l++){
+    field[l] = randInt(0, f-w);
+  }
+  
+  SET_UP
+  startTime = time(NULL);
+
+  hops = 0;
+  index = initial;
+
+  while ((hops < maxhops) &&
+        (!((index >= minStop) &&
+           (index < maxStop)))){    
+    int sum;
+
+    unsigned int ll, lll;
+    unsigned int max, min;
+    unsigned int partition;
+    unsigned int high;
+    if (hops % 100 == 0) {START_LOOP} // These loops are too quick to sample individually
+    max = MAX_FIELD_SIZE;
+    min = 0;
+    high = 0;
+    sum = 0;
+
+    for (ll=0; ll<w; ll++){
+      unsigned int balance;
+      unsigned int x;
+      x = field[index+ll];
+      sum += x;
+
+      if (x > max) high++;
+      else if (x >min){ /* start else* */
+        partition = x;
+        balance = 0;
+        for (lll=ll+1; lll<w; lll++){
+          if (field[index+lll] > partition) balance++;
+        } 
+        if (balance+high == w/2) break;
+        else if (balance+high>w/2){
+          min = partition;
+        }/* end if */
+        else{
+          max = partition;
+          high++;
+        } /* end else */
+      }
+      if (min == max) break;
+    }/* end else* */
+    field[index] = sum % (f-w);
+    index = (partition+hops)%(f-w);
+    hops++;
+    if (hops % 100 == 0) {STOP_LOOP} // These loops are too quick to sample individually
+  }/* end for loop */
+
+  startTime = time(NULL) - startTime;
+
+  fprintf(stdout, "%u hops\n", hops);
+  fprintf(stderr, "total time = %u seconds.\n", (unsigned int)startTime);
+  free(field);
+  WRITE_TO_FILE
+  return(1);
+}