extern void fatalerror(char *s)
{ print_preamble();
printf("Fatal error: %s\n",s);
if (no_compiler_errors > 0) print_sorry_message();
#ifdef ARC_THROWBACK
throwback(0, s);
throwback_end();
#endif
#ifdef MAC_FACE
close_all_source();
if (temporary_files_switch) remove_temp_files();
abort_transcript_file();
free_arrays();
if (store_the_text)
my_free(&all_text,"transcription text");
longjmp(g_fallback, 1);
#endif
exit(1);
}
int
main (int argc, char *argv[])
{
int i, numprocs, rank, size;
int skip;
double latency = 0.0, t_start = 0.0, t_stop = 0.0;
double timer=0.0;
double avg_time = 0.0, max_time = 0.0, min_time = 0.0;
char * sendbuf = NULL, * recvbuf = NULL;
int po_ret;
size_t bufsize;
set_header(HEADER);
set_benchmark_name("osu_gather");
enable_accel_support();
po_ret = process_options(argc, argv);
if (po_okay == po_ret && none != options.accel) {
if (init_accel()) {
fprintf(stderr, "Error initializing device\n");
exit(EXIT_FAILURE);
}
}
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
switch (po_ret) {
case po_bad_usage:
print_bad_usage_message(rank);
MPI_Finalize();
exit(EXIT_FAILURE);
case po_help_message:
print_help_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_version_message:
print_version_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_okay:
break;
}
if(numprocs < 2) {
if (rank == 0) {
fprintf(stderr, "This test requires at least two processes\n");
}
MPI_Finalize();
exit(EXIT_FAILURE);
}
if ((options.max_message_size * numprocs) > options.max_mem_limit) {
options.max_message_size = options.max_mem_limit / numprocs;
}
if (0 == rank) {
bufsize = options.max_message_size * numprocs;
if (allocate_buffer((void**)&recvbuf, bufsize, options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(recvbuf, options.accel, 1, bufsize);
}
if (allocate_buffer((void**)&sendbuf, options.max_message_size,
options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(sendbuf, options.accel, 0, options.max_message_size);
print_preamble(rank);
for (size=1; size <= options.max_message_size; size *= 2) {
if (size > LARGE_MESSAGE_SIZE) {
skip = SKIP_LARGE;
options.iterations = options.iterations_large;
} else {
skip = SKIP;
}
MPI_Barrier(MPI_COMM_WORLD);
timer=0.0;
for (i=0; i < options.iterations + skip ; i++) {
t_start = MPI_Wtime();
MPI_Gather(sendbuf, size, MPI_CHAR, recvbuf, size, MPI_CHAR, 0,
MPI_COMM_WORLD);
t_stop = MPI_Wtime();
if (i >= skip) {
timer+=t_stop-t_start;
}
MPI_Barrier(MPI_COMM_WORLD);
}
latency = (double)(timer * 1e6) / options.iterations;
MPI_Reduce(&latency, &min_time, 1, MPI_DOUBLE, MPI_MIN, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
avg_time = avg_time/numprocs;
print_stats(rank, size, avg_time, min_time, max_time);
MPI_Barrier(MPI_COMM_WORLD);
}
if (0 == rank) {
free_buffer(recvbuf, options.accel);
}
free_buffer(sendbuf, options.accel);
MPI_Finalize();
if (none != options.accel) {
if (cleanup_accel()) {
fprintf(stderr, "Error cleaning up device\n");
exit(EXIT_FAILURE);
}
}
return EXIT_SUCCESS;
}
static void Write(FILE *fp, Gdinfo *ginfo) {
register int i,j,k;
const int nel = ginfo->nel;
double *x = ginfo->x;
double *y = ginfo->y;
print_preamble(fp);
/* write mesh */
fprintf(fp,
"**MESH DATA** 1st line is X of corner 1,2,3,4. 2nd line is Y.\n");
fprintf(fp,"\t %d \t %d \t %d \t NEL,NDIM,NELV\n",nel,2,nel);
for(i = 0; i < nel; ++i) {
fprintf(fp,"\tELEMENT %d [ 1A] GROUP 0\n",i+1);
for(j = 0; j < 3; ++j)
fprintf(fp," %12.6lf",x[ginfo->elmtpts[i][j]-1]);
fprintf(fp," %12.6lf\n",x[ginfo->elmtpts[i][0]-1]);
for(j = 0; j < 3; ++j)
fprintf(fp," %12.6lf",y[ginfo->elmtpts[i][j]-1]);
fprintf(fp," %12.6lf\n",y[ginfo->elmtpts[i][0]-1]);
}
fprintf(fp," ***** CURVED SIDE DATA ***** \n");
if(ginfo->clist) {
int n;
Curlist *cl;
Curinfo *c;
/* count to see how many types */
for(n=0,c = ginfo->curve; c; c = c->next) ++n;
fprintf(fp,"%d\tNumber of curve types \n",n);
for(c = ginfo->curve; c; c = c->next)
switch(c->type) {
case 'C':
fprintf(fp,"Circle\n");
fprintf(fp,"%lf %lf %lf %c xc yc rad tagid\n",c->info.arc.xc,
c->info.arc.yc,c->info.arc.radius,c->type);
break;
case 'S':
fprintf(fp,"Straight sided\n");
fprintf(fp,"%c\ttagid\n",c->idtype);
break;
case 'F':
fprintf(fp,"File\n");
fprintf(fp,"%s %c\n",c->info.file.name,c->idtype);
break;
default:
fprintf(stderr,"unknown curve type %c\n",c->idtype);
}
for(n=0,cl = ginfo->clist; cl; cl = cl->next) ++n;
fprintf(fp,"%d\tnumber of curved sides, (iside, iel, tagid) \n",n);
for(cl=ginfo->clist,n=0; cl; cl = cl->next,++n) {
fprintf(fp,"%d %d %c \t",cl->iside+1,cl->eid,cl->type);
if((n+1)%4 == 0) fprintf(fp,"\n");
}
if(!(n%4 == 0))fprintf(fp,"\n");
}
else
fprintf(fp," 0 Curved sides follow IEDGE,IEL,CURVE(I),I=1,5, CCURVE \n");
/* write fluid boundary conditions */
fprintf(fp," ***** BOUNDARY CONDITIONS *****\n");
fprintf(fp," ***** FLUID BOUNDARY CONDITIONS *****\n");
for(i = 0; i < nel; ++i) {
for(j = 0; j < 3; ++j) {
switch(ginfo->elmtcon[i][j].type) {
case 'E':
fprintf(fp,"E %d %d %12.6lf %12.6lf 0.000000 \n",i+1,j+1,
(double) ginfo->elmtcon[i][j].elmtid,
(double) ginfo->elmtcon[i][j].vsid+1);
break;
case 'W':
case 'O':
case 'S':
case 'B':
case 'M':
case 'I':
case 'Z':
fprintf(fp,"%c %d %d 0.000000 0.000000 0.000000 \n",
ginfo->elmtcon[i][j].type,i+1,j+1);
break;
case 'V':
case 'F':
fprintf(fp,"%c %d %d %12.6lf %12.6lf %12.6lf \n",
ginfo->elmtcon[i][j].type,i+1,j+1,ginfo->elmtcon[i][j].f[0],
ginfo->elmtcon[i][j].f[1],ginfo->elmtcon[i][j].f[2]);
break;
case 'v':
case 'f':
case 'm':
fprintf(fp,"%c %d %d 0.000000 0.000000 0.000000 \n",
ginfo->elmtcon[i][j].type,i+1,j+1);
k = 0;
while(ginfo->elmtcon[i][j].str[k])
fprintf(fp,"\t%s",ginfo->elmtcon[i][j].str[k++]);
break;
default:
fprintf(stderr,"Unknown boundary type %c in Write\n",
ginfo->elmtcon[i][j].type);
fprintf(fp,"W %d %d 0.000000 0.000000 0.000000 \n",
i+1,j+1);
}
}
fprintf(fp, "not used\n");
}
print_postamble(fp);
}
int main(int argc, char *argv[])
{
int i, j, numprocs, rank, size;
double latency = 0.0, t_start = 0.0, t_stop = 0.0;
double timer=0.0;
double avg_time = 0.0, max_time = 0.0, min_time = 0.0;
float *sendbuf, *recvbuf;
int po_ret;
size_t bufsize;
int64_t* problems = all_reduce_kernels_size;
int64_t* numRepeats = all_reduce_kernels_repeat;
set_header(HEADER);
#ifdef ENABLE_MLSL
mlsl_comm_req request;
set_benchmark_name("mlsl_osu_allreduce");
#else
set_benchmark_name("osu_allreduce");
#endif
enable_accel_support();
po_ret = process_options(argc, argv);
if (po_okay == po_ret && none != options.accel) {
if (init_accel()) {
fprintf(stderr, "Error initializing device\n");
exit(EXIT_FAILURE);
}
}
#ifdef ENABLE_MLSL
MLSL_CALL(mlsl_environment_get_env(&env));
MLSL_CALL(mlsl_environment_init(env, &argc, &argv));
size_t process_idx, process_count;
MLSL_CALL(mlsl_environment_get_process_idx(env, &process_idx));
MLSL_CALL(mlsl_environment_get_process_count(env, &process_count));
rank = process_idx;
numprocs = process_count;
MLSL_CALL(mlsl_environment_create_distribution(env, process_count, 1, &distribution));
#else
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
#endif
switch (po_ret) {
case po_bad_usage:
print_bad_usage_message(rank);
FINALIZE();
exit(EXIT_FAILURE);
case po_help_message:
print_help_message(rank);
FINALIZE();
exit(EXIT_SUCCESS);
case po_version_message:
print_version_message(rank);
FINALIZE();
exit(EXIT_SUCCESS);
case po_okay:
break;
}
if(numprocs < 2) {
if (rank == 0) {
fprintf(stderr, "This test requires at least two processes\n");
}
FINALIZE();
exit(EXIT_FAILURE);
}
if (options.max_message_size > options.max_mem_limit) {
options.max_message_size = options.max_mem_limit;
}
bufsize = sizeof(float)*(options.max_message_size/sizeof(float));
if (allocate_buffer((void**)&sendbuf, bufsize, options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(sendbuf, options.accel, 1, bufsize);
bufsize = sizeof(float)*(options.max_message_size/sizeof(float));
if (allocate_buffer((void**)&recvbuf, bufsize, options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(recvbuf, options.accel, 0, bufsize);
print_preamble(rank, numprocs);
size = options.max_message_size/sizeof(float);
for (j = 0; j < _NUMBER_OF_KERNELS_; j++)
{
size = problems[j];
options.iterations = numRepeats[j];
MPI_Barrier(MPI_COMM_WORLD);
timer = 0.0;
t_start = MPI_Wtime();
for(i=0; i < options.iterations; i++) {
#ifdef ENABLE_MLSL
MLSL_CALL(mlsl_distribution_all_reduce(distribution, sendbuf, recvbuf, size, DT_FLOAT, RT_SUM, GT_DATA, &request));
MLSL_CALL(mlsl_environment_wait(env, request));
#else
MPI_Allreduce(sendbuf, recvbuf, size, MPI_FLOAT, MPI_SUM, MPI_COMM_WORLD);
#endif
}
t_stop = MPI_Wtime();
timer = t_stop-t_start;
latency = (double)(timer * 1e3) / options.iterations;
MPI_Reduce(&latency, &min_time, 1, MPI_DOUBLE, MPI_MIN, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
avg_time = avg_time/numprocs;
print_stats(rank, size, avg_time, min_time, max_time);
MPI_Barrier(MPI_COMM_WORLD);
}
free_buffer(sendbuf, options.accel);
free_buffer(recvbuf, options.accel);
FINALIZE();
if (none != options.accel) {
if (cleanup_accel()) {
fprintf(stderr, "Error cleaning up device\n");
exit(EXIT_FAILURE);
}
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int i = 0, rank;
int numprocs;
double avg_time = 0.0, max_time = 0.0, min_time = 0.0;
double latency = 0.0, t_start = 0.0, t_stop = 0.0;
double timer=0.0;
int po_ret;
set_header(HEADER);
set_benchmark_name("osu_barrier");
enable_accel_support();
po_ret = process_options(argc, argv);
if (po_okay == po_ret && none != options.accel) {
if (init_accel()) {
fprintf(stderr, "Error initializing device\n");
exit(EXIT_FAILURE);
}
}
options.show_size = 0;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
switch (po_ret) {
case po_bad_usage:
print_bad_usage_message(rank);
MPI_Finalize();
exit(EXIT_FAILURE);
case po_help_message:
print_help_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_version_message:
print_version_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_okay:
break;
}
if(numprocs < 2) {
if(rank == 0) {
fprintf(stderr, "This test requires at least two processes\n");
}
MPI_Finalize();
return EXIT_FAILURE;
}
print_preamble(rank);
options.skip = options.skip_large;
options.iterations = options.iterations_large;
timer = 0.0;
for(i=0; i < options.iterations + options.skip ; i++) {
t_start = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
t_stop = MPI_Wtime();
if(i>=options.skip){
timer+=t_stop-t_start;
}
}
MPI_Barrier(MPI_COMM_WORLD);
latency = (timer * 1e6) / options.iterations;
MPI_Reduce(&latency, &min_time, 1, MPI_DOUBLE, MPI_MIN, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
avg_time = avg_time/numprocs;
print_stats(rank, 0, avg_time, min_time, max_time);
MPI_Finalize();
return EXIT_SUCCESS;
}
void ast_export_root(FILE* dest, struct ast_node_t* node) {
print_preamble(dest);
print_naked_list(dest, node, 0, 1);
print_after(dest);
}
