Bucket v2

bucketSort.c

-// Copyright 2012 www.mpitutorial.com 
-// Program yang menghitung rata­rata dari array secara paralel menggunakan Scatter dan Gather. 
 #include <stdio.h> 
 #include <stdlib.h> 
+#include <string.h>
 #include <time.h> 
 #include <mpi.h> 
 #include <assert.h> 
  
-float *create_rand_nums(int num_elements, int num_per_bucket) { 
-	float *rand_nums = (float *)malloc(sizeof(float) * num_elements); 
+int *create_rand_nums(int num_elements, int* counts, int* displs, int num_buckets) { 
+	int *rand_nums = (int *)malloc(sizeof(int) * num_elements); 
 	assert(rand_nums != NULL); 
-	int i; 
+	int bucket_size = RAND_MAX / num_buckets;
+	int i, j; 
+	int** buckets;
+	buckets = (int **)malloc(sizeof(int*) * num_buckets);
+	for(i = 0; i < num_buckets; i++){
+		counts[i] = 0;
+		displs[i] = 0;
+		buckets[i] = (int *)malloc(sizeof(int) * num_elements); 
+	}
 	for (i = 0; i < num_elements; i++) { 
-		rand_nums[i] = ((rand() % (float)RAND_MAX) % (float)(i/num_per_bucket) * 200) + (float)(i/num_per_bucket) * 200; 
-	} 
+		int random = (rand() % RAND_MAX);
+		int bucket = random / bucket_size;
+		buckets[bucket][counts[bucket]] = random;
+		counts[bucket]++;
+		for(j = bucket+1; j < num_buckets; j++){
+			displs[j]++;
+		}			
+	}
+	for(i = 0; i < num_buckets; i++){
+		memcpy(rand_nums + displs[i], buckets[i], counts[i]);
+		//printf("count %d\n", counts[i]);
+		free(buckets[i]);
+	}
+	free(buckets);
 	return rand_nums; 
-} 
- 
-float * bucketSort(float *array, int n) {
-  for (c = 1 ; c <= n - 1; c++) {
-    d = c;
+}
+
+int get_bucket_count(int bucket, int *array, int num_elements, int num_buckets){
+	int bucket_size = RAND_MAX / num_buckets;
+	int i=0;
+	int count = 0;
+
+	for(i = 0; i < num_elements; i++){
+		if((array[i]/bucket_size )== bucket) count++;
+	}
+	return count;
+}
  
-    while ( d > 0 && array[d] < array[d-1]) {
-      t          = array[d];
-      array[d]   = array[d-1];
-      array[d-1] = t;
+
+void sort(int *array, int n) {
+	int c, d, t;
+	for (c = 1 ; c <= n - 1; c++) {
+		d = c;
  
-      d--;
-    }
-  }
-  return array;
+		while ( d > 0 && array[d] < array[d-1]) {
+			t          = array[d];
+			array[d]   = array[d-1];
+			array[d-1] = t;
+			d--;
+		}
+	}
 }
-
+ 
 int main(int argc, char** argv) { 
+	int* sendcounts;
+	int* displacements;
+	
 	if (argc != 2) { 
-		fprintf(stderr, "Usage: avg num_elements_per_proc\n"); 
+		fprintf(stderr, "Usage: number of elements\n"); 
 		exit(1); 
-	} 
+	}
+	
  
-	int num_elements_per_proc = atoi(argv[1]); 
+	int num_elements = atoi(argv[1]); 
 	srand(time(NULL)); 
  
 	MPI_Init(NULL, NULL); 
@@ -46,44 +80,34 @@ int main(int argc, char** argv) {
 	MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); 
 	int world_size; 
 	MPI_Comm_size(MPI_COMM_WORLD, &world_size); 
- 
-	float *rand_nums = NULL; 
-	if (world_rank == 0) { 
-		rand_nums = create_rand_nums(num_elements_per_proc * world_size); 
-	} 
- 
-	float *sub_rand_nums = (float *)malloc(sizeof(float) * 
-	num_elements_per_proc); 
+	int *rand_nums = NULL; 
+	sendcounts = (int *)malloc(sizeof(int)*world_size);
+	displacements = (int *)malloc(sizeof(int)*world_size);
+	if (world_rank == 0) {
+		
+		rand_nums = create_rand_nums(num_elements, sendcounts, displacements, world_size); 
+		printf("size %d\n", world_size);
+	}	 
+	printf("%d\n", world_rank);
+
+	int *sub_rand_nums = (int *)malloc(sizeof(int) * num_elements); 
 	assert(sub_rand_nums != NULL); 
 	
-        
-        MPI_Scatter(rand_nums, num_elements_per_proc, MPI_FLOAT, sub_rand_nums, 
-	num_elements_per_proc, MPI_FLOAT, 0, MPI_COMM_WORLD); 
-        
-	float* sub_bucket = bucketSort(sub_rand_nums, num_elements_per_proc); 
- 
-	float *sub_buckets = NULL; 
-	if (world_rank == 0) { 
-		sub_buckets = (float *)malloc(sizeof(float) * world_size); 
-		assert(sub_buckets != NULL); 
-	} 
-	MPI_Gather(&sub_bucket, num_elements_per_proc, MPI_FLOAT, sub_buckets, 1, MPI_FLOAT, 0, 
-	MPI_COMM_WORLD); 
- 
-	if (world_rank == 0) { 
-            int i;
-            for(i=0; i<(num_elements_per_proc*world_size); i++)
-		printf("Avg of all elements is %f\n",sub_buckets[i]); 
-	} 
+	MPI_Scatterv(rand_nums, sendcounts, displacements, MPI_INT, sub_rand_nums, num_elements, MPI_INT, 0, MPI_COMM_WORLD);
+	printf("count2 %d\n", get_bucket_count(world_rank, sub_rand_nums, num_elements, world_size));
+	
+	sort(sub_rand_nums, get_bucket_count(world_rank, sub_rand_nums, num_elements, world_size));
  
-	if (world_rank == 0) { 
-		free(rand_nums); 
-		free(sub_bukcets); 
-	} 
 	free(sub_rand_nums); 
  
+	if (world_rank == 0) {
+		free(rand_nums);	
+	}	
+	free(sendcounts);
+	free(displacements);
 	MPI_Barrier(MPI_COMM_WORLD); 
 	MPI_Finalize(); 
+	
+	 
 }  
 
-