Add separate implementation folders, minimize serial's main

mean_shift_cuda/Makefile

@@ -0,0 +1,36 @@
+SHELL := /bin/bash
+
+# ============================================
+# COMMANDS
+
+CC = nvcc
+RM = rm -f
+CFLAGS=-lm -O3 -Wall -I.
+OBJ=meanshift.o meanshift_declarations.o
+DEPS=meanshift_declarations.h
+
+# ==========================================
+# TARGETS
+
+EXECUTABLES = meanshift
+
+.PHONY: all clean
+
+all: $(EXECUTABLES)
+
+# ==========================================
+# DEPENDENCIES (HEADERS)
+
+%.o: %.c $(DEPS)
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+.PRECIOUS: $(EXECUTABLES) $(OBJ)
+
+# ==========================================
+# EXECUTABLE (MAIN)
+
+$(EXECUTABLES): $(OBJ)
+	$(CC) -o $@ $^ $(CFLAGS)
+
+clean:
+	$(RM) *.o *~ $(EXECUTABLES)

meanshift.c → mean_shift_cuda/meanshift.c

@@ -4,7 +4,9 @@
 #include <math.h>
 #include <float.h>
 
-#include "serial_declarations.h"
+#include <cuda_runtime.h>
+
+#include "meanshift_declarations.h"
 #define N       512
 
 int NUMBER_OF_POINTS = 600;

Makefile → mean_shift_serial/Makefile

@@ -12,7 +12,7 @@ DEPS=serial_declarations.h
 # ==========================================
 # TARGETS
 
-EXECUTABLES = serial mean-shift
+EXECUTABLES = serial
 
 .PHONY: all clean
 

mean_shift_serial/serial.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#include "serial_declarations.h"
+
+int DEVIATION = 1;
+int NUMBER_OF_POINTS = 600;
+int DIMENSIONS = 2;
+char* POINTS_FILENAME = "../data/X.bin";
+char* LABELS_FILENAME = "../data/L.bin";
+
+struct timeval startwtime, endwtime;
+double seq_time;
+
+int main(int argc, char **argv){
+    double **vectors, **shifted_points;
+    char *labels;
+    parameters params;
+
+    //get_args(argc, argv); commented out while in development
+    init(&vectors, &labels, &params);
+
+    //save_matrix(vectors, 0);
+
+    // tic
+    gettimeofday (&startwtime, NULL);
+
+    int iterations = meanshift(vectors, &shifted_points, DEVIATION, &params);
+    printf("Total iterations = %d\n", iterations);
+
+    // toc
+    gettimeofday (&endwtime, NULL);
+    seq_time = (double)((endwtime.tv_usec - startwtime.tv_usec)/1.0e6 + endwtime.tv_sec - startwtime.tv_sec);
+    printf("%s wall clock time = %f\n","Mean Shift", seq_time);
+
+    //TODO write output points to file -> plot later
+    //save_matrix(shifted_points, iterations);
+}

serial_declarations.c → mean_shift_serial/serial_declarations.c

@@ -6,7 +6,9 @@
 
 #include "serial_declarations.h"
 
-void get_args(int argc, char **argv, int *h){
+#define OUTPUT_PREFIX "../output/output_"
+
+void get_args(int argc, char **argv){
     if (argc != 6) {
         printf("Usage: %s h N D Pd Pl\nwhere:\n", argv[0]);
         printf("\th is the variance\n");
@@ -17,47 +19,111 @@ void get_args(int argc, char **argv, int *h){
         exit(1);
     }
 
-    *h = atoi(argv[1]);
+    DEVIATION = atoi(argv[1]);
     NUMBER_OF_POINTS = atoi(argv[2]);
     DIMENSIONS = atoi(argv[3]);
     POINTS_FILENAME = argv[4];
     LABELS_FILENAME = argv[5];
 }
 
-int meanshift(double **original_points, double ***shifted_points, int h
+void init(double ***vectors, char **labels, parameters *params){
-    , parameters *opt, int iteration){
+    int bytes_read = 0;
+    // initializes vectors
+    FILE *points_file;
+    points_file = fopen(POINTS_FILENAME, "rb");
+    if (points_file != NULL){
+        // allocates memory for the array
+        (*vectors) = alloc_2d_double(NUMBER_OF_POINTS, DIMENSIONS);
+        // reads vectors dataset from file
+        for (int i=0; i<NUMBER_OF_POINTS; i++){
+            bytes_read = fread((*vectors)[i], sizeof(double), DIMENSIONS, points_file);
+            if ( bytes_read != DIMENSIONS ){
+                if(feof(points_file)){
+                    printf("Premature end of file reached.\n");
+                } else{
+                    printf("Error reading points file.");
+                }
+                fclose(points_file);
+                exit(EXIT_FAILURE);
+            }
+        }
+    } else {
+        printf("Error reading dataset file.\n");
+        exit(EXIT_FAILURE);
+    }
+    fclose(points_file);
+
+    // initializes file that will contain the labels (train)
+    FILE *labels_file;
+    labels_file = fopen(LABELS_FILENAME, "rb");
+    if (labels_file != NULL){
+        // NOTE : Labels were classified as <class 'numpy.uint8'>
+        // variables of type uint8 are stored as 1-byte (8-bit) unsigned integers
+        // gets number of labels
+        fseek(labels_file, 0L, SEEK_END);
+        long int pos = ftell(labels_file);
+        rewind(labels_file);
+        int label_elements = pos/ sizeof(char);
+
+        // allocates memory for the array
+        *labels = (char*)malloc(label_elements* sizeof(char));
+        fseek(labels_file, 0L, SEEK_SET);
+        bytes_read = fread((*labels), sizeof(char), label_elements, labels_file);
+        if ( bytes_read != label_elements ){
+            if(feof(points_file)){
+                printf("Premature end of file reached.\n");
+            } else{
+                printf("Error reading points file.");
+            }
+            fclose(labels_file);
+            exit(EXIT_FAILURE);
+        }
+    }
+    fclose(labels_file);
+
+    // MEAN SHIFT OPTIONS
+    params->epsilon = 0.0001;
+    params->verbose = false;
+    params->display = false;
+}
+
+int meanshift(double **original_points, double ***shifted_points, int deviation
+    , parameters *opt){
+    static int iteration = 0;
 
-    // allocates space and copies original points on first iteration
+    // allocates memory and copies original points on first iteration
-    if (iteration == 1){
+    if (iteration == 0 || (*shifted_points) == NULL){
+        iteration = 0;
         (*shifted_points) = alloc_2d_double(NUMBER_OF_POINTS, DIMENSIONS);
         duplicate(original_points, NUMBER_OF_POINTS, DIMENSIONS, shifted_points);
     }
 
-    // mean shift vector
+    // allocates memory for mean shift vector
     double **mean_shift_vector;
     mean_shift_vector = alloc_2d_double(NUMBER_OF_POINTS, DIMENSIONS);
-    // initialize elements of mean_shift_vector to inf
+    // initializes elements of mean_shift_vector to inf
     for (int i=0;i<NUMBER_OF_POINTS;i++){
         for (int j=0;j<DIMENSIONS;j++){
             mean_shift_vector[i][j] = DBL_MAX;
         }
     }
 
+    // allocates memory for other arrays needed
     double **kernel_matrix = alloc_2d_double(NUMBER_OF_POINTS, NUMBER_OF_POINTS);
     double *denominator = malloc(NUMBER_OF_POINTS * sizeof(double));
 
-    // find pairwise distance matrix (inside radius)
+    // finds pairwise distance matrix (inside radius)
     // [I, D] = rangesearch(x,y,h);
     for (int i=0; i<NUMBER_OF_POINTS; i++){
         double sum = 0;
         for (int j=0; j<NUMBER_OF_POINTS; j++){
-            double dist = calculateDistance((*shifted_points)[i]
+            double distance = calculateDistance((*shifted_points)[i]
                 , original_points[j]);
 
-            if (dist < h*h){
+            double deviation_square = deviation*deviation;
-                kernel_matrix[i][j] = dist * dist;
+            if (distance < deviation_square){
-                // compute kernel matrix
+                // computes kernel matrix
-                double pow = ((-1)*(kernel_matrix[i][j]))/(2*(h*h));
+                double pow = ((-1)*(distance * distance))/(2*(deviation_square));
                 kernel_matrix[i][j] = exp(pow);
             } else {
                 kernel_matrix[i][j] = 0;
@@ -70,15 +136,15 @@ int meanshift(double **original_points, double ***shifted_points, int h
         denominator[i] = sum;
     }
 
-    // create new y vector
+    // creates new y vector
     double **new_shift = alloc_2d_double(NUMBER_OF_POINTS, DIMENSIONS);
-    // build nominator
+    // builds nominator
     multiply(kernel_matrix, original_points, new_shift);
-    // divide element-wise
+    // divides element-wise
     for (int i=0; i<NUMBER_OF_POINTS; i++){
         for (int j=0; j<DIMENSIONS; j++){
             new_shift[i][j] = new_shift[i][j] / denominator[i];
-            // calculate mean-shift vector at the same time
+            // calculates mean-shift vector at the same time
             mean_shift_vector[i][j] = new_shift[i][j] - (*shifted_points)[i][j];
         }
     }
@@ -90,19 +156,21 @@ int meanshift(double **original_points, double ***shifted_points, int h
 
     save_matrix((*shifted_points), iteration);
 
+    // calculates norm of the new mean shift vector
     double current_norm = norm(mean_shift_vector, NUMBER_OF_POINTS, DIMENSIONS);
     printf("Iteration n. %d, error %f \n", iteration, current_norm);
 
-    // clean up this iteration's allocates
+    // cleans up this iteration's allocations
     free(mean_shift_vector[0]);
     free(mean_shift_vector);
     free(kernel_matrix[0]);
     free(kernel_matrix);
     free(denominator);
 
-    /** iterate until convergence **/
+    /** iterates until convergence **/
     if (current_norm > opt->epsilon) {
-        return meanshift(original_points, shifted_points, h, opt, ++iteration);
+        ++iteration;
+        return meanshift(original_points, shifted_points, deviation, opt);
     }
 
     return iteration;
@@ -171,8 +239,8 @@ void print_matrix(double **array, int rows, int cols){
 }
 
 void save_matrix(double **matrix, int iteration){
-    char filename[18];
+    char filename[50];
-    snprintf(filename, sizeof(filename), "%s%d", "output/output_", iteration);
+    snprintf(filename, sizeof(filename), "%s%d", "../output/output_", iteration);
     FILE *file;
     file = fopen(filename, "w");
     for (int rows=0; rows<NUMBER_OF_POINTS; ++rows){

serial_declarations.h → mean_shift_serial/serial_declarations.h

@@ -3,6 +3,7 @@
 
 #include <stdbool.h>
 
+extern int DEVIATION;
 extern int NUMBER_OF_POINTS;
 extern int DIMENSIONS;
 extern char* POINTS_FILENAME;
@@ -15,14 +16,16 @@ typedef struct parameters {
 } parameters;
 
 //Function get_args parses command line arguments.
-void get_args(int argc, char **argv, int *h);
+void get_args(int argc, char **argv);
+
+//Function init reads the dataset and label arrays from the corresponding files.
+void init(double ***vectors, char **labels, parameters *params);
 
 //Function meanshift recursively shifts original points according to th
 //mean-shift algorithm saving the result to shiftedPoints. Struct opt has user
-//options, h is the desirable deviation, iteration is this call's iteration
+//options, h is the desirable deviation.
-//number.
 int meanshift(double **original_points, double ***shifted_points, int h
-	, parameters *opt, int iteration);
+	, parameters *opt);
 
 //Function norm returns the second norm of matrix of dimensions rowsXcols.
 double norm(double **matrix, int rows, int cols);

serial.c

@@ -1,72 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-
-#include "serial_declarations.h"
-
-int NUMBER_OF_POINTS = 600;
-int DIMENSIONS = 2;
-char* POINTS_FILENAME = "data/X.bin";
-char* LABELS_FILENAME = "data/L.bin";
-
-struct timeval startwtime, endwtime;
-double seq_time;
-
-int main(int argc, char **argv){
-	int h = 1;
-
-	//get_args(argc, argv, &h); commented out while in development
-
-    FILE *f;
-//    f = fopen(X, "rb");
-//    fseek(f, 0L, SEEK_END);
-//    long int pos = ftell(f);
-//    fclose(f);
-//    int elements = pos / sizeof(double);  // number of total elements (points*dimension)
-//    int points = elements/DIMENSIONS;
-//    //printf("points : %d \n", points);
-    f = fopen(POINTS_FILENAME, "rb");
-    double **vectors;
-    vectors = alloc_2d_double(NUMBER_OF_POINTS, DIMENSIONS);
-    for (int i=0; i<NUMBER_OF_POINTS; i++){
-        int out = fread(vectors[i], sizeof(double), DIMENSIONS, f);
-    }
-
-    save_matrix(vectors, 0);
-
-    // initializing file that will contain the labels (train)
-    f = fopen(LABELS_FILENAME, "rb");
-    // NOTE : Labels were classified as <class 'numpy.uint8'>
-    // variables of type uint8 are stored as 1-byte (8-bit) unsigned integers
-    fseek(f, 0L, SEEK_END);
-    long int pos = ftell(f);
-    rewind(f);
-    //printf("position : %ld \n", pos);
-    int label_elements = pos/ sizeof(char);
-    char *labels = (char*)malloc(label_elements* sizeof(char));
-    fseek(f, 0L, SEEK_SET);
-    int out = fread(labels, sizeof(char), label_elements, f);
-    fclose(f);
-
-    // MEAN SHIFT OPTIONS
-    parameters params;
-    params.epsilon = 0.0001;
-    params.verbose = false;
-    params.display = false;
-    parameters *opt;
-    opt = &params;
-
-    double **shifted_points;
-    // tic
-    gettimeofday (&startwtime, NULL);
-
-    int iterations = meanshift(vectors, &shifted_points, h, opt, 1);
-
-    // toc
-    gettimeofday (&endwtime, NULL);
-    seq_time = (double)((endwtime.tv_usec - startwtime.tv_usec)/1.0e6 + endwtime.tv_sec - startwtime.tv_sec);
-    printf("%s wall clock time = %f\n","Mean Shift", seq_time);
-
-    //TODO write output points to file -> plot later
-    //save_matrix(shifted_points, iterations);
-}