From 1a3a7f47683ce36f3682ef5146e843f8e28c1c67 Mon Sep 17 00:00:00 2001
From: Farhan Ramadhan <farhanramadhansk@gmail.com>
Date: Sun, 1 Mar 2020 23:23:51 +0700
Subject: [PATCH] edit readme
---
README.md | 51 +++++++++++---
src/dijkstra.c | 187 +++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 229 insertions(+), 9 deletions(-)
create mode 100644 src/dijkstra.c
diff --git a/README.md b/README.md
index f77e0e8..5f28e4d 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,44 @@
-# Announcement
+# Petunjuk Penggunaan
+ 1. Compile file dengan perintah `make compile/ make run`
+ 2. Inputkan jumlah process, nodes, dan file output yang diinginkan
+ 3. Lihat hasil di file output
-Beberapa file yang harus ada dalam repositori tersebut diantaranya:
-* Direktori src yang berisi source code yang anda buat.
-* File output yang berisi hasil uji dijkstra algorithm pada data uji.
-* Makefile. Buatlah sehingga kompilasi program dapat dilakukan hanya dengan pemanggilan command ’make’ saja.
-* File README.md yang berisi:
- * Petunjuk penggunaan program.
- * Pembagian tugas. Sampaikan dalam list pengerjaan untuk setiap mahasiswa. Sebagai contoh: XXXX mengerjakan fungsi YYYY, ZZZZ, dan YYZZ.
- * Laporan pengerjaan, dengan struktur laporan sesuai dengan deskripsi pada bagian sebelumnya.
+# Pembagian Tugas
+ * InitMatrix - Syaiful - 13517139
+ * RandomMatrix - Farhan - 13517001
+ * PrintMatrix - Syaiful - 13517139
+ * FreeMatrix - Farhan - 13517001
+ * Pragma Omp - Farhan - 13517001
+# Laporan Pengerjaan
+ * Deskripsi solusi paralel. Berikan ilustrasi jika perlu.
+ > Solusi paralel dilakukan dengan cara membagi proses sebanyak n nodes ke n process, kemudian tiap proses tersebut dijalankan oleh sejumlah np proses secara paralel dan akan ada matrix global yang akan diakses secara paralel oleh tiap proses, dan kemudian di-print ke output.
+
+ * Analisis solusi yang anda berikan.
+ Apakah mungkin terdapat solusi yang memberikan kinerja lebih baik?
+ > Dalam menggunakan library OpenMP ini dalam kasus 100, 500, 1000, 3000 lebih cepat paralel karena pembagian thread lebih mudah dan overhead dari tiap transaksi per thread tidak terlalu besar.
+
+ * Jumlah thread yang digunakan. Kenapa anda memilih angka tersebut?
+ > Pada lokal prosesnya maksimum sesuai dengan cpu mungkin 2,4, atau 8 sedangkan untuk di server menggunakan 2 karena pada VM ...150, jumlah processnya 2 sehingga lebih baik membagi program sebanyak itu (dapat dari nproc).
+
+ * Pengukuran kinerja untuk tiap kasus uji (jumlah N pada graf)
+ dibandingkan dengan dijkstra algorithm serial.
+ > Pada paralel kecepatannya lebih cepat karena dibagi sebanyak prosesnya
+ - Serial = N * (N^2)
+ - Paralel = N * (N^2)/N
+ Pada N = 100
+ - Serial > Paralel
+ Pada N = 500
+ - Serial > Paralel
+ Pada N = 1000
+ - Serial > Paralel
+ Pada N = 3000
+ - Serial > Paralel
+
+
+
+ * Analisis perbandingan kinerja serial dan paralel.
+ Analisis yang diharapkan adalah analisis yang minimal
+ dapat menjelaskan setiap hasil pengukuran kinerja sebelumnya.
+ > Terlihat dari hasil kinerja yang telah dilakukan bahwa waktu pada serial lebih
+ tinggi karena pada paralel dibagi lagi dengan banyaknya prosesnya..
\ No newline at end of file
diff --git a/src/dijkstra.c b/src/dijkstra.c
new file mode 100644
index 0000000..74098ee
--- /dev/null
+++ b/src/dijkstra.c
@@ -0,0 +1,187 @@
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+
+
+#define true 1
+#define false 0
+
+int minDistance(int dist[], int sptSet[], int num_vertex) {
+ int min = INT_MAX, min_index;
+ for (int v = 0; v < num_vertex; v++)
+ if (sptSet[v] == false && dist[v] <= min)
+ min = dist[v], min_index = v;
+ return min_index;
+}
+
+int* dijkstra(int** graph, int src, int num_vertex) {
+ int dist[num_vertex];
+ int sptSet[num_vertex];
+ for (int i = 0; i < num_vertex; i++)
+ dist[i] = INT_MAX, sptSet[i] = false;
+
+ dist[src] = 0;
+
+ for (int count = 0; count < num_vertex - 1; count++) {
+ int u = minDistance(dist, sptSet, num_vertex);
+
+ sptSet[u] = true;
+
+ for (int v = 0; v < num_vertex; v++)
+
+ if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
+ && dist[u] + graph[u][v] < dist[v])
+ dist[v] = dist[u] + graph[u][v];
+ }
+
+ int* result;
+ result = malloc(num_vertex * sizeof *result);
+ for (int i = 0; i < num_vertex; i++) {
+ result[i] = dist[i];
+ }
+
+ return result;
+}
+
+int** InitMatrix(int num_nodes) {
+ int** adj_matrix;
+ adj_matrix = malloc(num_nodes * sizeof *adj_matrix);
+ for(int i = 0; i < num_nodes; i++){
+ adj_matrix[i] = malloc(num_nodes * sizeof *adj_matrix[i]);
+ }
+ return adj_matrix;
+}
+
+void RandomMatrix(int** adj_matrix, int num_nodes) {
+ srand(13517001);
+ // init distance
+ for (int i = 0; i < num_nodes; i++) {
+ for (int j = i; j < num_nodes; j++) {
+ if (i == j) {
+ adj_matrix[i][j] = 0;
+ } else {
+ adj_matrix[i][j] = rand() % 100;
+ adj_matrix[j][i] = adj_matrix[i][j];
+ }
+ }
+ }
+}
+
+int random_matrix(int*** adj_matrix, int num_nodes) {
+ srand(13517001);
+ // init distance
+ for (int i = 0; i < num_nodes; i++) {
+ for (int j = i; j < num_nodes; j++) {
+ if (i == j) {
+ (*adj_matrix)[i][j] = 0;
+ } else {
+ (*adj_matrix)[i][j] = rand() % 100;
+ (*adj_matrix)[j][i] = (*adj_matrix)[i][j];
+ }
+ }
+ }
+ return 0;
+}
+
+int print_matrix(int*** adj_matrix, int num_nodes) {
+ for (int i = 0; i < num_nodes; i++) {
+ for (int j = 0; j < num_nodes; j++) {
+ printf("%d\t", (*adj_matrix)[i][j]);
+ }
+ printf("\n");
+ }
+ return 0;
+}
+
+int malloc2dint(int ***array, int n, int m) {
+
+ int *p = (int *)malloc(n*m*sizeof(int));
+ if (!p) return -1;
+
+ (*array) = (int **)malloc(n*sizeof(int*));
+ if (!(*array)) {
+ free(p);
+ return -1;
+ }
+
+ for (int i = 0; i < n; i++)
+ (*array)[i] = &(p[i*m]);
+
+ return 0;
+}
+
+int free2dint(int ***array) {
+ free(&((*array)[0][0]));
+
+ free(*array);
+
+ return 0;
+}
+
+void PrintMatrix(int** adj_matrix, int num_nodes) {
+ for (int i = 0; i < num_nodes; i++) {
+ for (int j = 0; j < num_nodes; j++) {
+ printf("%d\t", adj_matrix[i][j]);
+ }
+ printf("\n");
+ }
+}
+
+void FreeMatrix(int** adj_matrix, int num_nodes) {
+ for (int i = 0; i < num_nodes; i++) {
+ free(adj_matrix[i]);
+ }
+ free(adj_matrix);
+}
+
+void debug(int x) {
+ printf("DEBUG %d >>>\n", x);
+}
+
+
+void Hello(void); /* Thread function */
+
+int main(int argc, char *argv[]) {
+ int nodes_count = strtol(argv[2], NULL, 10);
+
+ long double start, end;
+ int num_thread;
+ int** adj_matrix;
+ int** result_matrix;
+ num_thread = atoi(argv[1]);
+ result_matrix = InitMatrix(nodes_count);
+ adj_matrix = InitMatrix(nodes_count);
+ RandomMatrix(adj_matrix, nodes_count);
+ // PrintMatrix(adj_matrix, nodes_count);
+ start = omp_get_wtime();
+ // printf("%l\n")
+
+ #pragma omp parallel num_threads(num_thread)
+ #pragma omp for
+ for (int i = 0; i < nodes_count; i++) {
+ /* code */
+ // int my_rank = omp_get_thread_num();
+ int* temp;
+
+ temp = dijkstra(adj_matrix, i, nodes_count);
+ result_matrix[i] = temp;
+ // printf("rank %d do nodes %d\n", my_rank, i);
+ }
+
+ printf("~=== Hasil ===~\n");
+ PrintMatrix(result_matrix, nodes_count);
+ end = omp_get_wtime();
+ printf("time: %Lf microsecond(s)\n", (end - start)*1000000);
+ FreeMatrix(adj_matrix, nodes_count);
+ FreeMatrix(result_matrix, nodes_count);
+ return 0;
+}
+
+void Hello(void) {
+ int my_rank = omp_get_thread_num();
+ int thread_count = omp_get_num_threads();
+
+ printf("Hello from thread %d of %d\n", my_rank, thread_count);
+}
+
--
GitLab