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

3 files changed, 434 insertions, 112 deletions

diff --git a/dis/Neighborhood/initializeImage.c b/dis/Neighborhood/initializeImage.c
new file mode 100644
index 0000000..a030a1a
--- /dev/null
+++ b/dis/Neighborhood/initializeImage.c
@@ -0,0 +1,371 @@
+/* Copyright 2000, Atlantic Aerospace Electronics Corp */
+/*
+ * Name:    initializeImage
+ * Input:   dimension      dimension of image
+ *          maxImageValue  max legal image value
+ *          numberLines    number line segments for image
+ *          minThickness   min thickness for line segment
+ *          maxThickness   max thickness for line segment
+ * Output:  image          image initialized
+ * Comment: This routine allocates memory to store an image and fills
+ *          in the image structure except for the image data.  The 
+ *          pixels of the image are of type ShortInt. If there
+ *          is an error allocating memory, than a NULL pointer is 
+ *          returned. Assumptions: the image dimensions given are 
+ *          positive.
+ * Calls:   errorMessage()
+ * (system) malloc()
+ *          free()
+ * Return:  image structure pointer (partially filled in - no data -  
+ *                                   and allocated)
+ *          NULL (error allocating memory for image/image structure)
+ *
+ * Revision   History:
+ * Date       Name         Revision
+ * ---------  -----------  -----------------------------
+ * 25May2000  May Leung    Created
+ * 05Jun2000  May Leung    Add maxImageValue as input to initializeImage()
+ * XXMay2020 Joshua Bakita Commented out significant portions to allow this to
+ *                         be #include(d) elsewhere.
+ */
+typedef int Int;
+typedef short int ShortInt;
+typedef float Float;
+void drawRowPoint (Int   value,
+              Int   pointThickness,
+              Int   row,
+              Int   column,
+              Image *image);
+void drawColumnPoint (Int   value,
+                 Int   pointThickness,
+                 Int   row,
+                 Int   column,
+                 Image *image);
+#define MIN_RANDOM_VALUE 0
+#if 0
+#ifndef NDEBUG
+#include <stdio.h>
+#endif /* NDEBUG */
+#include <assert.h>                         /* define assert() */
+#include <stdlib.h>                         /* define NULL, malloc(), free() */
+#include "stressmark.h"                     /* system include file */
+#include "neighborhood.h"                   /* define types, structures, etc  */
+#include "errorMessage.h"                   /* define errorMessage() */
+#include "random.h"                         /* define randomUInt() */
+#include "initializeImage.h"                /* define initializeImage() */
+
+Image *initializeImage (Int dimension,     /* dimension of image */
+                        Int maxImageValue, /* max legal image value */
+                        Int numberLines,   /* number line segments for image */
+                        Int minThickness,  /* min thickness for line segment */
+                        Int maxThickness)  /* max thickness for line segment */
+{ /* beginning of initializeImage() */
+
+  Image    *image;              /* pointer to image structure to allocate */   
+  ShortInt *data;               /* pointer to the data for the image structure*/
+  Int      lineIndex;           /* loop index variable for line segments */    
+  Int      pixelIndex;          /* loop index variable for pixels */           
+  Int      limit;               /* limit for loop using pixelIndex */          
+                                                                               
+  Coord    startPoint;          /* starting point for a line segment */        
+  Coord    endPoint;            /* ending point for a line segment */          
+  Int      lineThickness;       /* thickness for a line segment */
+  Int      startValue;          /* starting value for a line segment */        
+  Int      endValue;            /* ending value for a line segment */          
+
+  /*
+   * Assert the assumptions that the number of columns and number of rows
+   * are positive values.  No test on the maximum possible value is done since
+   * numColumns and numRows are of type Int and the maximum value of an Int
+   * type is possible.
+   */
+  assert(dimension > 0);
+  assert(numberLines > 0);
+  assert((minThickness > 0) && (minThickness < dimension));
+  assert((maxThickness > 0) && (maxThickness < dimension));
+  assert(minThickness <= maxThickness);
+
+  /* create image */
+  image = createImage(dimension,dimension,maxImageValue);
+  if (image == NULL) {
+    return(NULL);
+  } /* end error check from createImage */
+
+  /* zero out the image */
+  limit = dimension * dimension;
+  data = image->data;
+  for (pixelIndex = 0; pixelIndex < limit; pixelIndex++) {
+    *data++ = 0;
+  } /* end for loop */
+
+  /*
+   * Populate the image with line segments where the endpoints, values, and 
+   * thickness of each line segment are randomly generated.
+   */
+  for (lineIndex = 0; lineIndex < numberLines; lineIndex++) {
+    randomImageLocation(image, &startPoint);
+    randomImageLocation(image, &endPoint);
+    lineThickness = randomUInt(minThickness,maxThickness);
+    startValue = randomUInt(MIN_RANDOM_VALUE, maxImageValue);
+    endValue = randomUInt(MIN_RANDOM_VALUE, maxImageValue);
+
+    /* add line segment to the image */
+    drawLineSegment(&startPoint, &endPoint, startValue, endValue, lineThickness,
+                    image);
+
+    } /* end for loop */
+
+  return(image);
+} /* end initializeImage() */
+#endif
+
+/*
+ * drawLineSegment() This routine draws a line segment into the given image
+ *                   starting at the coordinate startPoint and ending at the
+ *                   coordinate endPoint.  The values along this line segment
+ *                   vary linearly from the given starting value startValue to
+ *                   the end value endValue and have a lineThickness associated
+ *                   to it.
+ *
+ * This routine is modeled after the routine draw_line() from 
+ * "Practical Computer Vision using C", by J.R. Parker, Wiley, 1994, pp 114-116.
+ * It has been enhanced to have values on the line segment vary and to have
+ * a thickness to the line segment.
+ */
+void drawLineSegment (Coord *startPoint,   /* starting point for line segment */
+                      Coord *endPoint,     /* ending point for line segment */  
+                      Int   startValue,    /* starting value for line segment */
+                      Int   endValue,      /* ending value for line segment */  
+                      Int   lineThickness, /* thickness for line segment */     
+                      Image *image)        /* image to add line segment to */   
+{ /* beginning of drawLineSegment() */
+
+  /*
+   * Modeled after draw_line() from "Practical Computer Vision using C",
+   * by J.R. Parker, Wiley, 1994, pp 114-116.  Enhanced to have values
+   * on the line segment vary and to have a thickness to the line segment.
+   * The value along the line segment is kept in a float variable so that 
+   * fractional increments along the line segment can accumulate to integer
+   * values.
+   */
+  Int   changeColumn, changeRow; /* change along line segment in col/row */     
+  Int   absColumn, absRow;       /* absolute value of change in col/row */      
+  Int   signColumn, signRow;     /* sign of change along line segment col/row */
+  Int   delta;                   /* increment alone line segment */             
+  Int   column, row;             /* column & row of coordinate along line seg */
+  Float value, valueDelta;       /* value & value change along line segment */  
+
+//  assert(validImage(image));
+  assert(startPoint != NULL);
+  assert(endPoint != NULL);
+
+#ifdef DEBUG0
+  fprintf(stderr,
+          "drawLineSegment: start row %6ld col %6ld\tend row %6ld col %6ld\n",
+          startPoint->row,startPoint->column,endPoint->row,endPoint->column);
+  fprintf(stderr,"                 startVal %6ld endVal %6ld thickness %6ld\n",
+          startValue, endValue, lineThickness);
+#endif /* DEBUG0 */
+
+  changeColumn = endPoint->column - startPoint->column;
+  if (changeColumn < 0) {
+    absColumn  = - changeColumn;
+    signColumn = - 1;
+  } /* end changeColumn < 0 */
+  else { /* changeColumn >= 0 */
+    absColumn  = changeColumn;
+    signColumn = 1;
+  } /* end changeColumn >= 0 */
+  absColumn *= 2;
+
+  changeRow = endPoint->row - startPoint->row;
+  if (changeRow < 0) {
+    absRow  = - changeRow;
+    signRow = - 1;
+  } /* end changeRow < 0 */
+  else { /* changeRow >= 0 */