MLP: dos2unix; indent -linux

5 files changed, 314 insertions, 228 deletions

diff --git a/MLP/dpu/task.c b/MLP/dpu/task.c
index de3e554..4f85024 100644
--- a/MLP/dpu/task.c
+++ b/MLP/dpu/task.c
@@ -15,7 +15,8 @@
 __host dpu_arguments_t DPU_INPUT_ARGUMENTS;
 
 // GEMV
-static void gemv(T *bufferC, T *bufferA, T *bufferB, int pos) {
+static void gemv(T *bufferC, T *bufferA, T *bufferB, int pos)
+{
 	for (unsigned int i = 0; i < BLOCK_SIZE / sizeof(T); i++) {
 		bufferC[pos] += bufferA[i] * bufferB[i];
 	}
@@ -26,13 +27,14 @@ static void gemv(T *bufferC, T *bufferA, T *bufferB, int pos) {
 BARRIER_INIT(my_barrier, NR_TASKLETS);
 
 // main
-int main() {
+int main()
+{
 	unsigned int tasklet_id = me();
 #if PRINT
 	printf("tasklet_id = %u\n", tasklet_id);
 #endif
-	if (tasklet_id == 0){ // Initialize once the cycle counter
-		mem_reset(); // Reset the heap
+	if (tasklet_id == 0) {	// Initialize once the cycle counter
+		mem_reset();	// Reset the heap
 	}
 	// Barrier
 	barrier_wait(&my_barrier);
@@ -42,12 +44,11 @@ int main() {
 	uint32_t nr_rows = DPU_INPUT_ARGUMENTS.nr_rows;
 	uint32_t max_rows = DPU_INPUT_ARGUMENTS.max_rows;
 
-
 	unsigned int nrows = nr_rows;
-	unsigned int rows_per_tasklet; 
+	unsigned int rows_per_tasklet;
 	unsigned int start_row;
 	unsigned int chunks = nrows / (NR_TASKLETS + NR_TASKLETS);
-	unsigned int dbl_chunks = chunks + chunks;                                                                       
+	unsigned int dbl_chunks = chunks + chunks;
 	rows_per_tasklet = dbl_chunks;
 	unsigned int rest_rows = nrows % (NR_TASKLETS + NR_TASKLETS);
 
@@ -57,19 +58,30 @@ int main() {
 		if ((tasklet_id + tasklet_id) >= rest_rows) {
 			unsigned int hlf_rest_rows = rest_rows >> 1;
 			if ((rest_rows & 1) == 1)
-				start_row = (hlf_rest_rows + 1) * (dbl_chunks + 2) + (tasklet_id - 1 - hlf_rest_rows) * dbl_chunks;
+				start_row =
+				    (hlf_rest_rows + 1) * (dbl_chunks + 2) +
+				    (tasklet_id - 1 -
+				     hlf_rest_rows) * dbl_chunks;
 			else
-				start_row = (hlf_rest_rows) * (dbl_chunks + 2) + (tasklet_id - hlf_rest_rows) * dbl_chunks;
-		} else 
+				start_row =
+				    (hlf_rest_rows) * (dbl_chunks + 2) +
+				    (tasklet_id - hlf_rest_rows) * dbl_chunks;
+		} else
 			start_row = tasklet_id * (dbl_chunks + 2);
 	} else {
 		start_row = tasklet_id * (dbl_chunks);
 	}
 
 	// Address of the current row in MRAM
-	uint32_t mram_base_addr_A = (uint32_t) (DPU_MRAM_HEAP_POINTER + start_row * n_size * sizeof(T));
-	uint32_t mram_base_addr_B = (uint32_t) (DPU_MRAM_HEAP_POINTER + max_rows * n_size_pad * sizeof(T));
-	uint32_t mram_base_addr_C = (uint32_t) (DPU_MRAM_HEAP_POINTER + max_rows * n_size_pad * sizeof(T) + n_size_pad * sizeof(T) + start_row * sizeof(T));
+	uint32_t mram_base_addr_A =
+	    (uint32_t) (DPU_MRAM_HEAP_POINTER + start_row * n_size * sizeof(T));
+	uint32_t mram_base_addr_B =
+	    (uint32_t) (DPU_MRAM_HEAP_POINTER +
+			max_rows * n_size_pad * sizeof(T));
+	uint32_t mram_base_addr_C =
+	    (uint32_t) (DPU_MRAM_HEAP_POINTER +
+			max_rows * n_size_pad * sizeof(T) +
+			n_size_pad * sizeof(T) + start_row * sizeof(T));
 	uint32_t mram_temp_addr_A = mram_base_addr_A;
 	uint32_t mram_temp_addr_B = mram_base_addr_B;
 
@@ -82,34 +94,44 @@ int main() {
 	int offset = 0;
 
 	// Iterate over nr_rows
-	for (unsigned int i = start_row; i < start_row + rows_per_tasklet; i += 2) {
+	for (unsigned int i = start_row; i < start_row + rows_per_tasklet;
+	     i += 2) {
 
-		mram_temp_addr_A = (uint32_t) (DPU_MRAM_HEAP_POINTER + i * n_size * sizeof(T));
+		mram_temp_addr_A =
+		    (uint32_t) (DPU_MRAM_HEAP_POINTER + i * n_size * sizeof(T));
 		mram_temp_addr_B = mram_base_addr_B;
 
 		cache_C[0] = 0;
 		cache_C[1] = 0;
-		for(unsigned int pos = 0; pos < 2 && i + pos < nr_rows; pos++){
+		for (unsigned int pos = 0; pos < 2 && i + pos < nr_rows; pos++) {
 			int n = 0, j;
-			for (n = 0; n < (int32_t) (n_size - (BLOCK_SIZE/sizeof(T))); n += (BLOCK_SIZE / sizeof(T)))
-			{
-
-				mram_read((__mram_ptr void const*) (mram_temp_addr_A), cache_A, BLOCK_SIZE);
-				mram_read((__mram_ptr void const*) (mram_temp_addr_B), cache_B, BLOCK_SIZE);
-
-				if(offset)
-				{
-
-					for(unsigned int off = 0; off < (BLOCK_SIZE / sizeof(T)) - 1; off++)
-					{
+			for (n = 0;
+			     n < (int32_t) (n_size - (BLOCK_SIZE / sizeof(T)));
+			     n += (BLOCK_SIZE / sizeof(T))) {
+
+				mram_read((__mram_ptr void const
+					   *)(mram_temp_addr_A), cache_A,
+					  BLOCK_SIZE);
+				mram_read((__mram_ptr void const
+					   *)(mram_temp_addr_B), cache_B,
+					  BLOCK_SIZE);
+
+				if (offset) {
+
+					for (unsigned int off = 0;
+					     off < (BLOCK_SIZE / sizeof(T)) - 1;
+					     off++) {
 						cache_A[off] = cache_A[off + 1];
 					}
 
-					mram_read((__mram_ptr void const*) (mram_temp_addr_A + BLOCK_SIZE), cache_A_aux, 8);
+					mram_read((__mram_ptr void const
+						   *)(mram_temp_addr_A +
+						      BLOCK_SIZE), cache_A_aux,
+						  8);
 
-					cache_A[BLOCK_SIZE / sizeof(T) - 1] = cache_A_aux[0];
+					cache_A[BLOCK_SIZE / sizeof(T) - 1] =
+					    cache_A_aux[0];
 				}
-
 				// Compute GEMV
 				gemv(cache_C, cache_A, cache_B, pos);
 
@@ -118,49 +140,51 @@ int main() {
 				mram_temp_addr_B += BLOCK_SIZE;
 			}
 
-			mram_read((__mram_ptr void const*) (mram_temp_addr_A), cache_A, BLOCK_SIZE);
+			mram_read((__mram_ptr void const *)(mram_temp_addr_A),
+				  cache_A, BLOCK_SIZE);
 
-
-			if(offset)
-			{
-				for(unsigned int off = 0; off < (BLOCK_SIZE / sizeof(T)) -1; off++)
-				{
+			if (offset) {
+				for (unsigned int off = 0;
+				     off < (BLOCK_SIZE / sizeof(T)) - 1;
+				     off++) {
 
 					cache_A[off] = cache_A[off + 1];
 				}
 
-				mram_read((__mram_ptr void const*) (mram_temp_addr_A + BLOCK_SIZE ), cache_A_aux, 8);
+				mram_read((__mram_ptr void const
+					   *)(mram_temp_addr_A + BLOCK_SIZE),
+					  cache_A_aux, 8);
 
-  			       cache_A[BLOCK_SIZE / sizeof(T) - 1] = cache_A_aux[0];
+				cache_A[BLOCK_SIZE / sizeof(T) - 1] =
+				    cache_A_aux[0];
 			}
 
+			mram_read((__mram_ptr void const *)(mram_temp_addr_B),
+				  cache_B, BLOCK_SIZE);
 
-			mram_read((__mram_ptr void const*) (mram_temp_addr_B), cache_B, BLOCK_SIZE);
-
-			for (j = 0; j < (int) (n_size - n); j++) {
+			for (j = 0; j < (int)(n_size - n); j++) {
 				// Compute GEMV
-				if(j >= (int)(BLOCK_SIZE / sizeof(T))){ 
+				if (j >= (int)(BLOCK_SIZE / sizeof(T))) {
 					printf("error\n");
 					break;
 				}
 				cache_C[pos] += cache_A[j] * cache_B[j];
 			}
 
-
-			mram_temp_addr_A += (BLOCK_SIZE - ((BLOCK_SIZE / sizeof(T)) - (n_size - n)) * sizeof(T));
+			mram_temp_addr_A +=
+			    (BLOCK_SIZE -
+			     ((BLOCK_SIZE / sizeof(T)) -
+			      (n_size - n)) * sizeof(T));
 			mram_temp_addr_B = mram_base_addr_B;
 
-			if(mram_temp_addr_A % 8 != 0)
-			{
+			if (mram_temp_addr_A % 8 != 0) {
 				offset = 1;
-			}
-			else
-			{
+			} else {
 				offset = 0;
 			}
 		}
 		// Write cache to current MRAM block
-		mram_write(cache_C, (__mram_ptr void *) (mram_base_addr_C), 8);
+		mram_write(cache_C, (__mram_ptr void *)(mram_base_addr_C), 8);
 
 		// Update memory address
 		mram_base_addr_C += 2 * sizeof(T);
diff --git a/MLP/host/app.c b/MLP/host/app.c
index 952cb3f..24243bf 100644
--- a/MLP/host/app.c
+++ b/MLP/host/app.c
@@ -27,28 +27,29 @@
 #define DPU_BINARY "./bin/mlp_dpu"
 #endif
 
-static T** A;
-static T* B;
-static T* B_host;
-static T* B_tmp;
-static T* C;
-static T* C_dpu;
+static T **A;
+static T *B;
+static T *B_host;
+static T *B_tmp;
+static T *C;
+static T *C_dpu;
 
 // Create input arrays
-static void init_data(T** A, T* B, T* B_host, unsigned int m_size, unsigned int n_size) {
+static void init_data(T **A, T *B, T *B_host, unsigned int m_size,
+		      unsigned int n_size)
+{
 	for (unsigned int l = 0; l < NUM_LAYERS; l++)
-		for (unsigned int i = 0; i < m_size * n_size; i++){
-			if(i % 100 < 98){
+		for (unsigned int i = 0; i < m_size * n_size; i++) {
+			if (i % 100 < 98) {
 				A[l][i] = 0;
-			}else{
-				A[l][i] = (l+i) % 2;
+			} else {
+				A[l][i] = (l + i) % 2;
 			}
 		}
-	for (unsigned int i = 0; i < n_size; i++){
-		if(i % 50 < 48){
+	for (unsigned int i = 0; i < n_size; i++) {
+		if (i % 50 < 48) {
 			B[i] = 0;
-		}
-		else{
+		} else {
 			B[i] = i % 2;
 		}
 		B_host[i] = B[i];
@@ -56,26 +57,29 @@ static void init_data(T** A, T* B, T* B_host, unsigned int m_size, unsigned int
 }
 
 // Compute output in the host
-static void mlp_host(T* C, T** A, T* B, unsigned int m_size, unsigned int n_size) {
+static void mlp_host(T *C, T **A, T *B, unsigned int m_size,
+		     unsigned int n_size)
+{
 
-	for (unsigned int nl = 0; nl < NUM_LAYERS; nl++){
-		for (unsigned int m = 0; m < m_size; m++){
+	for (unsigned int nl = 0; nl < NUM_LAYERS; nl++) {
+		for (unsigned int m = 0; m < m_size; m++) {
 			C[m] = 0;
 		}
-		for (unsigned int m = 0; m < m_size; m++){
-			for (unsigned int n = 0; n < n_size; n++){
+		for (unsigned int m = 0; m < m_size; m++) {
+			for (unsigned int n = 0; n < n_size; n++) {
 				C[m] += A[nl][m * n_size + n] * B[n];
 			}
 			C[m] = max(0, C[m]);
 		}
-		for (unsigned int n = 0; n < n_size; n++){
+		for (unsigned int n = 0; n < n_size; n++) {
 			B[n] = C[n];
 		}
 	}
 }
 
 // Main of the Host Application
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
 
 	struct Params p = input_params(argc, argv);
 
@@ -97,14 +101,15 @@ int main(int argc, char **argv) {
 	unsigned int n_size = p.n_size;
 
 	// Initialize help data
-	dpu_info = (struct dpu_info_t *) malloc(nr_of_dpus * sizeof(struct dpu_info_t));
-	dpu_arguments_t *input_args = (dpu_arguments_t *) malloc(nr_of_dpus * sizeof(dpu_arguments_t));
+	dpu_info =
+	    (struct dpu_info_t *)malloc(nr_of_dpus * sizeof(struct dpu_info_t));
+	dpu_arguments_t *input_args =
+	    (dpu_arguments_t *) malloc(nr_of_dpus * sizeof(dpu_arguments_t));
 	uint32_t max_rows_per_dpu = 0;
 	uint32_t n_size_pad = n_size;
-	if(n_size % 2 == 1){
+	if (n_size % 2 == 1) {
 		n_size_pad++;
 	}
-
 	// Timer
 	Timer timer;
 	i = 0;
@@ -118,7 +123,10 @@ int main(int argc, char **argv) {
 			rows_per_dpu++;
 		if (rest_rows > 0) {
 			if (i >= rest_rows)
-				prev_rows_dpu = rest_rows * (chunks + 1) + (i - rest_rows) * chunks;
+				prev_rows_dpu =
+				    rest_rows * (chunks + 1) + (i -
+								rest_rows) *
+				    chunks;
 			else
 				prev_rows_dpu = i * (chunks + 1);
 		} else {
@@ -127,7 +135,7 @@ int main(int argc, char **argv) {
 
 		// Keep max rows for parallel transfers
 		uint32_t rows_per_dpu_pad = rows_per_dpu;
-		if (rows_per_dpu_pad % 2 == 1) // 4-byte elements
+		if (rows_per_dpu_pad % 2 == 1)	// 4-byte elements
 			rows_per_dpu_pad++;
 		if (rows_per_dpu_pad > max_rows_per_dpu)
 			max_rows_per_dpu = rows_per_dpu_pad;
@@ -142,14 +150,15 @@ int main(int argc, char **argv) {
 		input_args[i].nr_rows = rows_per_dpu;
 	}
 
-	A = (T**)malloc(NUM_LAYERS * sizeof(T*));
-	for(l = 0; l < NUM_LAYERS; l++)
-		A[l] = (T*)malloc( max_rows_per_dpu * nr_of_dpus * n_size_pad * sizeof(T));
+	A = (T **) malloc(NUM_LAYERS * sizeof(T *));
+	for (l = 0; l < NUM_LAYERS; l++)
+		A[l] =
+		    (T *) malloc(max_rows_per_dpu * nr_of_dpus * n_size_pad *
+				 sizeof(T));
 
-
-	B = (T*)malloc(n_size * sizeof(T));
-	B_host = (T*)malloc(n_size * sizeof(T));
-	C = (T*)malloc(m_size * sizeof(T));
+	B = (T *) malloc(n_size * sizeof(T));
+	B_host = (T *) malloc(n_size * sizeof(T));
+	C = (T *) malloc(m_size * sizeof(T));
 	C_dpu = malloc(max_rows_per_dpu * nr_of_dpus * sizeof(T));
 	B_tmp = malloc(max_rows_per_dpu * nr_of_dpus * sizeof(T));
 
@@ -170,26 +179,36 @@ int main(int argc, char **argv) {
 			input_args[i].max_rows = max_rows_per_dpu;
 			DPU_ASSERT(dpu_prepare_xfer(dpu, input_args + i));
 		}
-		DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, "DPU_INPUT_ARGUMENTS", 0, sizeof(dpu_arguments_t), DPU_XFER_DEFAULT));
-
+		DPU_ASSERT(dpu_push_xfer
+			   (dpu_set, DPU_XFER_TO_DPU, "DPU_INPUT_ARGUMENTS", 0,
+			    sizeof(dpu_arguments_t), DPU_XFER_DEFAULT));
 
 		// Copy input array and vector
 		i = 0;
 		DPU_FOREACH(dpu_set, dpu, i) {
-			DPU_ASSERT(dpu_prepare_xfer(dpu, A[0] + dpu_info[i].prev_rows_dpu * n_size));
+			DPU_ASSERT(dpu_prepare_xfer
+				   (dpu,
+				    A[0] + dpu_info[i].prev_rows_dpu * n_size));
 		}
-		DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, 0, max_rows_per_dpu * n_size_pad * sizeof(T), DPU_XFER_DEFAULT));
+		DPU_ASSERT(dpu_push_xfer
+			   (dpu_set, DPU_XFER_TO_DPU,
+			    DPU_MRAM_HEAP_POINTER_NAME, 0,
+			    max_rows_per_dpu * n_size_pad * sizeof(T),
+			    DPU_XFER_DEFAULT));
 		i = 0;
 		DPU_FOREACH(dpu_set, dpu, i) {
 			DPU_ASSERT(dpu_prepare_xfer(dpu, B));
 		}
-		DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) , n_size_pad * sizeof(T), DPU_XFER_DEFAULT));
+		DPU_ASSERT(dpu_push_xfer
+			   (dpu_set, DPU_XFER_TO_DPU,
+			    DPU_MRAM_HEAP_POINTER_NAME,
+			    max_rows_per_dpu * n_size_pad * sizeof(T),
+			    n_size_pad * sizeof(T), DPU_XFER_DEFAULT));
 		if (rep >= p.n_warmup)
 			stop(&timer, 1);
 
 		// Run kernel on DPUs
-		if (rep >= p.n_warmup)
-		{
+		if (rep >= p.n_warmup) {
 			start(&timer, 2, rep - p.n_warmup);
 #if ENERGY
 			DPU_ASSERT(dpu_probe_start(&probe));
@@ -198,31 +217,38 @@ int main(int argc, char **argv) {
 
 		DPU_ASSERT(dpu_launch(dpu_set, DPU_SYNCHRONOUS));
 
-		if (rep >= p.n_warmup)
-		{
+		if (rep >= p.n_warmup) {
 			stop(&timer, 2);
 #if ENERGY
 			DPU_ASSERT(dpu_probe_stop(&probe));
 #endif
 		}
 
-		for(int lay = 1; lay < NUM_LAYERS; lay++){
+		for (int lay = 1; lay < NUM_LAYERS; lay++) {
 			if (rep >= p.n_warmup)
 				start(&timer, 4, rep - p.n_warmup);
 			i = 0;
 
 			// Copy C_dpu
 			DPU_FOREACH(dpu_set, dpu, i) {
-				DPU_ASSERT(dpu_prepare_xfer(dpu, C_dpu + i * max_rows_per_dpu));
+				DPU_ASSERT(dpu_prepare_xfer
+					   (dpu, C_dpu + i * max_rows_per_dpu));
 			}
-			DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_FROM_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) + n_size_pad * sizeof(T), max_rows_per_dpu * sizeof(T), DPU_XFER_DEFAULT));
+			DPU_ASSERT(dpu_push_xfer
+				   (dpu_set, DPU_XFER_FROM_DPU,
+				    DPU_MRAM_HEAP_POINTER_NAME,
+				    max_rows_per_dpu * n_size_pad * sizeof(T) +
+				    n_size_pad * sizeof(T),
+				    max_rows_per_dpu * sizeof(T),
+				    DPU_XFER_DEFAULT));
 
 			// B = C
 			unsigned int n, j;
 			i = 0;
 			for (n = 0; n < nr_of_dpus; n++) {
 				for (j = 0; j < dpu_info[n].rows_per_dpu; j++) {
-					B_tmp[i] = C_dpu[n * max_rows_per_dpu + j];
+					B_tmp[i] =
+					    C_dpu[n * max_rows_per_dpu + j];
 					i++;
 				}
 			}
@@ -230,20 +256,31 @@ int main(int argc, char **argv) {
 			DPU_FOREACH(dpu_set, dpu, i) {
 				DPU_ASSERT(dpu_prepare_xfer(dpu, B_tmp));
 			}
-			DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) , n_size_pad * sizeof(T), DPU_XFER_DEFAULT));
+			DPU_ASSERT(dpu_push_xfer
+				   (dpu_set, DPU_XFER_TO_DPU,
+				    DPU_MRAM_HEAP_POINTER_NAME,
+				    max_rows_per_dpu * n_size_pad * sizeof(T),
+				    n_size_pad * sizeof(T), DPU_XFER_DEFAULT));
 
 			// Copy next matrix of weights
 			i = 0;
 			DPU_FOREACH(dpu_set, dpu, i) {
-				DPU_ASSERT(dpu_prepare_xfer(dpu, A[lay] + dpu_info[i].prev_rows_dpu * n_size));
+				DPU_ASSERT(dpu_prepare_xfer
+					   (dpu,
+					    A[lay] +
+					    dpu_info[i].prev_rows_dpu *
+					    n_size));
 			}
-			DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, 0, max_rows_per_dpu * n_size_pad * sizeof(T), DPU_XFER_DEFAULT));
+			DPU_ASSERT(dpu_push_xfer
+				   (dpu_set, DPU_XFER_TO_DPU,
+				    DPU_MRAM_HEAP_POINTER_NAME, 0,
+				    max_rows_per_dpu * n_size_pad * sizeof(T),
+				    DPU_XFER_DEFAULT));
 
-			if(rep >= p.n_warmup)
+			if (rep >= p.n_warmup)
 				stop(&timer, 4);
 
-			if (rep >= p.n_warmup)
-			{
+			if (rep >= p.n_warmup) {
 				start(&timer, 2, rep - p.n_warmup);
 #if ENERGY
 				DPU_ASSERT(dpu_probe_start(&probe));
@@ -252,8 +289,7 @@ int main(int argc, char **argv) {
 
 			DPU_ASSERT(dpu_launch(dpu_set, DPU_SYNCHRONOUS));
 
-			if (rep >= p.n_warmup)
-			{
+			if (rep >= p.n_warmup) {
 				stop(&timer, 2);
 #if ENERGY
 				DPU_ASSERT(dpu_probe_stop(&probe));
@@ -273,16 +309,23 @@ int main(int argc, char **argv) {
 			start(&timer, 3, rep - p.n_warmup);
 		i = 0;
 		DPU_FOREACH(dpu_set, dpu, i) {
-			DPU_ASSERT(dpu_prepare_xfer(dpu, C_dpu + i * max_rows_per_dpu));
+			DPU_ASSERT(dpu_prepare_xfer
+				   (dpu, C_dpu + i * max_rows_per_dpu));
 		}
-		DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_FROM_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) + n_size_pad * sizeof(T), max_rows_per_dpu * sizeof(T), DPU_XFER_DEFAULT));
-		if(rep >= p.n_warmup)
+		DPU_ASSERT(dpu_push_xfer
+			   (dpu_set, DPU_XFER_FROM_DPU,
+			    DPU_MRAM_HEAP_POINTER_NAME,
+			    max_rows_per_dpu * n_size_pad * sizeof(T) +
+			    n_size_pad * sizeof(T),
+			    max_rows_per_dpu * sizeof(T), DPU_XFER_DEFAULT));
+		if (rep >= p.n_warmup)
 			stop(&timer, 3);
 	}
 
 #if ENERGY
 	double acc_energy, avg_energy, acc_time, avg_time;
-	DPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_ACCUMULATE, &acc_energy));
+	DPU_ASSERT(dpu_probe_get
+		   (&probe, DPU_ENERGY, DPU_ACCUMULATE, &acc_energy));
 	DPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_AVERAGE, &avg_energy));
 	DPU_ASSERT(dpu_probe_get(&probe, DPU_TIME, DPU_ACCUMULATE, &acc_time));
 	DPU_ASSERT(dpu_probe_get(&probe, DPU_TIME, DPU_AVERAGE, &avg_time));
@@ -311,23 +354,26 @@ int main(int argc, char **argv) {
 	i = 0;
 	for (n = 0; n < nr_of_dpus; n++) {
 		for (j = 0; j < dpu_info[n].rows_per_dpu; j++) {
-			if(C[i] != C_dpu[n * max_rows_per_dpu + j]) {
+			if (C[i] != C_dpu[n * max_rows_per_dpu + j]) {
 				status = false;
 #if PRINT
-				printf("%d: %d -- %d\n", i, C[i], C_dpu[n * max_rows_per_dpu + j]);
+				printf("%d: %d -- %d\n", i, C[i],
+				       C_dpu[n * max_rows_per_dpu + j]);
 #endif
 			}
 			i++;
 		}
 	}
 	if (status) {
-		printf("[" ANSI_COLOR_GREEN "OK" ANSI_COLOR_RESET "] Outputs are equal\n");
+		printf("[" ANSI_COLOR_GREEN "OK" ANSI_COLOR_RESET
+		       "] Outputs are equal\n");
 	} else {
-		printf("[" ANSI_COLOR_RED "ERROR" ANSI_COLOR_RESET "] Outputs differ!\n");
+		printf("[" ANSI_COLOR_RED "ERROR" ANSI_COLOR_RESET
+		       "] Outputs differ!\n");
 	}
 
 	// Deallocation
-	for(i = 0; i < NUM_LAYERS; i++)
+	for (i = 0; i < NUM_LAYERS; i++)
 		free(A[i]);
 	free(A);
 	free(B);
diff --git a/MLP/support/common.h b/MLP/support/common.h
index 53b2f1c..4b5031b 100755
--- a/MLP/support/common.h
+++ b/MLP/support/common.h
@@ -3,21 +3,21 @@
 
 // Structures used by both the host and the dpu to communicate information 
 typedef struct {
-    uint32_t n_size;
-    uint32_t n_size_pad;
-    uint32_t nr_rows;
-    uint32_t max_rows;
+	uint32_t n_size;
+	uint32_t n_size_pad;
+	uint32_t nr_rows;
+	uint32_t max_rows;
 } dpu_arguments_t;
 
 // Specific information for each DPU
 struct dpu_info_t {
-  uint32_t rows_per_dpu;
-  uint32_t rows_per_dpu_pad;
-  uint32_t prev_rows_dpu;
+	uint32_t rows_per_dpu;
+	uint32_t rows_per_dpu_pad;
+	uint32_t prev_rows_dpu;
 };
 struct dpu_info_t *dpu_info;
 
-#define NUM_LAYERS 3 
+#define NUM_LAYERS 3
 #define max(x, y) (x > y ? x : y)
 #define min(x, y) (x < y ? x : y)
 
diff --git a/MLP/support/params.h b/MLP/support/params.h
index f9e790e..4bfc2fc 100644
--- a/MLP/support/params.h
+++ b/MLP/support/params.h
@@ -4,53 +4,62 @@
 #include "common.h"
 
 typedef struct Params {
-    unsigned int  m_size;
-    unsigned int  n_size;
-    unsigned int  n_warmup;
-    unsigned int  n_reps;
-}Params;
+	unsigned int m_size;
+	unsigned int n_size;
+	unsigned int n_warmup;
+	unsigned int n_reps;
+} Params;
 
-static void usage() {
-    fprintf(stderr,
-            "\nUsage:  ./program [options]"
-            "\n"
-            "\nGeneral options:"
-            "\n    -h        help"
-            "\n    -w <W>    # of untimed warmup iterations (default=1)"
-            "\n    -e <E>    # of timed repetition iterations (default=3)"
-            "\n"
-            "\nBenchmark-specific options:"
-            "\n    -m <I>    m_size (default=2048 elements)"
-            "\n    -n <I>    n_size (default=2048 elements)"
-            "\n");
+static void usage()
+{
+	fprintf(stderr,
+		"\nUsage:  ./program [options]"
+		"\n"
+		"\nGeneral options:"
+		"\n    -h        help"
+		"\n    -w <W>    # of untimed warmup iterations (default=1)"
+		"\n    -e <E>    # of timed repetition iterations (default=3)"
+		"\n"
+		"\nBenchmark-specific options:"
+		"\n    -m <I>    m_size (default=2048 elements)"
+		"\n    -n <I>    n_size (default=2048 elements)" "\n");
 }
 
-struct Params input_params(int argc, char **argv) {
-    struct Params p;
-    p.m_size        = 163840;
-    p.n_size        = 4096;
-    p.n_warmup      = 1;
-    p.n_reps        = 3;
+struct Params input_params(int argc, char **argv)
+{
+	struct Params p;
+	p.m_size = 163840;
+	p.n_size = 4096;
+	p.n_warmup = 1;
+	p.n_reps = 3;
 
-    int opt;
-    while((opt = getopt(argc, argv, "hm:n:w:e:")) >= 0) {
-        switch(opt) {
-            case 'h':
-                usage();
-                exit(0);
-                break;
-            case 'm': p.m_size        = atoi(optarg); break;
-            case 'n': p.n_size        = atoi(optarg); break;
-            case 'w': p.n_warmup      = atoi(optarg); break;
-            case 'e': p.n_reps        = atoi(optarg); break;
-            default:
-                      fprintf(stderr, "\nUnrecognized option!\n");
-                      usage();
-                      exit(0);
-        }
-    }
-    assert(NR_DPUS > 0 && "Invalid # of dpus!");
+	int opt;
+	while ((opt = getopt(argc, argv, "hm:n:w:e:")) >= 0) {
+		switch (opt) {
+		case 'h':
+			usage();
+			exit(0);
+			break;
+		case 'm':
+			p.m_size = atoi(optarg);
+			break;
+		case 'n':
+			p.n_size = atoi(optarg);
+			break;
+		case 'w':
+			p.n_warmup = atoi(optarg);
+			break;
+		case 'e':
+			p.n_reps = atoi(optarg);
+			break;
+		default:
+			fprintf(stderr, "\nUnrecognized option!\n");
+			usage();
+			exit(0);
+		}
+	}
+	assert(NR_DPUS > 0 && "Invalid # of dpus!");
 
-    return p;
+	return p;
 }
 #endif
diff --git a/MLP/support/timer.h b/MLP/support/timer.h
index 886380a..961ed11 100755
--- a/MLP/support/timer.h
+++ b/MLP/support/timer.h
@@ -1,62 +1,69 @@
-/*

- * Copyright (c) 2016 University of Cordoba and University of Illinois

- * All rights reserved.

- *

- * Developed by:    IMPACT Research Group

- *                  University of Cordoba and University of Illinois

- *                  http://impact.crhc.illinois.edu/

- *

- * Permission is hereby granted, free of charge, to any person obtaining a copy

- * of this software and associated documentation files (the "Software"), to deal

- * with the Software without restriction, including without limitation the 

- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

- * sell copies of the Software, and to permit persons to whom the Software is

- * furnished to do so, subject to the following conditions:

- *

- *      > Redistributions of source code must retain the above copyright notice,

- *        this list of conditions and the following disclaimers.

- *      > Redistributions in binary form must reproduce the above copyright

- *        notice, this list of conditions and the following disclaimers in the

- *        documentation and/or other materials provided with the distribution.

- *      > Neither the names of IMPACT Research Group, University of Cordoba, 

- *        University of Illinois nor the names of its contributors may be used 

- *        to endorse or promote products derived from this Software without 

- *        specific prior written permission.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 

- * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH

- * THE SOFTWARE.

- *

- */

-

-#include <sys/time.h>

-

-typedef struct Timer{

-

-    struct timeval startTime[5];

-    struct timeval stopTime[5];

-    double         time[5];

-

-}Timer;

-

-void start(Timer *timer, int i, int rep) {

-    if(rep == 0) {

-        timer->time[i] = 0.0;

-    }

-    gettimeofday(&timer->startTime[i], NULL);

-}

-

-void stop(Timer *timer, int i) {

-    gettimeofday(&timer->stopTime[i], NULL);

-    timer->time[i] += (timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +

-                      (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec);

-    //printf("Time (ms): %f\t",((timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +

-    //                  (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec)) / 1000);

- 

-}

-

-void print(Timer *timer, int i, int REP) { printf("%f\t", timer->time[i] / (1000 * REP)); }

+/*
+ * Copyright (c) 2016 University of Cordoba and University of Illinois
+ * All rights reserved.
+ *
+ * Developed by:    IMPACT Research Group
+ *                  University of Cordoba and University of Illinois
+ *                  http://impact.crhc.illinois.edu/
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * with the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ *      > Redistributions of source code must retain the above copyright notice,
+ *        this list of conditions and the following disclaimers.
+ *      > Redistributions in binary form must reproduce the above copyright
+ *        notice, this list of conditions and the following disclaimers in the
+ *        documentation and/or other materials provided with the distribution.
+ *      > Neither the names of IMPACT Research Group, University of Cordoba,
+ *        University of Illinois nor the names of its contributors may be used
+ *        to endorse or promote products derived from this Software without
+ *        specific prior written permission.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH
+ * THE SOFTWARE.
+ *
+ */
+
+#include <sys/time.h>
+
+typedef struct Timer {
+
+	struct timeval startTime[5];
+	struct timeval stopTime[5];
+	double time[5];
+
+} Timer;
+
+void start(Timer *timer, int i, int rep)
+{
+	if (rep == 0) {
+		timer->time[i] = 0.0;
+	}
+	gettimeofday(&timer->startTime[i], NULL);
+}
+
+void stop(Timer *timer, int i)
+{
+	gettimeofday(&timer->stopTime[i], NULL);
+	timer->time[i] +=
+	    (timer->stopTime[i].tv_sec -
+	     timer->startTime[i].tv_sec) * 1000000.0 +
+	    (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec);
+	//printf("Time (ms): %f\t",((timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +
+	//                  (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec)) / 1000);
+
+}
+
+void print(Timer *timer, int i, int REP)
+{
+	printf("%f\t", timer->time[i] / (1000 * REP));
+}