HST-S: indent -linux

1 files changed, 311 insertions, 277 deletions

diff --git a/HST-S/baselines/cpu/app_baseline.c b/HST-S/baselines/cpu/app_baseline.c
index 745e384..bb4e28a 100644
--- a/HST-S/baselines/cpu/app_baseline.c
+++ b/HST-S/baselines/cpu/app_baseline.c
@@ -24,10 +24,10 @@
 #include <numaif.h>
 #include <numa.h>
 
-struct bitmask* bitmask_in;
-struct bitmask* bitmask_out;
+struct bitmask *bitmask_in;
+struct bitmask *bitmask_out;
 
-void* mp_pages[1];
+void *mp_pages[1];
 int mp_status[1];
 int mp_nodes[1];
 int numa_node_in = -1;
@@ -41,7 +41,6 @@ int numa_node_local = -1;
 int numa_node_in_is_local = 0;
 #endif
 
-
 #include "../../support/common.h"
 #include "../../support/timer.h"
 
@@ -49,364 +48,399 @@ int numa_node_in_is_local = 0;
 #define STR(x) #x
 
 // Pointer declaration
-static T* A;
+static T *A;
 static T *A_local;
-static unsigned int* histo_host;
+static unsigned int *histo_host;
 
 typedef struct Params {
-    unsigned int   input_size;
-    unsigned int   bins;
-    int   n_warmup;
-    int   n_reps;
-    const char *file_name;
-    int  exp;
-    int  n_threads;
+	unsigned int input_size;
+	unsigned int bins;
+	int n_warmup;
+	int n_reps;
+	const char *file_name;
+	int exp;
+	int n_threads;
 #if NUMA
-    struct bitmask* bitmask_in;
-    struct bitmask* bitmask_out;
-    int numa_node_cpu;
+	struct bitmask *bitmask_in;
+	struct bitmask *bitmask_out;
+	int numa_node_cpu;
 #endif
 #if NUMA_MEMCPY
-    int numa_node_cpu_memcpy;
-    struct bitmask* bitmask_cpu;
+	int numa_node_cpu_memcpy;
+	struct bitmask *bitmask_cpu;
 #endif
-}Params;
+} Params;
 
 /**
 * @brief creates input arrays
 * @param nr_elements how many elements in input arrays
 */
-static void read_input(T* A, const Params p) {
-
-    char  dctFileName[100];
-    FILE *File = NULL;
-
-    // Open input file
-    unsigned short temp;
-    sprintf(dctFileName, "%s", p.file_name);
-    if((File = fopen(dctFileName, "rb")) != NULL) {
-        for(unsigned int y = 0; y < p.input_size; y++) {
-            if (fread(&temp, sizeof(unsigned short), 1, File) == 1) {
-                A[y] = (unsigned int)ByteSwap16(temp);
-                if(A[y] >= 4096)
-                    A[y] = 4095;
-            } else {
-                //printf("out of bounds read at offset %d -- seeking back to 0\n", y);
-                rewind(File);
-            }
-        }
-        fclose(File);
-    } else {
-        printf("%s does not exist\n", dctFileName);
-        exit(1);
-    }
+static void read_input(T *A, const Params p)
+{
+
+	char dctFileName[100];
+	FILE *File = NULL;
+
+	// Open input file
+	unsigned short temp;
+	sprintf(dctFileName, "%s", p.file_name);
+	if ((File = fopen(dctFileName, "rb")) != NULL) {
+		for (unsigned int y = 0; y < p.input_size; y++) {
+			if (fread(&temp, sizeof(unsigned short), 1, File) == 1) {
+				A[y] = (unsigned int)ByteSwap16(temp);
+				if (A[y] >= 4096)
+					A[y] = 4095;
+			} else {
+				//printf("out of bounds read at offset %d -- seeking back to 0\n", y);
+				rewind(File);
+			}
+		}
+		fclose(File);
+	} else {
+		printf("%s does not exist\n", dctFileName);
+		exit(1);
+	}
 }
 
 /**
 * @brief compute output in the host
 */
-static void histogram_host(unsigned int* histo, T* A, unsigned int bins, unsigned int nr_elements, int exp, unsigned int nr_of_dpus, int t) {
-
-    omp_set_num_threads(t);
-
-    if(!exp){
-        #pragma omp parallel for
-        for (unsigned int i = 0; i < nr_of_dpus; i++) {
-            for (unsigned int j = 0; j < nr_elements; j++) {
-                T d = A[j];
-                histo[i * bins + ((d * bins) >> DEPTH)] += 1;
-            }
-        }
-    }
-    else{
-        #pragma omp parallel for
-        for (unsigned int j = 0; j < nr_elements; j++) {
-            T d = A[j];
-            #pragma omp atomic update
-            histo[(d * bins) >> DEPTH] += 1;
-        }
-    }
+static void histogram_host(unsigned int *histo, T *A, unsigned int bins,
+			   unsigned int nr_elements, int exp,
+			   unsigned int nr_of_dpus, int t)
+{
+
+	omp_set_num_threads(t);
+
+	if (!exp) {
+#pragma omp parallel for
+		for (unsigned int i = 0; i < nr_of_dpus; i++) {
+			for (unsigned int j = 0; j < nr_elements; j++) {
+				T d = A[j];
+				histo[i * bins + ((d * bins) >> DEPTH)] += 1;
+			}
+		}
+	} else {
+#pragma omp parallel for
+		for (unsigned int j = 0; j < nr_elements; j++) {
+			T d = A[j];
+#pragma omp atomic update
+			histo[(d * bins) >> DEPTH] += 1;
+		}
+	}
 }
 
 // Params ---------------------------------------------------------------------
-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    -t <T>    # of threads (default=8)"
-        "\n    -x <X>    Weak (0) or strong (1) scaling (default=0)"
-        "\n"
-        "\nBenchmark-specific options:"
-        "\n    -i <I>    input size (default=1536*1024 elements)"
-        "\n    -b <B>    histogram size (default=256 bins)"
-        "\n    -f <F>    input image file (default=../input/image_VanHateren.iml)"
-        "\n");
+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    -t <T>    # of threads (default=8)"
+		"\n    -x <X>    Weak (0) or strong (1) scaling (default=0)"
+		"\n"
+		"\nBenchmark-specific options:"
+		"\n    -i <I>    input size (default=1536*1024 elements)"
+		"\n    -b <B>    histogram size (default=256 bins)"
+		"\n    -f <F>    input image file (default=../input/image_VanHateren.iml)"
+		"\n");
 }
 
-struct Params input_params(int argc, char **argv) {
-    struct Params p;
-    p.input_size    = 1536 * 1024;
-    p.bins          = 256;
-    p.n_warmup      = 1;
-    p.n_reps        = 3;
-    p.n_threads     = 8;
-    p.exp           = 1;
-    p.file_name     = "../../input/image_VanHateren.iml";
+struct Params input_params(int argc, char **argv)
+{
+	struct Params p;
+	p.input_size = 1536 * 1024;
+	p.bins = 256;
+	p.n_warmup = 1;
+	p.n_reps = 3;
+	p.n_threads = 8;
+	p.exp = 1;
+	p.file_name = "../../input/image_VanHateren.iml";
 #if NUMA
-    p.bitmask_in     = NULL;
-    p.bitmask_out    = NULL;
-    p.numa_node_cpu = -1;
+	p.bitmask_in = NULL;
+	p.bitmask_out = NULL;
+	p.numa_node_cpu = -1;
 #endif
 #if NUMA_MEMCPY
-    p.numa_node_cpu_memcpy  = -1;
-    p.bitmask_cpu    = NULL;
+	p.numa_node_cpu_memcpy = -1;
+	p.bitmask_cpu = NULL;
 #endif
 
-    int opt;
-    while((opt = getopt(argc, argv, "hi:b:w:e:f:x:t:A:B:C:D:M:")) >= 0) {
-        switch(opt) {
-        case 'h':
-        usage();
-        exit(0);
-        break;
-        case 'i': p.input_size    = atoi(optarg); break;
-        case 'b': p.bins          = atoi(optarg); break;
-        case 'w': p.n_warmup      = atoi(optarg); break;
-        case 'e': p.n_reps        = atoi(optarg); break;
-        case 'f': p.file_name     = optarg; break;
-        case 'x': p.exp           = atoi(optarg); break;
-        case 't': p.n_threads     = atoi(optarg); break;
+	int opt;
+	while ((opt = getopt(argc, argv, "hi:b:w:e:f:x:t:A:B:C:D:M:")) >= 0) {
+		switch (opt) {
+		case 'h':
+			usage();
+			exit(0);
+			break;
+		case 'i':
+			p.input_size = atoi(optarg);
+			break;
+		case 'b':
+			p.bins = atoi(optarg);
+			break;
+		case 'w':
+			p.n_warmup = atoi(optarg);
+			break;
+		case 'e':
+			p.n_reps = atoi(optarg);
+			break;
+		case 'f':
+			p.file_name = optarg;
+			break;
+		case 'x':
+			p.exp = atoi(optarg);
+			break;
+		case 't':
+			p.n_threads = atoi(optarg);
+			break;
 #if NUMA
-        case 'A': p.bitmask_in    = numa_parse_nodestring(optarg); break;
-        case 'B': p.bitmask_out   = numa_parse_nodestring(optarg); break;
-        case 'C': p.numa_node_cpu = atoi(optarg); break;
+		case 'A':
+			p.bitmask_in = numa_parse_nodestring(optarg);
+			break;
+		case 'B':
+			p.bitmask_out = numa_parse_nodestring(optarg);
+			break;
+		case 'C':
+			p.numa_node_cpu = atoi(optarg);
+			break;
 #if NUMA_MEMCPY
-        case 'D': p.bitmask_cpu   = numa_parse_nodestring(optarg); break;
-        case 'M': p.numa_node_cpu_memcpy = atoi(optarg); break;
-#endif // NUMA_MEMCPY
-#endif // NUMA
-        default:
-            fprintf(stderr, "\nUnrecognized option!\n");
-            usage();
-            exit(0);
-        }
-    }
-    assert(p.n_threads > 0 && "Invalid # of ranks!");
-
-    return p;
+		case 'D':
+			p.bitmask_cpu = numa_parse_nodestring(optarg);
+			break;
+		case 'M':
+			p.numa_node_cpu_memcpy = atoi(optarg);
+			break;
+#endif				// NUMA_MEMCPY
+#endif				// NUMA
+		default:
+			fprintf(stderr, "\nUnrecognized option!\n");
+			usage();
+			exit(0);
+		}
+	}
+	assert(p.n_threads > 0 && "Invalid # of ranks!");
+
+	return p;
 }
 
 /**
 * @brief Main of the Host Application.
 */
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
+
+	struct Params p = input_params(argc, argv);
 
-    struct Params p = input_params(argc, argv);
+	uint32_t nr_of_dpus;
 
-    uint32_t nr_of_dpus;
-    
-    const unsigned int input_size = p.input_size; // Size of input image
-    if(!p.exp)
-        assert(input_size % p.n_threads == 0 && "Input size!");
-    else
-        assert(input_size % p.n_threads == 0 && "Input size!");
+	const unsigned int input_size = p.input_size;	// Size of input image
+	if (!p.exp)
+		assert(input_size % p.n_threads == 0 && "Input size!");
+	else
+		assert(input_size % p.n_threads == 0 && "Input size!");
 
-    // Input/output allocation
+	// Input/output allocation
 #if NUMA
-    if (p.bitmask_in) {
-        numa_set_membind(p.bitmask_in);
-        numa_free_nodemask(p.bitmask_in);
-    }
-    A = numa_alloc(input_size * sizeof(T));
+	if (p.bitmask_in) {
+		numa_set_membind(p.bitmask_in);
+		numa_free_nodemask(p.bitmask_in);
+	}
+	A = numa_alloc(input_size * sizeof(T));
 #else
-    A = malloc(input_size * sizeof(T));
+	A = malloc(input_size * sizeof(T));
 #endif
 
-    // Create an input file with arbitrary data.
-    read_input(A, p);
+	// Create an input file with arbitrary data.
+	read_input(A, p);
 
 #if NUMA
-    if (p.bitmask_out) {
-        numa_set_membind(p.bitmask_out);
-        numa_free_nodemask(p.bitmask_out);
-    }
+	if (p.bitmask_out) {
+		numa_set_membind(p.bitmask_out);
+		numa_free_nodemask(p.bitmask_out);
+	}
 #endif
-    if(!p.exp) {
-        // upstream code left nr_of_dpus uninitialized
-        nr_of_dpus = p.n_threads;
+	if (!p.exp) {
+		// upstream code left nr_of_dpus uninitialized
+		nr_of_dpus = p.n_threads;
 #if NUMA
-        histo_host = numa_alloc(nr_of_dpus * p.bins * sizeof(unsigned int));
+		histo_host =
+		    numa_alloc(nr_of_dpus * p.bins * sizeof(unsigned int));
 #else
-        histo_host = malloc(nr_of_dpus * p.bins * sizeof(unsigned int));
+		histo_host = malloc(nr_of_dpus * p.bins * sizeof(unsigned int));
 #endif
-    } else {
+	} else {
 #if NUMA
-        histo_host = numa_alloc(p.bins * sizeof(unsigned int));
+		histo_host = numa_alloc(p.bins * sizeof(unsigned int));
 #else
-        histo_host = malloc(p.bins * sizeof(unsigned int));
+		histo_host = malloc(p.bins * sizeof(unsigned int));
 #endif
-    }
+	}
 
 #if NUMA
 #if NUMA_MEMCPY
-    if (p.bitmask_cpu) {
-        numa_set_membind(p.bitmask_cpu);
-        numa_free_nodemask(p.bitmask_cpu);
-    }
+	if (p.bitmask_cpu) {
+		numa_set_membind(p.bitmask_cpu);
+		numa_free_nodemask(p.bitmask_cpu);
+	}
 #else
-    struct bitmask *bitmask_all = numa_allocate_nodemask();
-    numa_bitmask_setall(bitmask_all);
-    numa_set_membind(bitmask_all);
-    numa_free_nodemask(bitmask_all);
-#endif // NUMA_MEMCPY
-#endif // NUMA
+	struct bitmask *bitmask_all = numa_allocate_nodemask();
+	numa_bitmask_setall(bitmask_all);
+	numa_set_membind(bitmask_all);
+	numa_free_nodemask(bitmask_all);
+#endif				// NUMA_MEMCPY
+#endif				// NUMA
 
 #if NUMA
-    mp_pages[0] = A;
-    if (move_pages(0, 1, mp_pages, NULL, mp_status, 0) == -1) {
-        perror("move_pages(A)");
-    }
-    else if (mp_status[0] < 0) {
-        printf("move_pages error: %d", mp_status[0]);
-    }
-    else {
-        numa_node_in = mp_status[0];
-    }
-
-    mp_pages[0] = histo_host;
-    if (move_pages(0, 1, mp_pages, NULL, mp_status, 0) == -1) {
-        perror("move_pages(C)");
-    }
-    else if (mp_status[0] < 0) {
-        printf("move_pages error: %d", mp_status[0]);
-    }
-    else {
-        numa_node_out = mp_status[0];
-    }
-
-    numa_node_cpu = p.numa_node_cpu;
-    if (numa_node_cpu != -1) {
-        if (numa_run_on_node(numa_node_cpu) == -1) {
-            perror("numa_run_on_node");
-            numa_node_cpu = -1;
-        }
-    }
+	mp_pages[0] = A;
+	if (move_pages(0, 1, mp_pages, NULL, mp_status, 0) == -1) {
+		perror("move_pages(A)");
+	} else if (mp_status[0] < 0) {
+		printf("move_pages error: %d", mp_status[0]);
+	} else {
+		numa_node_in = mp_status[0];
+	}
+
+	mp_pages[0] = histo_host;
+	if (move_pages(0, 1, mp_pages, NULL, mp_status, 0) == -1) {
+		perror("move_pages(C)");
+	} else if (mp_status[0] < 0) {
+		printf("move_pages error: %d", mp_status[0]);
+	} else {
+		numa_node_out = mp_status[0];
+	}
+
+	numa_node_cpu = p.numa_node_cpu;
+	if (numa_node_cpu != -1) {
+		if (numa_run_on_node(numa_node_cpu) == -1) {
+			perror("numa_run_on_node");
+			numa_node_cpu = -1;
+		}
+	}
 #endif
 
 #if NUMA_MEMCPY
-    numa_node_in_is_local = ((numa_node_cpu == numa_node_in) || (numa_node_cpu + 8 == numa_node_in)) * 1;
+	numa_node_in_is_local = ((numa_node_cpu == numa_node_in)
+				 || (numa_node_cpu + 8 == numa_node_in)) * 1;
 #endif
 
-    Timer timer;
+	Timer timer;
 
 #if NUMA_MEMCPY
-    numa_node_cpu_memcpy = p.numa_node_cpu_memcpy;
-    start(&timer, 1, 0);
-    if (!numa_node_in_is_local) {
-        A_local = (T*) numa_alloc(input_size * sizeof(T));
-    }
-    stop(&timer, 1);
-    if (!numa_node_in_is_local) {
-        if (p.numa_node_cpu_memcpy != -1) {
-            if (numa_run_on_node(p.numa_node_cpu_memcpy) == -1) {
-                perror("numa_run_on_node");
-                numa_node_cpu_memcpy = -1;
-            }
-        }
-    }
-    start(&timer, 2, 0);
-    if (!numa_node_in_is_local) {
-        memcpy(A_local, A, input_size * sizeof(T));
-    } else {
-        A_local = A;
-    }
-    stop(&timer, 2);
-    if (p.numa_node_cpu != -1) {
-        if (numa_run_on_node(p.numa_node_cpu) == -1) {
-            perror("numa_run_on_node");
-            numa_node_cpu = -1;
-        }
-    }
-    mp_pages[0] = A_local;
-    if (move_pages(0, 1, mp_pages, NULL, mp_status, 0) == -1) {
-        perror("move_pages(A_local)");
-    }
-    else if (mp_status[0] < 0) {
-        printf("move_pages error: %d", mp_status[0]);
-    }
-    else {
-        numa_node_local = mp_status[0];
-    }
+	numa_node_cpu_memcpy = p.numa_node_cpu_memcpy;
+	start(&timer, 1, 0);
+	if (!numa_node_in_is_local) {
+		A_local = (T *) numa_alloc(input_size * sizeof(T));
+	}
+	stop(&timer, 1);
+	if (!numa_node_in_is_local) {
+		if (p.numa_node_cpu_memcpy != -1) {
+			if (numa_run_on_node(p.numa_node_cpu_memcpy) == -1) {
+				perror("numa_run_on_node");
+				numa_node_cpu_memcpy = -1;
+			}
+		}
+	}
+	start(&timer, 2, 0);
+	if (!numa_node_in_is_local) {
+		memcpy(A_local, A, input_size * sizeof(T));
+	} else {
+		A_local = A;
+	}
+	stop(&timer, 2);
+	if (p.numa_node_cpu != -1) {
+		if (numa_run_on_node(p.numa_node_cpu) == -1) {
+			perror("numa_run_on_node");
+			numa_node_cpu = -1;
+		}
+	}
+	mp_pages[0] = A_local;
+	if (move_pages(0, 1, mp_pages, NULL, mp_status, 0) == -1) {
+		perror("move_pages(A_local)");
+	} else if (mp_status[0] < 0) {
+		printf("move_pages error: %d", mp_status[0]);
+	} else {
+		numa_node_local = mp_status[0];
+	}
 #else
-    A_local = A;
+	A_local = A;
 #endif
 
-    start(&timer, 0, 0);
+	start(&timer, 0, 0);
 
-    if(!p.exp)
-        memset(histo_host, 0, nr_of_dpus * p.bins * sizeof(unsigned int));
-    else
-        memset(histo_host, 0, p.bins * sizeof(unsigned int));
+	if (!p.exp)
+		memset(histo_host, 0,
+		       nr_of_dpus * p.bins * sizeof(unsigned int));
+	else
+		memset(histo_host, 0, p.bins * sizeof(unsigned int));
 
-    histogram_host(histo_host, A_local, p.bins, input_size, p.exp, nr_of_dpus, p.n_threads);
+	histogram_host(histo_host, A_local, p.bins, input_size, p.exp,
+		       nr_of_dpus, p.n_threads);
 
-    stop(&timer, 0);
+	stop(&timer, 0);
 
 #if NUMA_MEMCPY
-    start(&timer, 3, 0);
-    if (!numa_node_in_is_local) {
-        numa_free(A_local, input_size * sizeof(T));
-    }
-    stop(&timer, 3);
+	start(&timer, 3, 0);
+	if (!numa_node_in_is_local) {
+		numa_free(A_local, input_size * sizeof(T));
+	}
+	stop(&timer, 3);
 #endif
 
-    unsigned int nr_threads = 0;
+	unsigned int nr_threads = 0;
 #pragma omp parallel
 #pragma omp atomic
-    nr_threads++;
+	nr_threads++;
 
 #if NUMA_MEMCPY
-    printf("[::] HST-S-CPU-MEMCPY | n_threads=%d e_type=%s n_elements=%d n_bins=%d"
-        " numa_node_in=%d numa_node_local=%d numa_node_out=%d numa_node_cpu=%d numa_node_cpu_memcpy=%d numa_distance_in_cpu=%d numa_distance_cpu_out=%d"
-        " | throughput_MBps=%f",
-        nr_threads, XSTR(T), input_size, p.exp ? p.bins : p.bins * nr_of_dpus,
-        numa_node_in, numa_node_local, numa_node_out, numa_node_cpu, numa_node_cpu_memcpy, numa_distance(numa_node_in, numa_node_cpu), numa_distance(numa_node_cpu, numa_node_out),
-        input_size * sizeof(T) / timer.time[0]);
-    printf(" throughput_MOpps=%f",
-        input_size / timer.time[0]);
-    printf(" latency_kernel_us=%f latency_alloc_us=%f latency_memcpy_us=%f latency_free_us=%f latency_total_us=%f\n",
-        timer.time[0], timer.time[1], timer.time[2], timer.time[3],
-        timer.time[0] + timer.time[1] + timer.time[2] + timer.time[3]);
+	printf
+	    ("[::] HST-S-CPU-MEMCPY | n_threads=%d e_type=%s n_elements=%d n_bins=%d"
+	     " numa_node_in=%d numa_node_local=%d numa_node_out=%d numa_node_cpu=%d numa_node_cpu_memcpy=%d numa_distance_in_cpu=%d numa_distance_cpu_out=%d"
+	     " | throughput_MBps=%f", nr_threads, XSTR(T), input_size,
+	     p.exp ? p.bins : p.bins * nr_of_dpus, numa_node_in,
+	     numa_node_local, numa_node_out, numa_node_cpu,
+	     numa_node_cpu_memcpy, numa_distance(numa_node_in, numa_node_cpu),
+	     numa_distance(numa_node_cpu, numa_node_out),
+	     input_size * sizeof(T) / timer.time[0]);
+	printf(" throughput_MOpps=%f", input_size / timer.time[0]);
+	printf
+	    (" latency_kernel_us=%f latency_alloc_us=%f latency_memcpy_us=%f latency_free_us=%f latency_total_us=%f\n",
+	     timer.time[0], timer.time[1], timer.time[2], timer.time[3],
+	     timer.time[0] + timer.time[1] + timer.time[2] + timer.time[3]);
 #else
-    printf("[::] HST-S-CPU | n_threads=%d e_type=%s n_elements=%d n_bins=%d"
+	printf("[::] HST-S-CPU | n_threads=%d e_type=%s n_elements=%d n_bins=%d"
 #if NUMA
-        " numa_node_in=%d numa_node_out=%d numa_node_cpu=%d numa_distance_in_cpu=%d numa_distance_cpu_out=%d"
+	       " numa_node_in=%d numa_node_out=%d numa_node_cpu=%d numa_distance_in_cpu=%d numa_distance_cpu_out=%d"
 #endif
-        " | throughput_MBps=%f",
-        nr_threads, XSTR(T), input_size, p.exp ? p.bins : p.bins * nr_of_dpus,
+	       " | throughput_MBps=%f",
+	       nr_threads, XSTR(T), input_size,
+	       p.exp ? p.bins : p.bins * nr_of_dpus,
 #if NUMA
-        numa_node_in, numa_node_out, numa_node_cpu, numa_distance(numa_node_in, numa_node_cpu), numa_distance(numa_node_cpu, numa_node_out),
+	       numa_node_in, numa_node_out, numa_node_cpu,
+	       numa_distance(numa_node_in, numa_node_cpu),
+	       numa_distance(numa_node_cpu, numa_node_out),
 #endif
-        input_size * sizeof(T) / timer.time[0]);
-    printf(" throughput_MOpps=%f latency_us=%f\n",
-        input_size / timer.time[0], timer.time[0]);
-#endif // NUMA_MEMCPY
+	       input_size * sizeof(T) / timer.time[0]);
+	printf(" throughput_MOpps=%f latency_us=%f\n",
+	       input_size / timer.time[0], timer.time[0]);
+#endif				// NUMA_MEMCPY
 
 #if NUMA
-    numa_free(A, input_size * sizeof(T));
-    if (!p.exp) {
-        numa_free(histo_host, nr_of_dpus * p.bins * sizeof(unsigned int));
-    } else {
-        numa_free(histo_host, p.bins * sizeof(unsigned int));
-    }
+	numa_free(A, input_size * sizeof(T));
+	if (!p.exp) {
+		numa_free(histo_host,
+			  nr_of_dpus * p.bins * sizeof(unsigned int));
+	} else {
+		numa_free(histo_host, p.bins * sizeof(unsigned int));
+	}
 #else
-    free(A);
-    free(histo_host);
+	free(A);
+	free(histo_host);
 #endif
 
-    return 0;
+	return 0;
 }