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.

3 files changed, 917 insertions, 0 deletions

diff --git a/SD-VBS/benchmarks/mser/src/c/mser.c b/SD-VBS/benchmarks/mser/src/c/mser.c
new file mode 100644
index 0000000..d886d7a
--- /dev/null
+++ b/SD-VBS/benchmarks/mser/src/c/mser.c
@@ -0,0 +1,714 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+/***
+%   MSER  Maximally Stable Extremal Regions
+%   R=MSER(I,DELTA) computes the Maximally Stable Extremal Regions
+%   (MSER) of image I with stability threshold DELTA. I is any
+%   array of class UINT8, while DELTA is a scalar of the same class.
+%   R is an index set (of class UINT32) which enumerates the
+%   representative pixels of the detected regions.
+%
+%   A region R can be recovered from a representative pixel X as the
+%   connected component of the level set {Y:I(Y) <= I(X)} which
+%   contains X.
+***/
+
+
+#include "mser.h"
+#include <string.h>
+
+/* advance N-dimensional subscript */
+void
+adv(iArray *dims, int ndims, iArray *subs_pt)
+{
+    int d = 0 ;
+    while(d < ndims) 
+    {
+        sref(subs_pt,d) = sref(subs_pt,d) + 1;
+        if( sref(subs_pt,d)  < sref(dims,d) ) 
+            return ;
+        sref(subs_pt,d++) = 0 ;
+    }
+}
+
+/** driver **/
+I2D* mser(I2D* I, int in_delta,
+          iArray* subs_pt, iArray* nsubs_pt, iArray* strides_pt, iArray* visited_pt, iArray* dims, 
+          uiArray* joins_pt,
+          region_t* regions_pt, 
+          pair_t* pairs_pt,
+          node_t* forest_pt,
+          ulliArray* acc_pt, ulliArray* ell_pt,
+          I2D* out)
+{
+   idx_t i, rindex=0;
+   int k;
+   int nout = 1;
+   
+   int OUT_REGIONS=0;
+   int OUT_ELL = 1;
+   int OUT_PARENTS = 2;
+   int OUT_AREA = 3;
+   int BUCKETS = 256;
+   
+   //I2D* out;
+
+   int IN_I = 0;
+   int IN_DELTA = 1;   
+
+    /* configuration */
+    int verbose = 1 ;      /* be verbose                              */
+    int small_cleanup= 1 ; /* remove very small regions               */
+    int big_cleanup  = 1 ; /* remove very big regions                 */
+    int bad_cleanup  = 0 ; /* remove very bad regions                 */
+    int dup_cleanup  = 1 ; /* remove duplicates                       */
+    val_t delta ;          /* stability delta                         */
+
+    /* node value denoting a void node */
+    idx_t const node_is_void = 0xffffffff ;
+
+    //iArray*   subs_pt ;       /* N-dimensional subscript                 
+    //iArray*   nsubs_pt ;      /* diff-subscript to point to neigh.       
+//    uiArray* strides_pt ;    /* strides to move in image array          
+//    uiArray* visited_pt ;    /* flag                                    
+
+    int nel ;              /* number of image elements (pixels)       */
+    int ner = 0 ;          /* number of extremal regions              */
+    int nmer = 0 ;         /* number of maximally stable              */
+    int ndims ;            /* number of dimensions                    */
+//    iArray* dims ;           /* dimensions                              
+    int njoins = 0 ;       /* number of join ops                      */
+
+    I2D* I_pt ;    /* source image                            */
+    //pair_t*   pairs_pt ;   /* scratch buffer to sort pixels           
+//    node_t*   forest_pt ;  /* the extremal regions forest             
+//    region_t* regions_pt ; /* list of extremal regions found          
+    int regions_pt_size;
+    int pairs_pt_size;
+    int forest_pt_size;
+
+    /* ellipses fitting */
+    //ulliArray* acc_pt ;        /* accumulator to integrate region moments
+    //ulliArray* ell_pt ;        /* ellipses parameters                     
+    int    gdl ;           /* number of parameters of an ellipse      */
+    //uiArray* joins_pt ;      /* sequence of joins                       
+   
+    delta = 0;
+    delta = in_delta;
+
+    /* get dimensions */
+
+    nel = I->height*I->width;            /* number of elements of src image */
+    ndims = 2;
+    //dims = malloc(sizeof(iArray) + sizeof(int)*ndims);
+    I_pt = I;
+    
+    sref(dims,0) = I->height;
+    sref(dims,1) = I->width;
+    
+    /* allocate stuff */
+    //subs_pt = malloc(sizeof(iArray) + sizeof(int)*ndims);
+    //nsubs_pt = malloc(sizeof(iArray) + sizeof(int)*ndims);
+
+    //strides_pt = malloc(sizeof(uiArray)+sizeof(unsigned int)*ndims);
+    //visited_pt = malloc(sizeof(uiArray) + sizeof(unsigned int)*nel);
+    //joins_pt = malloc(sizeof(uiArray) + sizeof(unsigned int)*nel);
+
+    //regions_pt = (region_t*)malloc(sizeof(region_t)*nel);
+    regions_pt_size = nel;
+
+    //pairs_pt = (pair_t*)malloc(sizeof(pair_t)*nel);
+    pairs_pt_size = nel;
+
+    //forest_pt = (node_t*)malloc(sizeof(node_t)*nel);
+    forest_pt_size = nel;
+
+    /* compute strides to move into the N-dimensional image array */
+    sref(strides_pt,0) = 1;
+    for(k = 1 ; k < ndims ; ++k)
+    {
+        sref(strides_pt,k) = sref(strides_pt,k-1) * sref(dims,k-1) ;
+    }
+
+    /* sort pixels in increasing order of intensity: using Bucket Sort */
+    {
+        int unsigned buckets [BUCKETS] ;
+        memset(buckets, 0, sizeof(int unsigned)*BUCKETS) ;
+
+        for(i = 0 ; i < nel ; ++i) 
+        {
+            val_t v = asubsref(I_pt,i) ;
+            ++buckets[v] ;
+        }
+        
+        for(i = 1 ; i < BUCKETS ; ++i) 
+        {
+            arrayref(buckets,i) += arrayref(buckets,i-1) ;
+        }
+        
+        for(i = nel ; i >= 1 ; )
+        {
+            val_t v = asubsref(I_pt,--i) ;
+            idx_t j = --buckets[v] ;
+            pairs_pt[j].value = v ;
+            pairs_pt[j].index = i ;
+        }
+    }
+     
+    /* initialize the forest with all void nodes */
+    for(i = 0 ; i < nel ; ++i) 
+    {
+        forest_pt[i].parent = node_is_void  ;
+    }
+  
+    /* number of ellipse free parameters */
+    gdl = ndims*(ndims+1)/2 + ndims ;
+
+    /* -----------------------------------------------------------------
+    *                                     Compute extremal regions tree
+    * -------------------------------------------------------------- */
+  
+    for(i = 0 ; i < nel ; ++i)
+    {
+        /* pop next node xi */
+        idx_t index = pairs_pt [i].index ;    
+        val_t value = pairs_pt [i].value ;
+
+        /* this will be needed later */
+        rindex = index ;
+    
+        /* push it into the tree */
+        forest_pt [index] .parent   = index ;
+        forest_pt [index] .shortcut = index ;
+        forest_pt [index] .area     = 1 ;
+#ifdef USE_RANK_UNION
+        forest_pt [index] .height   = 1 ;
+#endif
+    
+    /* convert index into a subscript sub; also initialize nsubs 
+    to (-1,-1,...,-1) */