Matlab version

.gitignore

@@ -7,3 +7,8 @@ rodinia_2.4/
 build/
 *.pyc
 dls14empiricalJS/
+builds/
+runs/
+node_modules/
+*.csv
+*.sublime*

.wu/README.md

@@ -0,0 +1 @@
+This is a hidden directory to maintain configuration information specific to a particular installation of the Ostrich Benchmark Suite, following the Wu Wei Benchmarking Toolking standards (https://github.com/Sable/wu-wei-benchmarking-toolkit).

README.md

@@ -12,6 +12,14 @@ We aim to make the suite:
  6. **Fast** by making the setup (data generation and loading) and teardown as quick as possible so that most of the time is spent in the core computation in every language;
  7. **Small** by minimizing the amount of data needed to download the suite;
  8. **Simple** by minimizing the amount of external dependencies and tools required to run the suite;
+
+Dependencies
+------------------------
+Although we tried our best to minimize external dependencies, the suite still depends on the following external tools:
+ 1. Node.js
+ 2. Python/Numpy/Scipy
+
+
 
 Getting Started
 ------------------------

benchmarks/lud/README.md

@@ -0,0 +1,3 @@
+Dependencies:
+
+Python/Numpy/Scipy (Suggested: [Enthought Canopy](https://store.enthought.com/downloads/)) 

benchmarks/lud/benchmark.json

@@ -0,0 +1,24 @@
+{
+   "type": "benchmark",
+   "name":"Lower-Upper Decomposition",
+   "short-name":"lud",
+   "description":"In numerical analysis, LU decomposition (where 'LU' stands for 'Lower Upper', and also called LU factorization) factors a matrix as the product of a lower triangular matrix and an upper triangular matrix. The product sometimes includes a permutation matrix as well. The LU decomposition can be viewed as the matrix form of Gaussian elimination. Computers usually solve square systems of linear equations using the LU decomposition, and it is also a key step when inverting a matrix, or computing the determinant of a matrix.",
+   "version":"0.1.0",
+   "input-size":{
+      "small":8,
+      "medium":1024,
+      "large":2048
+   },
+   "input-format": "csv",
+   "random-seed":1337,
+   "dwarf": "dense linear algebra",
+   "output": {
+      "type": "output-file",
+      "output-file": { "file": "./output/output.csv" },
+       "output-check-arguments": [
+          { "expand": "/experiment/input-size" },
+          { "config": "/benchmark/random-seed" },
+          { "config": "/experiment/output-file" }
+       ]
+   }
+}

benchmarks/lud/implementations/c/implementation.json

@@ -0,0 +1,42 @@
+{
+    "type": "implementation",
+    "short-name":"c",
+    "description":"Reference C implementation ported from Rodinia suite",
+    "language":"c",
+    "core-source-files":[
+       { "file": "./lud_base.c"}
+    ],
+    "runner-source-file": { "file": "./runner.c" },
+    "runner-arguments": [
+        {
+            "prefix":"-s ",
+            "value": { "expand": "/experiment/input-size" }
+        },
+        {
+            "prefix":"-i ",
+            "value": { "expand": "/experiment/input-file"}
+        }
+    ],
+    "runner-arguments-with-output-check": [
+        {
+            "prefix":"-s ",
+            "value": { "expand": "/experiment/input-size" }
+        },
+        {
+            "prefix":"-i ",
+            "value": { "expand": "/experiment/input-file" }
+        },
+        {
+            "prefix":"-o ",
+            "value": { "config": "/experiment/output-file" }
+        }
+    ],
+    "libraries":[
+        { "suite-root": "/implementations/c/common_rand.c"},
+        { "file": "./misc/common.c"}
+    ],
+    "include-directories":[
+        {"suite-root": "/implementations/c/"},
+        { "file": "./misc/"}
+    ]
+}

dense-linear-algebra/lud/common/common.c → benchmarks/lud/implementations/c/misc/common.c

@@ -7,6 +7,10 @@
 #include "common.h"
 #include "common_rand.h"
 
+#ifndef DEBUG
+#define DEBUG 0
+#endif
+
 void stopwatch_start(stopwatch *sw){
     if (sw == NULL)
         return;
@@ -38,6 +42,9 @@ get_interval_by_usec(stopwatch *sw){
     return ((sw->end.tv_sec-sw->begin.tv_sec)*1000000+(sw->end.tv_usec-sw->begin.tv_usec));
 }
 
+// This function creates a matrix that is guaranteed to have a
+// LUD solution by creating the upper and lower trangular matrices
+// and then multiplying them together.
 func_ret_t
 create_matrix_from_random(double **mp, int size){
     double *l, *u, *m;
@@ -86,6 +93,28 @@ create_matrix_from_random(double **mp, int size){
         }
     }
 
+    // For debugging purposes, change to '1' to print
+    // intermediary matrices
+    if (DEBUG) {
+        fprintf(stderr,"l:\n");
+        for (i=0; i < size; i++) {
+            for (j=0; j < size; j++) {
+                fprintf(stderr, "%f ", l[i*size+j]);
+            }
+            fprintf(stderr, "\n");
+        }
+        fprintf(stderr, "\n");
+
+        fprintf(stderr,"u:\n");
+        for (i=0; i < size; i++) {
+            for (j=0; j < size; j++) {
+                fprintf(stderr, "%f ", u[i*size+j]);
+            }
+            fprintf(stderr, "\n");
+        }
+        fprintf(stderr, "\n");
+    }
+
     for (i=0; i < size; i++) {
         for (j=0; j < size; j++) {
             sum = 0;
@@ -190,29 +219,32 @@ lud_verify(double *m, double *lu, int matrix_dim){
             }
         tmp[i*matrix_dim+j] = sum;
     }
-/*
-  fprintf(stderr, ">>>>>LU<<<<<<<\n");
-  for (i=0; i<matrix_dim; i++){
-    for (j=0; j<matrix_dim;j++){
-        fprintf(stderr, "%f ", lu[i*matrix_dim+j]);
-    }
-    fprintf(stderr, "\n");
-  }
-  fprintf(stderr, ">>>>>result<<<<<<<\n");
-  for (i=0; i<matrix_dim; i++){
-    for (j=0; j<matrix_dim;j++){
-        fprintf(stderr, "%f ", tmp[i*matrix_dim+j]);
-    }
-    fprintf(stderr, "\n");
-  }
-  fprintf(stderr, ">>>>>input<<<<<<<\n");
-  for (i=0; i<matrix_dim; i++){
-    for (j=0; j<matrix_dim;j++){
-        fprintf(stderr, "%f ", m[i*matrix_dim+j]);
-    }
-    fprintf(stderr, "\n");
-  }
-*/
+
+    // Just for debugging purposes
+    // Set to '1' to execute
+    if (DEBUG) {
+        fprintf(stderr, ">>>>>LU<<<<<<<\n");
+        for (i=0; i<matrix_dim; i++){
+            for (j=0; j<matrix_dim;j++){
+                fprintf(stderr, "%f ", lu[i*matrix_dim+j]);
+            }
+            fprintf(stderr, "\n");
+        }
+        fprintf(stderr, ">>>>>result<<<<<<<\n");
+        for (i=0; i<matrix_dim; i++){
+            for (j=0; j<matrix_dim;j++){
+                fprintf(stderr, "%f ", tmp[i*matrix_dim+j]);
+            }
+            fprintf(stderr, "\n");
+        }
+        fprintf(stderr, ">>>>>input<<<<<<<\n");
+        for (i=0; i<matrix_dim; i++){
+            for (j=0; j<matrix_dim;j++){
+                fprintf(stderr, "%f ", m[i*matrix_dim+j]);
+            }
+            fprintf(stderr, "\n");
+        }
+    }
 
     int good = 1;
     for (i=0; i<matrix_dim; i++){
@@ -223,9 +255,14 @@ lud_verify(double *m, double *lu, int matrix_dim){
             }
         }
     }
-    if(good) fprintf(stderr, "Good LUD!");
-    else fprintf(stderr, "Bad LUD!");
     free(tmp);
+    if(good) {
+        fprintf(stderr, "Good LUD!\n");
+        return RET_SUCCESS;
+    } else {
+        fprintf(stderr, "Bad LUD!\n");
+        return RET_FAILURE;
+    }
 }
 
 void

benchmarks/lud/implementations/c/runner.c

@@ -0,0 +1,165 @@
+/*
+ * =====================================================================================
+ *
+ *       Filename:  runner.c
+ *
+ *    Description:  The main wrapper for the suite
+ *
+ *        Version:  1.0
+ *        Created:  10/22/2009 08:40:34 PM
+ *       Revision:  none
+ *       Compiler:  gcc
+ *
+ *         Author:  Liang Wang (lw2aw), lw2aw@virginia.edu
+ *        Company:  CS@UVa
+ *
+ * =====================================================================================
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "common.h"
+#include "common_rand.h"
+
+static int do_verify = 0;
+
+static struct option long_options[] = {
+    /* name, has_arg, flag, val */
+    {"input", 1, NULL, 'i'},
+    {"size", 1, NULL, 's'},
+    {"verify", 0, NULL, 'v'},
+    {0,0,0,0}
+};
+
+extern void
+lud_base(double *m, int matrix_dim);
+
+int
+main ( int argc, char *argv[] )
+{
+    int matrix_dim = 32; /* default matrix_dim */
+    int opt, option_index=0, error=0;
+    func_ret_t ret;
+    char *input_path = NULL;
+    char *output_path = NULL;
+    FILE *file;
+    double *m;
+    stopwatch sw;
+    int i,j;
+    int debug = 0;
+    size_t linesiz=0;
+    char* linebuf=NULL;
+    ssize_t linelen=0;
+    char* token;
+    const char comma[2] = ",";
+
+    while ((opt = getopt_long(argc, argv, ":dvs:i:o:",
+                              long_options, &option_index)) != -1 ) {
+        switch(opt){
+        case 'v':
+            do_verify = 1;
+            break;
+        case 's':
+            matrix_dim = atoi(optarg);
+            break;
+        case 'i':
+            input_path = optarg;
+            break;
+        case 'o':
+            output_path = optarg;
+            break;
+        case '?':
+            fprintf(stderr, "invalid option\n");
+            error=1;
+            break;
+        case 'd':
+            debug=1;
+            break;
+        case ':':
+            fprintf(stderr, "missing argument\n");
+            error=1;
+            break;
+        default:
+            error=1;
+        }
+    }
+
+    if ((optind < argc) || (optind == 1) || input_path == NULL || error) {
+        fprintf(stderr, "Usage: %s -s size -i input_path [-v] [-d] [-o output_path]\n", argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    file = fopen(input_path, "r");
+    if (file == NULL) {
+        fprintf(stderr, "Invalid input file path: %s\n", input_path);
+        exit(EXIT_FAILURE);
+    }
+
+    // Read matrix from file
+    if (debug) {
+        fprintf(stderr, "Reading data from file %s\n", input_path);
+    }
+    m = (double *)malloc(sizeof(double) * matrix_dim * matrix_dim);
+    j = 0;
+    while ((linelen=getline(&linebuf, &linesiz, file)) != -1) {
+        if (debug) {
+            fprintf(stderr, "Read line: %s\n", linebuf);
+        }
+        /* get the first number */
+        i = 0;
+        token = strtok(linebuf, comma);
+
+        /* walk through other numbers */
+        while( token != NULL ) {
+            if (debug) {
+                fprintf(stderr, "Read token: %s\n", token);
+            }
+            m[j*matrix_dim + i] = atof(token);
+            token = strtok(NULL, comma);
+            i = i + 1;
+        }
+
+        free(linebuf);
+        linebuf=NULL;
+        j = j + 1;
+    }
+    fclose(file);
+
+    if (debug) {
+        fprintf(stderr, "Computing LUD\n");
+    }
+    stopwatch_start(&sw);
+    lud_base(m, matrix_dim);
+    stopwatch_stop(&sw);
+
+    if (output_path) {
+        if (debug) {
+            fprintf(stderr, "Saving result in %s\n", output_path);
+        }
+        file = fopen(output_path, "w");
+
+        if (file == NULL) {
+            free(m);
+            exit(EXIT_FAILURE);    
+        }
+
+        for (j = 0; j < matrix_dim; ++j) {
+            for (i = 0; i < matrix_dim; ++i) {
+                fprintf(file, "%.*f", 21, m[j*matrix_dim+i]);
+                if (i < matrix_dim-1) {
+                    fprintf(file, ",");
+                }
+            }
+            fprintf(file, "\n");
+        }  
+        fclose(file);
+    }
+
+    free(m);
+    printf("{ \"status\": %d, \"options\": \"-s %d\", \"time\": %f }\n", 1, matrix_dim, get_interval_by_sec(&sw));
+    return EXIT_SUCCESS;
+}				/* ----------  end of function main  ---------- */