int *pqsort(int* input, int num_elements, int num_threads)
{
if(num_threads*num_threads*CACHE_LINE_SIZE > num_elements){
num_threads = (int)(sqrt(num_elements/CACHE_LINE_SIZE));
}
int power_of=1;
while(power_of < num_threads){
power_of *= 2;
}
num_threads = power_of;
if(num_threads == 1){
qsort(input , num_elements, sizeof(int), compare);
return input;
}
// YOUR CODE GOES HERE
long i;
sort_data *sort_data_array = (sort_data*)malloc(num_threads*sizeof(sort_data));
pthread_t *thread_id = (pthread_t*)malloc(num_threads*sizeof(pthread_t));
all_pivot_data = (pivot_data*)aligned_malloc(num_threads*sizeof(pivot_data));
//all_pivot_data = (pivot_data*)malloc(num_threads*sizeof(pivot_data));
/* MAX_THREADS = 1;
while( MAX_THREADS < num_threads ){
MAX_THREADS = MAX_THREADS << 1;
}
printf("MAX_THREADS %d\n", MAX_THREADS);*/
//barr = (barrier_node*)malloc(MAX_THREADS*sizeof(barrier_node));
//barr = (barrier_node*)aligned_malloc(num_threads*sizeof(barrier_node));
barr = (barrier_node*)malloc(num_threads*sizeof(barrier_node));
ps = (prefix_sum_node*)aligned_malloc(num_threads*sizeof(prefix_sum_node));
mylib_init_prefix_sum(ps, num_threads, all_lengths);
final_pivots = (int*)malloc((num_threads-1)*sizeof(int));
partitions = (partition_data*)aligned_malloc(num_threads*sizeof(partition_data));
for(i=0; i<num_threads; i++){
partitions[i].id = i;
}
mylib_init_barrier (barr, num_threads);
output = (int*)aligned_malloc(num_elements*sizeof(int));
// Divide input into num_threads chunks
divide(input, num_elements, num_threads, sort_data_array);
// create threads for locally sorting the partitions
for(i=0; i<num_threads; i++){
pthread_create(&thread_id[i], NULL, run_threads, sort_data_array+i);
//printf("i %ld\n", thread_id[i]);
}
for(i=0; i<num_threads; i++){
pthread_join(thread_id[i], NULL);
}
return output; //return appropriately
}
/* ========== MAIN ========== */
int main(int argc, char* argv[]) {
/* Print out starting time */
double start = when();
printf("Starting time: %f\n", start);
/* Create thread count */
int nthreads = atoi(argv[1]);
/* Create plate */
main_plate = createPlate();
main_prev_plate = createPlate();
main_locked_cells = createCharPlate(); // bool array of locked cells
/* Init barriers and mutex */
pthread_mutex_init(&finished_count, NULL);
barr = (barrier_node*)malloc(sizeof(barrier_node));
mylib_init_barrier(barr, nthreads);
/* Init main plate and make a duplicate copy */
initPlate(main_plate, main_prev_plate);
/* Start updating */
startUpdate(nthreads);//, barr);
/* Report time and cleanup */
double end = when();
printf("\nEnding time: %f\n", end);
printf("Total execution time: %f\n", end - start);
printf("Number of iterations: %d\n\n", iterations);
/* Destroy mutex and barriers */
pthread_mutex_destroy(&finished_count);
mylib_destroy_barrier(barr);
/* free memory */
printf("Cleanup\n");
free(barr);
cleanupFloat(main_plate);
cleanupFloat(main_prev_plate);
cleanupChar(main_locked_cells);
return EXIT_SUCCESS;
}
