From b22667c93d1e9405f854c008e3f3a35ab9cfd863 Mon Sep 17 00:00:00 2001
From: M Algah Fattah Illahi <13517122@std.stei.itb.ac.id>
Date: Wed, 25 Mar 2020 22:03:00 +0700
Subject: [PATCH] project init
---
Makefile | 18 +++++
src/boolean.h | 8 ++
src/dijkstra.c | 117 +++++++++++++++++++++++++++
src/dijkstra.h | 43 ++++++++++
src/hello_openmp.c | 20 +++++
src/hellompi.c | 103 ++++++++++++++++++++++++
src/paralel.c | 186 +++++++++++++++++++++++++++++++++++++++++++
src/paralel_openmp.c | 77 ++++++++++++++++++
src/serial.c | 53 ++++++++++++
src/test | Bin 0 -> 17016 bytes
src/test.c | 37 +++++++++
src/util.c | 32 ++++++++
src/util.h | 14 ++++
13 files changed, 708 insertions(+)
create mode 100644 Makefile
create mode 100644 src/boolean.h
create mode 100644 src/dijkstra.c
create mode 100644 src/dijkstra.h
create mode 100644 src/hello_openmp.c
create mode 100644 src/hellompi.c
create mode 100644 src/paralel.c
create mode 100644 src/paralel_openmp.c
create mode 100644 src/serial.c
create mode 100755 src/test
create mode 100644 src/test.c
create mode 100644 src/util.c
create mode 100644 src/util.h
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..c8a4e64
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,18 @@
+serial: ./src/serial.c ./src/dijkstra.* ./src/util.*
+ gcc ./src/serial.c ./src/dijkstra.c ./src/util.c -o ./bin/serial
+ ./bin/serial $(n)
+
+parallel: ./src/paralel.c ./src/util.* ./src/dijkstra.*
+ mpicc ./src/paralel.c ./src/util.c ./src/dijkstra.c -o ./bin/parallel
+ mpirun -np $(np) --hostfile mpi_hostfile ./bin/parallel $(np) $(nv)
+
+run_par: ./bin/parallel
+ mpirun -np $(np) --hostfile mpi_hostfile ./bin/parallel $(np) $(nv)
+
+hello_omp: ./src/hello_openmp.c
+ gcc -g -Wall -fopenmp -o ./bin/hello_omp ./src/hello_openmp.c
+ ./bin/hello_omp $(nt)
+
+parallel_omp: ./src/paralel_openmp.c
+ gcc -g -Wall -fopenmp -o ./bin/parallel_omp ./src/paralel_openmp.c ./src/util.c ./src/dijkstra.c
+ ./bin/parallel_omp $(nt) $(nv)
\ No newline at end of file
diff --git a/src/boolean.h b/src/boolean.h
new file mode 100644
index 0000000..652f1a7
--- /dev/null
+++ b/src/boolean.h
@@ -0,0 +1,8 @@
+#ifndef _BOOLEAN_h
+#define _BOOLEAN_h
+
+#define bool unsigned char
+#define true 1
+#define false 0
+
+#endif
\ No newline at end of file
diff --git a/src/dijkstra.c b/src/dijkstra.c
new file mode 100644
index 0000000..7662d2c
--- /dev/null
+++ b/src/dijkstra.c
@@ -0,0 +1,117 @@
+#include "dijkstra.h"
+
+
+/**
+ * Get vertex index with minimum distance which not yet included
+ * in spt_set
+ * @param dist distance from origin vertex to vertex with that index
+ * @param spt_set a set denoting vertices included in spt_set
+ * @param n number of vertices in the graph
+ * @return index of minimum distance not yet included in spt_set
+ */
+int min_distance_idx(long dist[], bool spt_set[], int n) {
+ // Initialize min value
+ int min = INT_MAX, min_index;
+
+ for (int i = 0; i < n; i++) {
+ if (spt_set[i] == false && dist[i] <= min) {
+ min = dist[i];
+ min_index = i;
+ }
+ }
+
+
+ return min_index;
+}
+
+
+/**
+ * generate a graph with n vertices
+ * @param n number of vertices
+ * @return 2D array, graph[i][j] = graph[j][i] = distance from vertex i to j
+ */
+long **gen_graph(int n) {
+ // alokasi memori untuk matriks yang merepresentasikan graf
+ long **result = (long **)malloc(n * sizeof(long *));
+ for (int i = 0; i < n; i++) {
+ result[i] = (long *)malloc(n * sizeof(long));
+ }
+
+ // isi matriks dengan bilangan random
+ srand(13517122);
+
+ for (int i = 0; i < n; i++) {
+ for (int j = i; j < n; j++) {
+ if (i == j) {
+ result[i][j] = 0;
+ } else {
+ result[i][j] = result[j][i] = rand();
+ }
+
+ }
+ }
+
+ return result;
+}
+
+long **gen_temp(int r, int c) {
+ // alokasi memori untuk matriks yang merepresentasikan graf
+ long **result = (long **)malloc(r * sizeof(long *));
+ // printf("[gen_temp] initiate temp\n");
+ for (int i = 0; i < r; i++) {
+ result[i] = (long *)malloc(c * sizeof(long));
+ // printf("[gen_temp] initiate each row in temp\n");
+ }
+
+ for (int i = 0; i < r; i++) {
+ for (int j = 0; j < c; j++) {
+ // printf("[gen_temp] filling temp\n");
+ result[i][j] = 0;
+ }
+ }
+
+ return result;
+}
+
+
+long *dijkstra(long **graph, int n, int src) {
+
+ // output array, contains shortest distance from src to every vertices
+ long *dist = (long *) malloc (sizeof(long) * n);
+ // spt_set[i] is true if vertex i already included in the shortest path tree
+ bool spt_set[n];
+
+ // initialize dist and spt_set
+ for (int i = 0; i < n; i++) {
+ dist[i] = INT_MAX;
+ spt_set[i] = false;
+ }
+
+ // initiate path searching
+ dist[src] = 0;
+
+
+ // find the shortest path for all vertices
+ for (int i = 0; i < n; i++) {
+
+ // pick vertex with minimum distance from src from spt_set not yet
+ // processed
+ int processed_vertex = min_distance_idx(dist, spt_set, n);
+
+ // mark vertex as processed
+ spt_set[processed_vertex] = true;
+
+ for (int j = 0; j < n; j++) {
+ // check vertices connected to processed_vertex not yet processed
+ if (!spt_set[j]
+ && graph[processed_vertex][j] != 0
+ && dist[processed_vertex] != INT_MAX
+ && dist[processed_vertex] + graph[processed_vertex][j] < dist[j]) {
+
+ dist[j] = dist[processed_vertex] + graph[processed_vertex][j];
+ }
+ }
+ }
+
+ return dist;
+}
\ No newline at end of file
diff --git a/src/dijkstra.h b/src/dijkstra.h
new file mode 100644
index 0000000..00a7aca
--- /dev/null
+++ b/src/dijkstra.h
@@ -0,0 +1,43 @@
+#ifndef DIJKSTRA_H
+#define DIJKSTRA_H
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
+#include "boolean.h"
+
+/**
+ * Get vertex index with minimum distance which not yet included
+ * in spt_set
+ * @param dist distance from origin vertex to vertex with that index
+ * @param spt_set a set denoting vertices included in spt_set
+ * @return index of minimum distance not yet included in spt_set
+ */
+int min_distance_idx(long dist[], bool spt_set[], int n);
+
+
+/**
+ * generate a graph with n vertices
+ * @param n number of vertices
+ * @return 2D array, graph[i][j] = graph[j][i] = distance from vertex i to j
+ */
+long **gen_graph(int n);
+
+
+/**
+ * generate 2D array with dimension of r x c
+ * @param r number of rows
+ * @param c number of columns
+ * @return 2D array, all filled with zero
+ */
+long **gen_temp(int r, int c);
+
+/**
+ *
+ * @param graph [description]
+ * @param n [description]
+ * @param src [description]
+ */
+long *dijkstra(long **graph, int n, int src);
+
+
+#endif
\ No newline at end of file
diff --git a/src/hello_openmp.c b/src/hello_openmp.c
new file mode 100644
index 0000000..904804a
--- /dev/null
+++ b/src/hello_openmp.c
@@ -0,0 +1,20 @@
+#include <omp.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (int argc, char *argv[]) {
+ int nthreads = atoi(argv[1]), t_id;
+ int i;
+ #pragma omp parallel for private(t_id)
+ for (i = 0; i < 10; i++) {
+ t_id = omp_get_thread_num(); // get thread if for each thread
+ printf("i : %d, by the way i'm thread %d\n", i, t_id);
+ }
+
+ // printf("Hello from thead number %d of %d\n", t_id, nthreads);
+
+
+
+
+ return 0;
+}
\ No newline at end of file
diff --git a/src/hellompi.c b/src/hellompi.c
new file mode 100644
index 0000000..4753d87
--- /dev/null
+++ b/src/hellompi.c
@@ -0,0 +1,103 @@
+#include <mpi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc,char *argv[]) {
+ int numtasks, rank;
+ char processor_name[MPI_MAX_PROCESSOR_NAME];
+ int name_len;
+ int arr_size = 3;
+
+
+ MPI_Status Stat;
+ MPI_Init(&argc,&argv);
+ MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
+ MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+ MPI_Get_processor_name(processor_name, &name_len);
+ // printf("Hello from processor %s, task %d of %d, argv[1]: %s\n",
+ // processor_name, rank, numtasks, argv[1]);
+ //
+
+ int *result_arr = (int *) malloc(arr_size * numtasks * sizeof(int));
+ // int **local_mat = (int **) malloc(arr_size * sizeof(int*));
+ int *local_arr = (int *) malloc(arr_size * sizeof(int));
+
+ // for (int i = 0; i < arr_size; i++) {
+ // local_mat = (int*) malloc(5 *sizeof(int));
+ // }
+
+ // for (int i = 0; i < r; i++) {
+ // for (int j = i; j < c; j++) {
+ // local_mat[i][j] = local_mat[j][i] = 0;
+ // }
+ // }
+
+ for (int i = 0; i < arr_size; i++) {
+ local_arr[i] = i*rank*3;
+ }
+
+ if (rank == 0) {
+ // int **local_mat = (int **) malloc(arr_size * sizeof(int*));
+
+ int *temp = (int *) malloc(arr_size * sizeof(int));
+
+
+
+ // initiate result arr
+ for (int i = 0; i < arr_size; i++) {
+ result_arr[i] = local_arr[i];
+ }
+
+ // terima array dari tiap node
+ for (int i = 1; i < numtasks; i++) {
+ MPI_Recv( temp,
+ arr_size*sizeof(int),
+ MPI_INT,
+ i,
+ 0,
+ MPI_COMM_WORLD,
+ MPI_STATUS_IGNORE
+ );
+ // salin array ke result_arr
+ // result_arr[i*arr_size] = temp;
+ memcpy(result_arr+(arr_size*i),
+ temp,
+ arr_size* sizeof(int)
+ );
+
+
+
+ // for (int j = 0; j < arr_size && j+(rank*arr_size); j++) {
+ // result_arr[j+i*arr_size] = temp[j];
+ // }
+ //
+ // printf("array from node %d\n", i);
+ // for(int j = 0; j < arr_size; j++) {
+ // printf("%d ", temp[j]);
+ // }
+ // printf("\n");
+ }
+ } else {
+ MPI_Send( local_arr,
+ arr_size*sizeof(int),
+ MPI_INT,
+ 0,
+ 0,
+ MPI_COMM_WORLD
+ );
+ }
+
+ if (rank == 0) {
+ printf("here is the array you ordered\n");
+ for (int i=0; i<arr_size*numtasks; i++){
+ printf("%d ", result_arr[i]);
+ }
+ printf("\n");
+ }
+
+ free(local_arr);
+ free(result_arr);
+
+ MPI_Finalize();
+}
diff --git a/src/paralel.c b/src/paralel.c
new file mode 100644
index 0000000..0dea0f6
--- /dev/null
+++ b/src/paralel.c
@@ -0,0 +1,186 @@
+#include "dijkstra.h"
+#include "util.h"
+#include <stdio.h>
+#include <mpi.h>
+#include <math.h>
+#include <string.h>
+
+
+int main(int argc, char *argv[])
+{
+ int numprocs, rank;
+ char processor_name[MPI_MAX_PROCESSOR_NAME];
+ int name_len;
+
+ int np = atoi(argv[1]);
+ int numvertices = atoi(argv[2]);
+ int chunk_size = ceil(numvertices/np);
+ // printf("chunk_size : %d\n", chunk_size);
+ // printf("np : %d\n", np);
+ // printf("numvertices : %d\n", numvertices);
+
+
+ MPI_Status Stat;
+ MPI_Init(&argc,&argv);
+ MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
+ MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+ MPI_Get_processor_name(processor_name, &name_len);
+
+
+ double start_time, finish_time;
+
+ // generate graph
+ // printf("about to generate our graph\n");
+ long **graph = gen_graph(numvertices);
+
+ // start the timer
+ MPI_Barrier(MPI_COMM_WORLD);
+ start_time = MPI_Wtime();
+
+
+ // set chunk size and local src
+ // int my_first_src = rank * ceil(numvertices/numprocs);
+ // int my_last_src = my_first_src + chunk_size;
+ int my_first_src = rank * chunk_size;
+ // int my_last_src = if (my_first_src+chunk_size < numvertices)? my_first_src+chunk_size:;
+
+ if (rank == 0) {
+ printf("chunk_size : %d\n", chunk_size);
+ }
+ printf("i'm node %d, my_first_src: %d\n", rank, my_first_src);
+ // printf("i'm node %d, my_last_src: %d\n", rank, my_last_src);
+
+
+
+ // long **my_results = (long **) malloc(chunk_size * sizeof(long*));
+ // allocate 2D array for local result
+ // printf("initiate my result\n");
+ long **my_results = gen_temp(chunk_size, numvertices);
+ // printf("done initiating my result\n");
+
+ // find shortest path from each src
+ for (int i = 0; i+my_first_src < numvertices && i < chunk_size; i++) {
+ // printf("i'm node %d and currently working on row %d \n", rank, i+my_first_src);
+ long *dist = dijkstra(graph, numvertices, i+my_first_src);
+ my_results[i] = dist;
+ }
+ // printf("hi i'm node %d and i'm done searching\n", rank);
+
+
+ // TBD gathering data from these processes
+ if ( rank == 0 ) { // gather data from other nodes
+ long **result = gen_temp(numvertices, numvertices);
+ // printf("generated empty result matrix\n");
+ // long **temp = gen_temp(chunk_size, numvertices);
+ long *temp = (long*) malloc(numvertices * sizeof(long));
+ // printf("generated temp\n");
+
+ memcpy(result,
+ my_results,
+ chunk_size*sizeof(long*));
+ printf("copying temp to result\n");
+
+ for (int i = 1; i < numprocs; i++) {
+ printf("about to receive local result from node %d\n", i);
+
+ for (int j = 0; j < chunk_size; j++) { // loop buat nerima tiap baris dari node lain
+ MPI_Recv(temp,
+ numvertices*sizeof(long),
+ MPI_LONG,
+ i,
+ 0,
+ MPI_COMM_WORLD,
+ MPI_STATUS_IGNORE);
+ // for (int i=0;i<numvertices;i++) {
+ // printf("%d ", temp[i]);
+ // }
+ // printf("\n");
+ // printf("alamat result yang mau ditulis: result+ %d\n", (i*chunk_size)+(j*numvertices));
+ // memcpy(result+((i*chunk_size)+(j*numvertices)),
+ // temp,
+ // chunk_size*sizeof(long));
+ for (int k = 0; k < numvertices; k++) {
+ result[i*chunk_size+j][k] = temp[k];
+ }
+
+
+ }
+
+ printf("done receiving local result from node %d\n", i);
+
+ // for (int i =0; i < chunk_size; i++) {
+ // for (int j= 0 ; j < numvertices; j++){
+ // printf("%ld ", temp[i][j]);
+ // }
+ // printf("\n");
+ // }
+ printf("copying local result from node %d to result\n", i);
+
+
+ }
+
+ // for (int i=0; i < numvertices; i++) {
+ // printf("row %d\n", i);
+ // for (int j = 0; j < numvertices; j++) {
+ // printf("%d ", result[i][j]);
+ // }
+ // printf("\n");
+ // }
+ //
+
+ char filename[20];
+ sprintf(filename, "./output_parallel_%d", numvertices);
+ printf("about to write output file\n");
+ write_result(result, numvertices, filename);
+ printf("done writing\n");
+
+ //free result (2d arr)
+ for(int i = 0; i < numvertices; i++){
+ free(result[i]);
+ }
+ printf("freeing result\n");
+ //free temp (1d arr)
+ free(temp);
+ printf("freeing temp\n");
+
+
+ } else { // send my_results to master node
+ printf("i'm node %d and i'm going to send my result to master\n", rank);
+ for(int i = 0; i < chunk_size; i++) {
+ MPI_Send(my_results[i],
+ chunk_size*sizeof(long),
+ MPI_LONG,
+ 0,
+ 0,
+ MPI_COMM_WORLD
+ );
+
+ }
+ printf("i'm node %d and i'm just sent my result to master\n", rank);
+ }
+
+
+ // printf("I'm process %d and the distance from vertex 1 to 2 is %d\n",
+ // rank,
+ // graph[0][1]);
+ //
+ MPI_Barrier(MPI_COMM_WORLD);
+ finish_time = MPI_Wtime();
+
+ if (rank == 0) {
+ printf("elapsed time : %.lf ms\n", (finish_time-start_time)*1000000);
+ }
+
+
+ //free my_results (2d arr)
+ free(my_results);
+ printf("freed my_results\n");
+ //free graph (2d arr)
+ free(graph);
+ printf("freed graph\n");
+
+ MPI_Finalize();
+
+
+ return 0;
+}
\ No newline at end of file
diff --git a/src/paralel_openmp.c b/src/paralel_openmp.c
new file mode 100644
index 0000000..cdfc6fd
--- /dev/null
+++ b/src/paralel_openmp.c
@@ -0,0 +1,77 @@
+#include <omp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "util.h"
+#include "dijkstra.h"
+#include "boolean.h"
+
+
+static double get_micros(void) {
+ struct timespec ts;
+ timespec_get(&ts, TIME_UTC);
+ return ((double)((long)ts.tv_sec * 1000000000L + ts.tv_nsec)/1000);
+}
+
+
+int main(int argc, char const *argv[])
+{
+ // int thread_count = strtol(argv[1], NULL, 10);
+ int num_vertices = atoi(argv[2]);
+ // int tid;
+
+ // time
+ double start_time, end_time, total_time;
+
+ // generate graph and result matrix
+ long **result = gen_temp(num_vertices, num_vertices);
+ long **graph = gen_graph(num_vertices);
+
+ long *temp = (long*) malloc(sizeof(long)*num_vertices);
+
+ // init time
+ total_time = 0;
+
+ #pragma omp barrier
+
+ // start time
+ start_time = get_micros();
+
+ // share the work to all the threads
+ #pragma omp parallel for private(temp)
+ for (int i = 0; i < num_vertices; i++) {
+ // tid = omp_get_thread_num();
+ // printf("i: %d, by the way i'm thread %d\n", i, tid);
+
+ // get the shortest path from each vertex
+ // get time execution
+
+
+ temp = dijkstra(graph, num_vertices, i);
+
+ // kalo barrier nya disini error
+ end_time = get_micros();
+
+
+ // put it in result
+ // #pragma omp critical(result)
+ // {
+ for (int j = 0; j < num_vertices; j++) {
+ result[i][j] = temp[j];
+ }
+ // }
+
+ total_time += end_time - start_time;
+ }
+ // #pragma omp barrier
+ // total_time += end_time - start_time;
+
+ char filename[20];
+ sprintf(filename, "./output_parallel_%d", num_vertices);
+ printf("about to write output file\n");
+ write_result(result, num_vertices, filename);
+ printf("done writing\n");
+ printf("processing time: %0.04lf us ...\n",total_time);
+
+ return 0;
+}
\ No newline at end of file
diff --git a/src/serial.c b/src/serial.c
new file mode 100644
index 0000000..ec3acbb
--- /dev/null
+++ b/src/serial.c
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "dijkstra.h"
+#include "util.h"
+
+
+
+
+
+int main(int argc, char const *argv[])
+{
+ time_t start,end;
+
+ if (argc > 1) {
+
+ int n = atoi(argv[1]);
+ printf("n: %d\n", n);
+
+ // start timer
+ start=clock();
+ // generate graph
+ long **graph = gen_graph(n);
+
+ // result matrix
+ long **result = gen_temp(n, n);
+
+ for (int i = 0; i < n; i++) {
+ long *dist = dijkstra(graph, n, i);
+ result[i] = dist;
+ }
+ //end timer
+ end=clock();
+
+ //elapsed time
+ float t = (float)(end-start)/CLOCKS_PER_SEC;
+ printf("Elapsed time (in millisecond): %f", t*1000000);
+
+ char filename[20];
+ sprintf(filename, "./output_serial_%d", n);
+
+ write_result(result, n, filename);
+
+ free(result);
+ free(graph);
+
+ } else {
+ printf("usage : serial [n]\n");
+ }
+
+ return 0;
+}
+
diff --git a/src/test b/src/test
new file mode 100755
index 0000000000000000000000000000000000000000..465cd19b9177f81e395688fb030a90603f419852
GIT binary patch
literal 17016
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
literal 0
HcmV?d00001
diff --git a/src/test.c b/src/test.c
new file mode 100644
index 0000000..f5bda7e
--- /dev/null
+++ b/src/test.c
@@ -0,0 +1,37 @@
+#include "dijkstra.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+int main(int argc, char const *argv[])
+{
+ long **result = gen_temp(10,5);
+ long **first = gen_temp(5,5);
+ long **second = gen_temp(5,5);
+
+ for (int i = 0; i < 5; i++) {
+ for (int j = 0; j < 5; j++) {
+ first[i][j] = 1 * i * j;
+ second[i][j] = 2 * i * j;
+ }
+ }
+
+ memcpy(result,
+ first,
+ 5 * sizeof(int*)
+ );
+
+ memcpy(result+5,
+ second,
+ 5 * sizeof(int*)
+ );
+
+ for (int i =0; i < 10; i++) {
+ for (int j =0; j < 5; j++) {
+ printf("%d ", result[i][j]);
+ }
+ printf("\n");
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git a/src/util.c b/src/util.c
new file mode 100644
index 0000000..f3fece5
--- /dev/null
+++ b/src/util.c
@@ -0,0 +1,32 @@
+#include "util.h"
+
+
+/**
+ * write matrix of shortest distance from vertex i to j
+ * @param graph 2D array
+ */
+void write_result(long **m, int n, char filename[]) {
+
+ FILE *outfile;
+
+ printf("here we go, writing file again\n");
+ outfile = fopen(filename,"w");
+ printf("file %s opened\n", filename);
+ if (outfile == NULL) {
+ printf("Error!\n");
+ exit(1);
+ }
+
+ printf("Writing output...\n");
+ for (int i = 0; i < n; i++) {
+ // printf("about to write row %d\n", i);
+ for (int j = 0; j < n; j++) {
+ fprintf(outfile, "%ld ", m[i][j]);
+ }
+ // printf("just write row %d\n", i);
+ fprintf(outfile, "\n");
+ }
+
+ printf("Done.\n");
+
+}
\ No newline at end of file
diff --git a/src/util.h b/src/util.h
new file mode 100644
index 0000000..f58a1b1
--- /dev/null
+++ b/src/util.h
@@ -0,0 +1,14 @@
+#ifndef UTIL_H
+#define UTIL_H
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * write matrix of shortest distance from vertex i to j
+ * @param m 2D array, m[i][j] = m[j][i] = shortest distance from vertex i to j
+ * @param n dimension of matrix m
+ */
+void write_result(long **m, int n, char filename[]);
+
+
+#endif
\ No newline at end of file
--
GitLab