Squashed commit of the sb-vbs branch.

Includes the SD-VBS benchmarks modified to:
- Use libextra to loop as realtime jobs
- Preallocate memory before starting their main computation
- Accept input via stdin instead of via argc

Does not include the SD-VBS matlab code.

Fixes libextra execution in LITMUS^RT.

5 files changed, 373 insertions, 0 deletions

diff --git a/SD-VBS/benchmarks/multi_ncut/src/c/.computeMultiW.c.swp b/SD-VBS/benchmarks/multi_ncut/src/c/.computeMultiW.c.swp
new file mode 100644
index 0000000..a3b35c6
--- /dev/null
+++ b/SD-VBS/benchmarks/multi_ncut/src/c/.computeMultiW.c.swp
diff --git a/SD-VBS/benchmarks/multi_ncut/src/c/script_multi_ncut.c b/SD-VBS/benchmarks/multi_ncut/src/c/script_multi_ncut.c
new file mode 100644
index 0000000..e4f7912
--- /dev/null
+++ b/SD-VBS/benchmarks/multi_ncut/src/c/script_multi_ncut.c
@@ -0,0 +1,90 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "segment.h"
+#include "extra.h"
+#define MAX_EDGE 500000
+int main(int argc, char* argv[])
+{
+    SET_UP
+    float sigma = 0.6;
+    float k = 4;
+    int min_size = 10;
+    char im1[256];
+    int num_ccs[1] = {0};
+    I2D *out;
+    I2D* im;
+    I2D* seg;
+    I2D* kernel;
+    I2D* ind;
+    I2D* output;
+    int ret;
+    int *segments;
+    edge* edges;
+    universe* u;
+
+    F2D *imageOut, *tempOut;
+    F2D *edgeWeights, *in;
+    printf("Input image: ");
+    scanf("%s", im1);
+    im = readImage(im1);
+
+
+    int height, width, num_edges, num_vertices;
+    height = im->height;
+    width = im->width;
+    num_edges = MAX_EDGE;
+    num_vertices = width * height;
+    segments = (int *) malloc(height*width*sizeof(int));
+    edges = (edge*)malloc(sizeof(edge)*width*height*4);
+    imageOut = fSetArray(height, width, 0);
+    tempOut = fSetArray(height, width, 0);
+    kernel = iMallocHandle(1,5);
+    edgeWeights = fMallocHandle(1, num_edges);
+    in = fDeepCopy(edgeWeights);
+    ind = fMallocHandle(1, num_edges);
+    u = (universe*)malloc(sizeof(universe));
+    u->elts = (uni_elt*)malloc(sizeof(uni_elt)*num_vertices);
+    output = iMallocHandle(height, width);
+
+    printf("start\n");
+    for_each_job{
+        seg = segment_image(im, sigma, k, min_size, num_ccs, segments, edges, imageOut, tempOut, kernel, edgeWeights, in, ind, u, output);
+        out = seg;
+    }
+    printf("end..\n");
+#ifdef CHECK   
+    /** Self checking - use expected.txt from data directory  **/
+    {
+        int ret=0;
+        float tol = 0;
+        
+#ifdef GENERATE_OUTPUT
+        writeMatrix(out, argv[1]);
+#endif
+ 
+    ret = selfCheck(out, "./expected_C.txt", tol);
+    if(ret < 0)
+        printf("Error in Multi N Cut\n");
+    }
+#endif
+
+    iFreeHandle(im); 
+    free(edges);
+    free(segments);
+    free(tempOut);
+    free(imageOut);
+    free(edgeWeights);
+    free(in);
+    free(ind);
+    free(output);
+    free(u->elts);
+    free(u);
+    WRITE_TO_FILE
+    return 0;
+}
+
+
diff --git a/SD-VBS/benchmarks/multi_ncut/src/c/segment-graph.c b/SD-VBS/benchmarks/multi_ncut/src/c/segment-graph.c
new file mode 100644
index 0000000..13b219b
--- /dev/null
+++ b/SD-VBS/benchmarks/multi_ncut/src/c/segment-graph.c
@@ -0,0 +1,95 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "segment.h"
+
+// threshold function
+#define THRESHOLD(size, c) (c/size)
+
+int find(universe* u, int x)
+{
+    int y=x;
+    while (y != u->elts[y].p)
+        y = u->elts[y].p;
+    u->elts[x].p = y;
+    return y;
+}
+
+void join(universe* u, int x, int y)
+{
+    if (u->elts[x].rank > u->elts[y].rank) 
+    {
+        u->elts[y].p = x;
+        u->elts[x].size += u->elts[y].size;
+    } 
+    else 
+    {
+        u->elts[x].p = y;
+        u->elts[y].size += u->elts[x].size;
+        if (u->elts[x].rank == u->elts[y].rank)
+            u->elts[y].rank++;
+    }
+    u->num--;
+    return ;
+}
+
+universe *segment_graph(int num_vertices, int num_edges, edge *edges, float c, F2D* edgeWeights, F2D* in, I2D* ind,
+                        universe* u)
+{ 
+    float threshold[num_vertices];
+    int i, a, b, j, k;
+    //universe *u;
+    //F2D *edgeWeights;
+    I2D *indices;
+
+    edgeWeights = fResetHandle(edgeWeights,1,num_edges);
+
+    for(i=0; i<num_edges; i++)
+        asubsref(edgeWeights,i) = edges[i].w;
+
+    // sort edges by weight
+    indices = fResortIndices(edgeWeights,1, in, ind);
+
+    // make a disjoint-set forest
+    //u = (universe*)malloc(sizeof(universe));
+    //u->elts = (uni_elt*)malloc(sizeof(uni_elt)*num_vertices);
+    u->num = num_vertices;
+    for(i=0; i<num_vertices; i++)
+    {
+        u->elts[i].rank = 0;
+        u->elts[i].size = 1;
+        u->elts[i].p = i;
+    }
+
+    // init thresholds
+    for (i = 0; i < num_vertices; i++)
+        arrayref(threshold,i) = THRESHOLD(1,c);
+
+    // for each edge, in non-decreasing weight order...
+    for (i = 0; i < num_edges; i++)
+    {
+        edge *pedge = &edges[ asubsref(indices,i) ];
+    
+        // components conected by this edge
+        a = find(u, pedge->a);
+        b = find(u, pedge->b);
+        if (a != b) 
+        {
+            if ((pedge->w <= arrayref(threshold,a)) && (pedge->w <= arrayref(threshold,b))) 
+            {
+                    join(u, a, b);
+                    a = find(u, a);
+                    arrayref(threshold,a) = pedge->w + THRESHOLD(u->elts[a].size, c);
+            }
+        }
+    }
+