Reorganize and commit all the modified TACLeBench code and run scripts

4 files changed, 361 insertions, 0 deletions

diff --git a/baseline/source/dijkstra/ChangeLog.txt b/baseline/source/dijkstra/ChangeLog.txt
new file mode 100644
index 0000000..f96350b
--- /dev/null
+++ b/baseline/source/dijkstra/ChangeLog.txt
@@ -0,0 +1,44 @@
+File: dijkstra.c
+Original provenience: network section of MiBench
+
+2015-11-30:
+- Replaced "NULL" with "0", remove #include of glibc_common.h
+- Removed commented code referring to variable "qKill"
+- Made ch, i, iPrev, iNode, iCost and iDist local variables
+- Stripped (inconsistently applied) Hungarian notation, replaced
+  prefix "q" with prefix "queue" for global variables, renamed
+  "next_in" to "queueNext" and "qNew" to "newItem"
+- Initialize queueHead statically (like queueCount and queueNext)
+- Prefixed all functions and global variables with "dijkstra_",
+  renaming "dijkstra" to "dijkstra_find"
+- Calculate a checksum in dijkstra_main, return its value in new
+  function dijkstra_return
+- Added (empty) function dijkstra_init and a main function
+- Reordered functions in source code: initialization- and
+  return-value-related functions first, followed by algorithm core
+  functions, followed by main functions
+- Added function prototypes
+- Applied code formatting with astyle as in the example
+- Added general TACLeBench header to beginning of source code
+
+2016-03-15:
+- Return 0 if checksum is as expected, -1 otherwise
+- Make all initializations explicit
+- Touch input matrix with volatile to rule out optimizations
+- Add entrypoint pragma
+
+2016-06-14:
+- Removed cast to make C++ compiler happy
+
+Files: input.h, input.c
+Original provenience: network section of MiBench
+
+2015-11-30:
+- Prefix global variable "AdjMatrix" with "dijkstra_"
+- Applied code formatting with astyle as in the example
+
+File: glibc_common.h
+Original provenience: network section of MiBench
+
+2015-11-30:
+- Removed file
diff --git a/baseline/source/dijkstra/dijkstra.c b/baseline/source/dijkstra/dijkstra.c
new file mode 100644
index 0000000..af86ea6
--- /dev/null
+++ b/baseline/source/dijkstra/dijkstra.c
@@ -0,0 +1,204 @@
+/*
+
+  This program is part of the TACLeBench benchmark suite.
+  Version V 2.0
+
+  Name: dijkstra
+
+  Author: unknown
+
+  Function: dijkstra finds the shortest path between nodes in a graph
+
+  Source: network section of MiBench
+
+  Changes: Made some variables local, compute checksum
+
+  License: GPL
+
+*/
+
+#include "../extra.h"
+#include "input.h"
+
+/*
+  Definitions of symbolic constants
+*/
+#define NONE 9999
+#define OUT_OF_MEMORY -1
+#define QUEUE_SIZE 1000
+
+/*
+  Type declarations
+*/
+struct _NODE {
+  int dist;
+  int prev;
+};
+
+struct _QITEM {
+  int node;
+  int dist;
+  int prev;
+  struct _QITEM *next;
+};
+
+/*
+  Global variable definitions
+*/
+struct _NODE dijkstra_rgnNodes[NUM_NODES];
+
+int dijkstra_queueCount;
+int dijkstra_queueNext;
+struct _QITEM *dijkstra_queueHead;
+struct _QITEM dijkstra_queueItems[QUEUE_SIZE];
+
+int dijkstra_checksum = 0;
+
+/*
+  Forward declaration of functions
+*/
+void dijkstra_init( void );
+int dijkstra_return( void );
+int dijkstra_enqueue( int node, int dist, int prev );
+void dijkstra_dequeue( int *node, int *dist, int *prev );
+int dijkstra_qcount( void );
+int dijkstra_find( int chStart, int chEnd );
+void dijkstra_main( void );
+//int main( void );
+
+void dijkstra_init( void )
+{
+  int i, k;
+  volatile int x = 0;
+  _Pragma( "loopbound min 100 max 100" )
+  for ( i = 0; i < NUM_NODES; i++ ) {
+    _Pragma( "loopbound min 100 max 100" )
+    for ( k = 0; k < NUM_NODES; k++ ) {
+      dijkstra_AdjMatrix[i][k] ^= x;
+    }
+  }
+
+  dijkstra_queueCount = 0;
+  dijkstra_queueNext = 0;
+  dijkstra_queueHead = ( struct _QITEM * )0;
+
+  dijkstra_checksum = 0;
+}
+
+int dijkstra_return( void )
+{
+  return ( ( dijkstra_checksum == 25 ) ? 0 : -1 );
+}
+
+int dijkstra_enqueue( int node, int dist, int prev )
+{
+  struct _QITEM *newItem = &dijkstra_queueItems[dijkstra_queueNext];
+  struct _QITEM *last = dijkstra_queueHead;
+
+  if ( ++dijkstra_queueNext >= QUEUE_SIZE )
+    return OUT_OF_MEMORY;
+  newItem->node = node;
+  newItem->dist = dist;
+  newItem->prev = prev;
+  newItem->next = 0;
+
+  if ( !last )
+    dijkstra_queueHead = newItem;
+  else {
+    /* TODO: where does this magic loop bound come from? */
+    _Pragma( "loopbound min 0 max 313" )
+    while ( last->next )
+      last = last->next;
+    last->next = newItem;
+  }
+  dijkstra_queueCount++;
+  return 0;
+}
+
+void dijkstra_dequeue( int *node, int *dist, int *prev )
+{
+  if ( dijkstra_queueHead ) {
+    *node = dijkstra_queueHead->node;
+    *dist = dijkstra_queueHead->dist;
+    *prev = dijkstra_queueHead->prev;
+    dijkstra_queueHead = dijkstra_queueHead->next;
+    dijkstra_queueCount--;
+  }
+}
+
+int dijkstra_qcount( void )
+{
+  return ( dijkstra_queueCount );
+}
+
+int dijkstra_find( int chStart, int chEnd )
+{
+  int ch;
+  int prev, node;
+  int cost, dist;
+  int i;
+
+  _Pragma( "loopbound min 100 max 100" )
+  for ( ch = 0; ch < NUM_NODES; ch++ ) {
+    dijkstra_rgnNodes[ch].dist = NONE;
+    dijkstra_rgnNodes[ch].prev = NONE;
+  }
+
+  if ( chStart == chEnd ) {
+  } else {
+    dijkstra_rgnNodes[chStart].dist = 0;
+    dijkstra_rgnNodes[chStart].prev = NONE;
+
+    if ( dijkstra_e