laporan.txt

+thread : 1
+
+Elemen : 50000
+
+Waktu Eksekusi : 3.310 s
+
+
+
+Thread : 8
+
+Elemen : 50000
+
+Waktu Eksekusi : 0.086 s
+
+
+
+Thread : 16
+
+Elemen : 50000
+
+Waktu Eksekusi : 0.038 s
+
+
+
+Thread : 32
+
+Elemen : 50000
+
+Waktu Eksekusi : 0.019 s
+
+
+
+Thread : 64
+
+Elemen : 50000
+
+Waktu Eksekusi : 0.024 s
+
+
+
+Thread : 128
+
+Elemen : 50000
+
+Waktu Eksekusi : 0.021 s
+
+
+
+Thread : 1
+
+Elemen : 100.000
+
+Waktu Eksekusi : 12.746 s
+
+
+
+Thread : 8
+
+Elemen : 100.000
+
+Waktu Eksekusi : 0.253 s
+
+
+
+Thread : 16
+
+Elemen : 100.000
+
+Waktu Eksekusi : 0.104 s
+
+
+
+Thread : 32
+
+Elemen : 100.000
+
+Waktu Eksekusi : 0.048 s
+
+
+
+Thread : 64
+
+Elemen : 100.000
+
+Waktu Eksekusi : 0.047 s
+
+
+
+Thread : 128
+
+Elemen : 100.000
+
+Waktu Eksekusi : 0.030 s
+
+
+
+Thread : 1
+
+Elemen : 200.000
+
+Waktu Eksekusi : 50715.0 s
+
+
+
+Thread : 8
+
+Elemen : 200.000
+
+Waktu Eksekusi : 0.960 s
+
+
+
+Thread : 16
+
+Elemen : 200.000
+
+Waktu Eksekusi : 0.297 s
+
+
+
+Thread : 32
+
+Elemen : 200.000
+
+Waktu Eksekusi : 0.165 s
+
+
+
+Thread : 64
+
+Elemen : 200.000
+
+Waktu Eksekusi : 0.107 s
+
+
+
+Thread : 128
+
+Elemen : 200.000
+
+Waktu Eksekusi : 0.053 s
+
+
+
+Thread : 1
+
+Elemen : 400.000
+
+Waktu Eksekusi : 3233.0 s
+
+
+
+Thread : 8
+
+Elemen : 400.000
+
+Waktu Eksekusi : 3.60 s
+
+
+
+Thread : 16
+
+Elemen : 400.000
+
+Waktu Eksekusi : 1.01 s
+
+
+
+Thread : 32
+
+Elemen : 400.000
+
+Waktu Eksekusi : 0.517 s
+
+
+
+Thread : 64
+
+Elemen : 400.000
+
+Waktu Eksekusi : 0.210 s
+
+
+
+Thread : 128
+
+Elemen : 400.000
+
+Waktu Eksekusi : 208.555 s

omp_bucket.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+#include <time.h>
+#define MAX_VALUE 10000
+
+void bucket_sort(int* sorted_array, int element_num); /* Thread function */
+void insertion_sort(int* sorted_array, int size, int element_num);
+
+
+int main(int argc, char *argv[]) {
+
+    int i;
+
+    // Timer
+    struct timeval start, end;
+    float delta;
+
+    // Num of threads
+    int thread_count = atoi(argv[1]);
+    // Num of elements
+    int element_num = atoi(argv[2]);
+
+    int range = MAX_VALUE / thread_count;
+
+    // Seed
+    srand(time(NULL));
+
+    // Bucket
+    //int* bucket = (int *)malloc(sizeof(int) * element_num);
+    //memset (bucket, 0, (sizeof(int) * element_num));
+
+    // Sorted Array
+    int* sorted_array = (int *)malloc(sizeof(int) * element_num);
+    memset (sorted_array, 0, (sizeof(int) * element_num));
+
+    // Do bucket sort
+    gettimeofday(&start, NULL);
+    #pragma omp parallel num_threads(thread_count)
+    bucket_sort(sorted_array, element_num);
+
+    gettimeofday(&end, NULL);
+
+    delta = ((end.tv_sec  - start.tv_sec) * 1000000u +
+             end.tv_usec - start.tv_usec) / 1.e6;
+    // Print result
+    // printf("\n");
+    // for (i=0;i<element_num;i++){
+    //     printf("%d ", sorted_array[i]);
+    // }
+    // printf("\n");
+
+    printf("Time : %f s\n", delta);
+    return 0;
+}
+
+void insertion_sort(int* sorted_array, int size, int element_num)
+{
+  int n, c, d, t;
+
+  int interval;
+  int my_rank = omp_get_thread_num();
+  int thread_count = omp_get_num_threads();
+
+  interval = size;
+  // if there is remainder of thread then the last thread hold all the element
+  if ((element_num - thread_count * size) != 0){
+    if(my_rank == thread_count-1){
+      // printf("%d\n", my_rank );
+
+      size = element_num % thread_count + size;
+
+      // printf("%d\n", size);
+    }
+  }
+
+  int array[size];
+
+  for (c = 0; c < size; c++) {
+    array[c] = rand() % (size) + (my_rank)*size;
+    // printf("%d ", array[c]);
+  }
+
+  // Sorting
+  for (c = 1 ; c <= size - 1; c++) {
+    d = c;
+
+    while ( d > 0 && array[d] < array[d-1]) {
+      t          = array[d];
+      array[d]   = array[d-1];
+      array[d-1] = t;
+
+      d--;
+    }
+  }
+
+//   printf("Rank : %d\n", my_rank);
+//   for (c=0;c<size;c++){
+//     printf("%d ",array[c]);
+//
+// }
+  // printf("\nSize : %d\n", size);
+  memcpy(sorted_array+(my_rank * interval), &array, size*sizeof(int));
+}
+
+void bucket_sort(int* sorted_array, int element_num) {
+    int my_rank = omp_get_thread_num();
+    int thread_count = omp_get_num_threads();
+
+    int bucket_size = element_num / thread_count;
+
+    insertion_sort(sorted_array, bucket_size, element_num);
+
+
+
+}