/*
* Test for karatsuba routines
*/
int main (int argc, char* argv[])
{
std::srand(2);
// Test for correctness. If the implementations give different results,
// the test function will not return.
printf("Testing Karatsuba implementations... ");
TestKaratsuba();
printf("Validated\n");
glt_init(argc,argv);
// Test speed. The correctness tests are assumed to have warmed up the runtime.
printf("\nStarting speed tests. Parallel runs will use %d threads...\n\n",
glt_get_num_threads());
//TimeRoutine(karatsuba_serial, "Serial");
//TimeRoutine(karatsuba_vectorized, "Vectorized");
//TimeRoutine(karatsuba_parallel, "Parallel");
TimeRoutine2(karatsuba_glt, "GLT");
glt_finalize();
//TimeRoutine(karatsuba_parallel_vectorized, "Parallel/Vectorized");
return 0;
}
int main(int argc, char *argv[])
{
if(!glt_init())
{
printf("Failure!!!\n");
return -1;
}
gm_start();
glt_shutdown();
return 0;
}
void glt_pthread_start() {
char buff[10];
int num_threads = 2;
int num_workers = get_nprocs()/2;
sprintf(buff, "%d", num_threads);
setenv("GLT_NUM_THREADS", buff, 1);
sprintf(buff, "%d", num_workers);
setenv("GLT_NUM_WORKERS_PER_THREAD", buff, 1);
setenv("QTHREAD_SHEPHERD_BOUNDARY", "node", 1);
setenv("QTHREAD_WORKER_UNIT", "pu", 1);
int argc = 0;
char * argv;
glt_init(argc, &argv);
}
int main(int argc, char *argv[]) {
glt_init(argc,argv);
double times[TIMES];
double times_join[TIMES];
int i;
main_args_t * args;
struct timeval t_start_create, t_start_join, t_end_create, t_end_join;
int nthreads = glt_get_num_threads();
double inner_create[TIMES];
double inner_join[TIMES];
for ( i = 0; i< TIMES; i++){
times[i]=0.0;
times_join[i]=0.0;
}
for ( i = 0; i< TIMES; i++){
inner_create[i]=0.0;
inner_join[i]=0.0;
}
args = (main_args_t *) malloc(sizeof (main_args_t)
* nthreads);
GLT_ult * ults;
ults = glt_ult_malloc(nthreads);
for (int t = 0; t < TIMES; t++) {
gettimeofday(&t_start_create, NULL);
/* Work here */
for (i = 0; i < nthreads; i++) {
glt_ult_create_to(thread_func,(void *) &args[i],&ults[i],i);
}
gettimeofday(&t_end_create, NULL);
glt_yield();
gettimeofday(&t_start_join, NULL);
for (i = 0; i < nthreads; i++) {
glt_ult_join(&ults[i]);
}
gettimeofday(&t_end_join, NULL);
double time = (t_end_create.tv_sec * 1000000 + t_end_create.tv_usec) -
(t_start_create.tv_sec * 1000000 + t_start_create.tv_usec);
times[t] = (time / 1000000.0);
double time_join = (t_end_join.tv_sec * 1000000 + t_end_join.tv_usec) -
(t_start_join.tv_sec * 1000000 + t_start_join.tv_usec);
times_join[t] = (time_join / 1000000.0);
for (i = 0; i < nthreads; i++) {
/* Gather each thread individually*/
inner_create[t]+=args[i].create_time;
inner_join[t]+=args[i].join_time;
}
}
double o_min, o_max, o_avg, o_aux, o_sigma, o_dev;
double o_avgj=times_join[0];
o_min = times[0];
o_max = times[0];
o_aux = times[0];
for (int t = 1; t < TIMES; t++) {
if (times[t] < o_min) o_min = times[t];
if (times[t] > o_max) o_max = times[t];
o_aux += times[t];
o_avgj+=times_join[t];
}
o_avg = o_aux / TIMES;
for (int t = 0; t < TIMES; t++) {
o_sigma = o_sigma + ((times[t] - o_avg)*(times[t] - o_avg));
}
#ifndef VERBOSE
o_dev = sqrt(o_sigma / (TIMES - 1));
#else
o_dev = sqrt(o_sigma);
#endif
double i_min, i_max, i_avg, i_avgj ,i_aux, i_sigma, i_dev;
i_avg = inner_create[0];
i_avgj = inner_join[0];
for (int t = 1; t < TIMES; t++) {
i_avg += inner_create[t];
i_avgj += inner_join[t];
}
i_avg = (i_avg / TIMES) / nthreads;
i_avgj = (i_avgj / TIMES) / nthreads;
#ifndef VERBOSE
//printf("Nthreads OCreation OJoin ICreation IJoin"
#endif
printf("%d %f %f %f %f\n", nthreads, o_avg, o_avgj, i_avg, i_avgj );
glt_finalize();
return EXIT_SUCCESS;
}
