int main(int ac, char** av)
{
int print = 0;
int n = 2000000;
int i;
double* a;
double start, end;
if (ac > 1)
sscanf(av[1], "%d", &n);
srand(getpid());
a = malloc(n * sizeof (double));
for (i = 0; i < n; i++)
a[i] = rand() % n;
start = sec();
#ifdef PARALLEL
double *p1, *p2, *p3;
partial_sort(a, &p2, n);
partial_sort(a, &p1, (p2 - a));
partial_sort(p2, &p3, (a + n - p2));
double dn = (double) n;
double s1 = 100 * (p1 - a) / dn, s2 = 100 * (p2 - p1) / dn,
s3 = 100 * (p3 - p2) / dn, s4 = 100 * (a + n - p3) / dn;
printf("Load:\ts1: %1.2lf%%, s2: %1.2lf%%, s3: %1.2lf%%, s4: %1.2lf%%.\n",
s1, s2, s3, s4);
pthread_t* threads = malloc(NUM_THREADS * sizeof (pthread_t));
data_t* args = malloc(NUM_THREADS * sizeof (data_t));
/*
print_array(a, p1 - a);
print_array(p1, p2 - p1);
print_array(p2, p3 - p2);
print_array(p3, a + n - p3);
*/
par_sort(&threads[0], &args[0], a, p1 - a, sizeof (double), cmp, 0); // a -> p2
par_sort(&threads[1], &args[1], p1, p2 - p1, sizeof(double), cmp, 1); // p2 -> p1
par_sort(&threads[2], &args[2], p2, p3 - p2, sizeof (double), cmp, 2); // p1 -> p3
par_sort(&threads[3], &args[3], p3, a + n - p3, sizeof (double), cmp, 3); // p3 -> &a[n - 1]
for (i = 0; i < NUM_THREADS; ++i)
pthread_join(threads[i], NULL);
#else
qsort(a, n, sizeof a[0], cmp);
#endif
for (i = 0; i < n - 1; ++i)
assert(a[i] <= a[i + 1]);
end = sec();
printf("%1.2f ms\n", end - start);
free(a);
return 0;
}
void sorting(TYPE* buffer, int size) {
sort_data_t* buf = (sort_data_t*) malloc(sizeof(sort_data_t));
buf->buffer = buffer;
buf->left = 0;
buf->right = size - 1;
par_sort(buf);
}
void par_sort(
void* base, // Array to sort.
size_t n, // Number of elements in base.
size_t s, // Size of each element
int (*cmp)(const void*, const void*)) // Behaves like strcmp
{
int split = 0;
//lock and handle mutex stuff
pthread_mutex_lock(&thread_sum);
//change n in if to higher number to potentially decrease load balancing problem
if(n_thread<NBR_THREADS && n > 1 ){
split = 1;
n_thread++;
}
//do stuff with mutex
//unlock mutex stuff
pthread_mutex_unlock(&thread_sum);
if(split){
pthread_t t;
size_t left_size = partition(base, n);
size_t right_size = n - left_size;
void* new_base = ((double*)(base)) + ((left_size));
arg_struct_t arg = {new_base,right_size,s,cmp};
pthread_create(&t,NULL,thread_sort,&arg);
par_sort(base,left_size,s,cmp);
pthread_join(t,NULL);
}
/*pthread_t t1,t2;
if(i+2<NBR_THREADS)
{
arg_struct_t arg1 = {base, n/2, s, i+1, cmp};
pthread_create(&t1,NULL,thread_sort,&arg1);
arg_struct_t arg2 = {(char*)(base)+(s*(n/2)), n/2, s, i+2,cmp};
pthread_create(&t2,NULL,thread_sort,&arg2);
pthread_join(t1,NULL);
pthread_join(t2,NULL);
//fixa ihop delarna
}else if(i+1<NBR_THREADS)
{
arg_struct_t arg1 = {base, n/2, s, i+1, cmp};
pthread_create(&t1,NULL,thread_sort,&arg1);
pthread_join(t1,NULL);
qsort((char*)(base)+(s*(n/2)), n/2, s,cmp);
//fixa ihop delarna
}*/ else{
printf("workload %zu\n", n);
qsort(base,n,s,cmp);
}
}
void* par_sort( void* args )
{
arg_struct arg1 = *(arg_struct*) args;
void* base = arg1.base; // base pointer
size_t n = arg1.n; // number of elements in base
size_t s = arg1.s; // size of each element
compare cmp_func = arg1.cmp_func;
int split = 0; //get from mutex
pthread_mutex_lock (&thread_sum);
if(n_thread < limit){
split = 1;
n_thread+=1;
}
pthread_mutex_unlock (&thread_sum);
if(split && n > 5){
pthread_t thread;
size_t middle = partition(base,n);
if(middle == 0){
arg_struct arg0 = { ((double*) base) + 1, n-1, s, cmp_func};
par_sort(&arg0);
return NULL;
}
printf("middle index is %zu of %zu ,percentage %1.2f\n", middle,n,middle*1.0 /n);
arg_struct arg0 = { base, middle, s, cmp_func};
arg_struct arg1 = { ((double*) base) + middle + 1 , n - middle - 1 , s, cmp_func };
if( pthread_create( &thread, NULL, par_sort,&arg1 ) ) {
fprintf(stderr,"Error creating thread\n");
}
par_sort(&arg0);
// end thread run with pthread_join
if( pthread_join(thread,NULL) ){
fprintf(stderr,"Error joining thread\n");
}
//merge result
}else{
printf("i sort this %zu\n",n);
qsort(base,n,s,cmp_func);
}
return NULL;
}
static void pragma147_omp_task_hclib_async(void *____arg) {
pragma147_omp_task *ctx = (pragma147_omp_task *)____arg;
hclib_start_finish();
{
par_sort((*(ctx->buf_ptr)));
} ; ; hclib_end_finish();
free(____arg);
}
int main(int ac, char** av)
{
int n = 20000;
int i;
double* a;
#ifdef ASSERT
double* b;
#endif
double start, end;
if (ac > 1)
sscanf(av[1], "%d", &n);
srand(getpid());
a = malloc(n * sizeof a[0]);
#ifdef ASSERT
b = malloc(n * sizeof a[0]);
#endif
for (i = 0; i < n; i++){
a[i] = rand();
#ifdef ASSERT
b[i] = a[i];
#endif
}
pthread_mutex_init(&thread_sum, NULL);
arg_struct arg = {a,n,sizeof a[0],cmp};
start = sec();
// print(a,n);
par_sort(&arg);
printf("par: %1.5f s\n", (sec() - start) );
start = sec();
#ifdef ASSERT
qsort(b, n, sizeof a[0] , cmp);
#endif
printf("seq: %1.5f s\n", (sec() - start) );
#ifdef ASSERT
for(i = 0; i < n ; i++){
if(a[i] != b[i]){
printf("%d \n %1.2f ",i, a[i]);
printf("%1.2f \n",b[i]);
}
}
#endif
free(a);
pthread_mutex_destroy(&thread_sum);
pthread_exit(NULL);
#ifdef ASSERT
free(b);
#endif
return 0;
}
int main(int ac, char** av)
{
int n = 2000000;
int i;
double* a;
double* b;
double start, end;
pthread_mutex_init(&thread_sum, NULL);
if (ac > 1)
sscanf(av[1], "%d", &n);
srand(getpid());
a = malloc(n * sizeof a[0]);
b = malloc(n* sizeof a[0]);
for (i = 0; i < n; i++){
a[i] = rand();
b[i] = a[i];
}
start = sec();
printf("runing parallell..\n");
par_sort(a, n, sizeof a[0], cmp);
end = sec();
double par_time = end - start;
start = sec();
printf("running qsort..\n");
qsort(b,n,sizeof a[0], cmp);
end = sec();
printf("running assert...\n");
for(i = 0; i<n;i++){
assert(a[i] == b[i]);
}
printf("seq: %1.2f s\n", end - start);
printf("par: %1.2f s\n",par_time);
free(a);
pthread_mutex_destroy(&thread_sum);
pthread_exit(NULL);
free(b);
return 0;
}
void par_sort(void* arg) {
sort_data_t *in = (sort_data_t*) arg;
TYPE* data = in->buffer;
int left = in->left;
int right = in->right;
if (right - left + 1 > HC_GRANULARITY) {
int index = partition(data, left, right);
#pragma omp parallel
{
#pragma omp single nowait
{
if (left < index - 1) {
sort_data_t* buf = (sort_data_t*) malloc(sizeof(sort_data_t));
buf->buffer = data;
buf->left = left;
buf->right = index - 1;
#pragma omp task
{
par_sort(buf);
}
}
if (index < right) {
sort_data_t* buf = (sort_data_t*) malloc(sizeof(sort_data_t));
buf->buffer = data;
buf->left = index;
buf->right = right;
#pragma omp task
{
par_sort(buf);
}
}
}
}
}
else {
// quicksort in C library
qsort(data+left, right - left + 1, sizeof(TYPE), compare);
}
free(arg);
}
int main(int ac, char** av)
{
int n = 2000000;
int i;
double* a;
double start, end;
if (ac > 1)
sscanf(av[1], "%d", &n);
srand(getpid());
a = malloc(n * sizeof a[0]);
for (i = 0; i < n; i++)
a[i] = rand();
start = sec();
#ifdef PARALLEL
par_sort(a, n, sizeof a[0], cmp);
#else
qsort(a, n, sizeof a[0], cmp);
#endif
end = sec();
printf("%1.2f s\n", (end - start));
for (i = 1; i < n; ++i)
{
if(a[i-1]>a[i])
printf("err result\n");
}
free(a);
return 0;
}
void thread_sort(void *args)
{
arg_struct_t* t = (arg_struct_t*)args;
par_sort(t->base,t->n,t->s,t->cmp);
}
