Program + laporan

laporan.txt

+perbandingan waktu kinerja program
+
+1)
+N = 50.000, M = 1
+t = 2240 ms
+
+N = 50.000, M = 8
+t = 580 ms
+
+N = 50.000, M = 16
+t = 450 ms
+
+N = 50.000, M = 32
+t = 460 ms
+
+N = 50.000, M = 64
+t = 780 ms
+
+N = 50.000, M = 128
+t = 140 ms
+
+2)
+N = 100.000, M = 1
+t = 8630 ms
+
+N = 100.000, M = 8
+t = 1440 ms
+
+N = 100.000, M = 16
+t = 1080 ms
+
+N = 100.000, M = 32
+t = 1130 ms
+
+N = 100.000, M = 64
+t = 1190 ms
+
+N = 100.000, M = 128
+t = 360 ms
+
+3)
+N = 200.000, M = 1
+t = 32500 ms
+
+N = 200.000, M = 8
+t = 5160 ms
+
+N = 200.000, M = 16
+t = 3140 ms
+
+N = 200.000, M = 32
+t = 2410 ms
+
+N = 200.000, M = 64
+t = 2330 ms
+
+N = 200.000, M = 128
+t = 840 ms
+
+4)
+N = 400.000, M = 1
+t = 132480 ms
+
+N = 400.000, M = 8
+t = 18430 ms
+
+N = 400.000, M = 16
+t = 10020 ms
+
+N = 400.000, M = 32
+t = 8060 ms
+
+N = 400.000, M = 64
+t = 6720 ms
+
+N = 400.000, M = 128
+t = 3450 ms
+

omp_bucketsort.c

+#include <stdio.h> 
+#include <stdlib.h> 
+#include <string.h>
+#include <time.h> 
+#include <math.h>
+#include <omp.h> 
+#include <assert.h> 
+
+int *create_rand_nums(int num_elements) { 
+  int *rand_nums = (int *)malloc(sizeof(int) * (num_elements)); 
+  assert(rand_nums != NULL); 
+  int i; 
+  for (i = 0; i < num_elements; i++) { 
+          rand_nums[i] = (abs((int)rand()) % num_elements); 
+  } 
+  return rand_nums; 
+}
+
+void insertionSort(int *arr, int indeksAwal, int indeksAkhir){
+	int i,j;
+    int value;
+    for(i=indeksAwal+1;i<=indeksAkhir;i++)
+    {
+        value=arr[i];
+        j=i-1;
+        while(j>=indeksAwal && value<arr[j])
+        {
+            arr[j+1]=arr[j];
+            j=j-1;
+        }
+        arr[j+1]=value;
+    }
+}
+
+int main(int argc, char** argv){
+	if(argc != 3){
+		fprintf(stderr, "Usage: avg num_elements\n");
+		exit(1);
+	}
+	
+	int i;
+	srand(time(NULL));
+	int thread_count = atoi(argv[1]);
+	int num_elements = atoi(argv[2]);
+	
+	int *rand_nums = create_rand_nums(num_elements);
+	time_t start_t;
+	start_t  = clock(); 
+	int *bucket = (int*)malloc(sizeof(int) * num_elements); // bucket utama yang berisi bucket-bucket dibagi setiap elemen
+	int *indeks = (int*)malloc(sizeof(int) * thread_count); // menandakan indeks awal setiap bucket pada bucket utama
+	int range = (num_elements + thread_count) / thread_count;
+	int* jumlahElemenBucket = NULL; // jumlah elemen setiap bucket
+	jumlahElemenBucket = (int *)malloc(sizeof(int) * thread_count);
+	memset(jumlahElemenBucket,0,sizeof(int) * thread_count);
+	for(i = 0; i < num_elements; ++i){
+		jumlahElemenBucket[rand_nums[i]/range]++;
+	}
+	for(i = 0; i < thread_count; ++i){
+		if(i == 0){
+			indeks[i] = 0;
+		} else {
+			indeks[i] = indeks[i-1] + jumlahElemenBucket[i-1];
+		}
+	}
+	memset(jumlahElemenBucket,0,sizeof(int) * thread_count);
+	for(i = 0; i < num_elements; ++i){
+		int indeksBucket = rand_nums[i]/range;
+		bucket[indeks[indeksBucket] + (jumlahElemenBucket[indeksBucket]++)] = rand_nums[i];
+	}
+	#pragma omp parallel for num_threads(thread_count)
+	for(i = 0; i < thread_count; ++i){
+		if(jumlahElemenBucket[i] != 0){
+			insertionSort(bucket,indeks[i],indeks[i]+jumlahElemenBucket[i]-1);
+		}
+	}
+	printf("\n");
+	for(i = 0; i < num_elements; ++i){
+		printf("%d\n",bucket[i]);
+	}
+	time_t finish_t = clock();
+	printf("Waktu eksekusi %d data : %d thread : %.5f ms\n", num_elements, thread_count, (double)(finish_t-start_t)*1000/CLOCKS_PER_SEC);
+
+	free(rand_nums);
+	free(bucket);
+	free(indeks);
+	free(jumlahElemenBucket);
+	return 0;
+}