DIS fixes used for (rejected) RTSS'20 submission

- All: Output times to stderr and nothing to stdout
- Field, Update, Pointer: change definition of a job to match other
  stressmark execution times more closely
- Matrix: move all allocations into main()
- Update: Use volatile to prevent computations from being optimized out
- Transitive: Use volatile to prevent computations from being optimized out
- Neighborhood: Use working version of drawLineSegment from original DIS
  sample code

1 files changed, 53 insertions, 108 deletions

diff --git a/dis/Neighborhood/utili.h b/dis/Neighborhood/utili.h
index 2a8e2a0..5b54d9b 100644
--- a/dis/Neighborhood/utili.h
+++ b/dis/Neighborhood/utili.h
@@ -56,81 +56,23 @@ typedef struct {
 
 typedef short int Pixel; /* short int;*/
 
+typedef struct {
+  int           numColumns;     /* number of columns in image */
+  int           numRows;        /* number of rows in image */
+  Pixel         maxImageValue;  /* max legal image value */
+  Pixel         *data;          /* data pointer */
+} Image;
 
-void drawLineSegment(Pixel *image,
-                     Coord startPoint,
-                     Coord endPoint,
-                     int startValue,
-                     int endValue,
-                     int thickness,
-                     int dimension)
-  {
-    int changeColumn, changeRow;
-    int delta;
-    int column, row;
-    float value, valueDelta;
-    int t;
-
-    changeColumn = endPoint.column - startPoint.column;
-    changeRow = endPoint.row - startPoint.row;
-    
-    assert((changeRow != 0) || (changeColumn != 0));
-
-    column = startPoint.column;
-    row = startPoint.row;
-    value = startValue;
-
-    if (ABS(changeColumn) > ABS(changeRow)){
-      valueDelta = ((float) endValue - startValue)/
-                    ((float) ABS(changeColumn));
-      delta = 2*ABS(row) - ABS(column);
-      for (column = startPoint.column;
-           column == endPoint.column+sign(changeColumn);
-           column += sign(changeColumn)){
-        for (t = MAX(0, row-thickness/2);
-             t < MIN(dimension, row+thickness - thickness/2);
-             t++)
-          image[t*dimension + column] = (int)value;
-        value += valueDelta;
-        if (delta >= 0){
-          row += sign(changeRow);
-          delta -= 2*ABS(changeColumn);
-        }
-        column += sign(changeColumn);
-        delta += 2*ABS(changeRow);
-      }
-    }
-    else {
-      valueDelta = ((float) endValue - startValue)/
-                   ((float) ABS(changeRow));
-      delta = 2* ABS(column) - ABS(row);
-      for (row = startPoint.row;
-           row == endPoint.row + sign(changeRow);
-           row += sign(changeRow)){
-        for (t = MAX(0, column-thickness/2);
-             t < MIN(dimension, row + thickness - thickness/2);
-             t++)
-          image[row*dimension + t] = (int)value;
-        if (delta >= 0){
-          column += sign(changeColumn);
-            delta -= 2*ABS(changeRow);
-        }
-        row += sign(changeRow);
-        delta += 2*ABS(changeColumn);
-      }
-    }
-    return;
-  }
-
-
+// For correct implementation of drawLineSegment
+#include "initializeImage.c"
 
-Pixel *createImage (int dimension,
+Pixel *createImage (Pixel *image,
+            int dimension,
                     Pixel maxPixel,
                     int numberLines,
                     int minThickness,
                     int maxThickness)
   {
-    Pixel *image;
     int i;
     
     Coord startPoint;
@@ -138,9 +80,12 @@ Pixel *createImage (int dimension,
     int thickness;
     int startValue;
     int endValue;
+    Image img;
+    img.numColumns = dimension;
+    img.numRows = dimension;
+    img.maxImageValue = maxPixel;
+    img.data = image;
 
-    image = (Pixel *)malloc(sizeof(Pixel) * dimension * dimension);
-    assert (image != NULL);
     for (i=0; i<dimension*dimension; i++){
       image[i] = 0;
     }
@@ -154,6 +99,7 @@ Pixel *createImage (int dimension,
       startPoint.column = (int) temp % dimension;
       prev = temp;
 
+      // Make sure that the end is different than the start
       while((temp = randomUInt(0, dimension*dimension -1)) == prev);
 
       endPoint.row = (int) temp/dimension;
@@ -163,11 +109,11 @@ Pixel *createImage (int dimension,
       startValue = randomUInt(MIN_PIXEL, maxPixel);
       endValue = randomUInt(MIN_PIXEL, maxPixel);
 
-      drawLineSegment(image, startPoint, endPoint,
-                      startValue, endValue, thickness, dimension);
+      drawLineSegment(&startPoint, &endPoint,
+                      startValue, endValue, thickness, &img);
     }
     return(image);
-  }
+}
 
 
 void calcEntropyEnergy(
@@ -214,10 +160,10 @@ void calcEntropyEnergy(
       columnHigh = dimension;
     }
     else
-      {
-        columnLow = 0;
-        columnHigh = dimension - dx;
-      }
+    {
+      columnLow = 0;
+      columnHigh = dimension - dx;
+    }
 
     totalNumPixels = 0;
     value0RowOffset = rowLow * dimension;
@@ -225,27 +171,27 @@ void calcEntropyEnergy(
 
     for (rowIndex = rowLow; rowIndex<rowHigh; rowIndex++){
       for (columnIndex= columnLow; columnIndex<columnHigh;
-           columnIndex++){
-        int value0;
-        int value1;
-        int binIndex;
+           columnIndex++){
+        int value0;
+        int value1;
+        int binIndex;
 
-        rowForPixelAtDistance = rowIndex + dy;
-        columnForPixelAtDistance = columnIndex + dx;
+        rowForPixelAtDistance = rowIndex + dy;
+        columnForPixelAtDistance = columnIndex + dx;
 
-        value0 = *(image + value0RowOffset + columnIndex);
-        value1 = *(image + value1RowOffset + 
-                   columnForPixelAtDistance);
+        value0 = *(image + value0RowOffset + columnIndex);
+        value1 = *(image + value1RowOffset + 
+               columnForPixelAtDistance);
 
-        binIndex = value0 + value1 - 2*MIN_PIXEL;
-        assert((binIndex >= 0) && (binIndex < numBins));
-        sumHist[binIndex] += 1;
-        binIndex = value0 - value1 + maxPixel - MIN_PIXEL;
+        binIndex = value0 + value1 - 2*MIN_PIXEL;
+        assert((binIndex >= 0) && (binIndex < numBins));
+        sumHist[binIndex] += 1;
+        binIndex = value0 - value1 + maxPixel - MIN_PIXEL;
 
-        assert((binIndex >= 0) && (binIndex < numBins));
+        assert((binIndex >= 0) && (binIndex < numBins));
 
-        diffHist[binIndex] += 1;        
-        totalNumPixels += 1;
+        diffHist[binIndex] += 1;
+        totalNumPixels += 1;