Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
No results found
Show changes
Commits on Source (10)
......@@ -9,3 +9,48 @@ Beberapa file yang harus ada dalam repositori tersebut diantaranya:
* 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.
# I. Petunjuk penggunaan program
gcc -g -Wall -o dijkstra dijkstra.c -fopenmp
./dijkstra [jumlah thread] [jumlah node]
# II. Pembagian tugas
* 13517008 mengerjakan fungsi chooseNode, dijkstra
* 13517143 mengerjakan fungsi paralel dijkstra dengan pragma omp
# III. Laporan pengerjaan
1. Deskripsi solusi paralel<br/>
Solusi yang digunakan adalah dengan menginisialisasi thread sejumlah thread\_count menggunakan #pragma omp parallel num\_threads(),
setelah itu membagi task dijkstra untuk setiap node ke setiap thread yang sudah diinisialisasi dengan #pragma omp for sejumlah node.
2. Analisis solusi<br/>
Solusi yang kami gunakan adalah memparalelkan proses eksekusi dijkstra untuk setiap node ke semua server.
3. Jumlah thread yang digunakan<br/>
Jumlah thread yang digunakan adalah 2 thread dimana prosesor server hanya memiliki 2 prosesor yang dapat dilihat dengan command
nproc. Hal itu dikarenakan jika menggunakan banyak thread maka waktu yang digunakan untuk switching akan semakin besar.
4. Pengukuran kinerja untuk tiap kasus uji (jumlah N pada graf) dibandingkan dengan dijkstra algorithm serial<br/>
1. Node 100 :
* Serial : 23,566617980 ms
* Paralel 1 : 6,276092026 ms
* Paralel 2 : 10,123373009 ms
* Paralel 3 : 12,125744019 ms
2. Node 500 :
* Serial : 1240,478164982 ms
* Paralel 1 : 1199,427668005 ms
* Paralel 2 : 1203,883039067 ms
* Paralel 3 : 1157,052313909 ms
3. Node 1000 :
* Serial : 14454,813088058 ms
* Paralel 1 : 9392,668731045 ms
* Paralel 2 : 9323,413665057 ms
* Paralel 3 : 9438,282919000 ms
4. Node 3000 :
* Serial : 364557,538866997 ms
* Paralel 1 : 240620,507878019 ms
<br/>
5. Analisis perbandingan kinerja serial dan paralel<br/>
Berdasarkan hasil setiap kasus uji menunjukkan bahwa algoritma paralel yang diterapkan menggunakan pragma omp lebih cepat <br/>
dibandingkan dengan algoritma secara serial.
\ No newline at end of file
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
default: compile
comile:
gcc -g -Wall dijkstraomp.c -o dijkstraomp -fopenmp
\ No newline at end of file
File added
File added
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#include <assert.h>
int minDistance(int dist[], int sptSet[], int V)
{
// Initialize min value
int min = INT_MAX, min_index;
for (int v = 0; v < V; v++)
if (sptSet[v] == 0 && dist[v] <= min)
min = dist[v], min_index = v;
return min_index;
}
int *dijkstra(int **graph, int src, int V)
{
int dist[V]; // The output array. dist[i] will hold the shortest
// distance from src to i
int sptSet[V]; // sptSet[i] will be true if vertex i is included in shortest
// path tree or shortest distance from src to i is finalized
// Initialize all distances as INFINITE and stpSet[] as false
for (int i = 0; i < V; i++)
dist[i] = INT_MAX, sptSet[i] = 0;
// Distance of source vertex from itself is always 0
dist[src] = 0;
// Find shortest path for all vertices
for (int count = 0; count < V - 1; count++)
{
// Pick the minimum distance vertex from the set of vertices not
// yet processed. u is always equal to src in the first iteration.
int u = minDistance(dist, sptSet, V);
// Mark the picked vertex as processed
sptSet[u] = 1;
// Update dist value of the adjacent vertices of the picked vertex.
for (int v = 0; v < V; v++)
// Update dist[v] only if is not in sptSet, there is an edge from
// u to v, and total weight of path from src to v through u is
// smaller than current value of dist[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 *ansArray;
ansArray = (int *)malloc(V * sizeof(int));
for (int i = 0; i < V; i++)
{
ansArray[i] = dist[i];
}
return ansArray;
}
int **initGraf(int n)
{
srand(13517143);
int random, **graf;
graf = (int **)malloc(n * sizeof(int *));
for (int i = 0; i < n; ++i)
graf[i] = (int *)malloc(n * sizeof(int));
for (int i = 0; i < n; i++)
{
for (int j = i; j < n; j++)
{
random = rand() % 100;
if (i == j)
{
graf[i][i] = 0;
}
else
{
graf[i][j] = random;
graf[j][i] = random;
}
}
}
return graf;
}
void printGraf(int **graf, int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
printf("%d\t", graf[i][j]);
}
printf("\n");
}
}
void freeMatrix(int **matrix,int n){
for(int i=0;i<n;i++){
free(matrix[i]);
}
free(matrix);
}
int main(int argc, char *argv[])
{
int thread_count = strtol(argv[1], NULL, 10);
int node_count = strtol(argv[2],NULL,10);
int **graf,**answerMatrix,*arrayTemp;
graf= initGraf(node_count);
double start;
double end;
start = omp_get_wtime();
answerMatrix= (int **)malloc(node_count * sizeof(int *));
#pragma omp parallel num_threads(thread_count)
#pragma omp for
for(int i =0;i<node_count;i++){
arrayTemp=dijkstra(graf,i,node_count);
answerMatrix[i]=arrayTemp;
}
for(int i=0;i<node_count;i++){
for(int j=0;j<node_count;j++){
printf("%d \t",answerMatrix[i][j]);
}
printf("\n");
}
end = omp_get_wtime();
printf("~Work took %f seconds\n~", (end - start)*1000000);
freeMatrix(answerMatrix,node_count);
freeMatrix(graf,node_count);
}
scp $1 $2@167.205.35.150:~
ssh $2@167.205.35.150 sh copy.sh $1 $2
\ No newline at end of file