/***************************************************************************************************
*
* tio_read_pointquant_chunk_c
*
**************************************************************************************************/
void
F2C(tio_read_pointquant_chunk_c,TIO_READ_POINTQUANT_CHUNK_C)
( const TIO_File_tf *fileID,
const TIO_Object_tf *quantID,
const TIO_Size_tf *idx,
const int_f *xfer,
const int_f *datatype,
const TIO_Size_tf *nghosts,
TIO_Size_tf *nnodes,
void *qdat,
const int_f *narg,
TIO_tf *err )
{
TIO_Size_t l_nn;
void *qptr;
setpm(narg, qptr, qptr, qdat, qdat);
*err = c2f_TIO( TIO_Read_PointQuant_Chunk( f2c_file(*fileID),
f2c_object(*quantID),
f2c_idx(*idx),
f2c_xfer(*xfer),
f2c_datatype(*datatype),
f2c_ghosts(*nghosts),
&l_nn,
qptr ) );
if (*err != TIO_SUCCESS_F) return;
*nnodes = c2f_size(l_nn);
return;
}
/***************************************************************************************************
*
* tio_read_pointquant_section_c
*
**************************************************************************************************/
void
F2C(tio_read_pointquant_section_c,TIO_READ_POINTQUANT_SECTION_C)
( const TIO_File_tf *fileID,
const TIO_Object_tf *quantID,
const TIO_Object_tf *sectionID,
const int_f *xfer,
const int_f *datatype,
TIO_Size_tf *nnodes,
void *qdat,
const int_f *narg,
TIO_tf *err )
{
TIO_Size_t l_nn;
void *qptr;
setpm(narg, qptr, qptr, qdat, qdat);
*err = c2f_TIO( TIO_Read_PointQuant_Section( f2c_file(*fileID),
f2c_object(*quantID),
f2c_object(*sectionID),
f2c_xfer(*xfer),
f2c_datatype(*datatype),
&l_nn,
qptr ) );
if (*err != TIO_SUCCESS_F) return;
*nnodes = c2f_size(l_nn);
return;
}
/***************************************************************************************************
*
* tio_read_unstrquant_all_c
*
**************************************************************************************************/
void
F2C(tio_read_unstrquant_all_c,TIO_READ_UNSTRQUANT_ALL_C)
( const TIO_File_tf *fileID,
const TIO_Object_tf *quantID,
const int_f *datatype,
TIO_Size_tf *nn,
void *qdat,
TIO_Size_tf *nmixcomp,
void *qmix,
const int_f *narg,
TIO_tf *err )
{
TIO_Size_t l_nn, l_nmc;
void *datptr, *mixptr;
setpm(narg, datptr, mixptr, qdat, qmix);
*err = c2f_TIO( TIO_Read_UnstrQuant_All( f2c_file(*fileID),
f2c_object(*quantID),
f2c_datatype(*datatype),
&l_nn,
datptr,
&l_nmc,
mixptr ) );
if (*err != TIO_SUCCESS_F) return;
*nn = c2f_size(l_nn);
*nmixcomp = c2f_size(l_nmc);
return;
}
/***************************************************************************************************
*
* tio_write_unstrquant_chunk_c
*
**************************************************************************************************/
void
F2C(tio_write_unstrquant_chunk_c,TIO_WRITE_UNSTRQUANT_CHUNK_C)
( const TIO_File_tf *fileID,
const TIO_Object_tf *quantID,
const TIO_Size_tf *idx,
const int_f *xfer,
const int_f *datatype,
const void *qdat,
const void *qmix,
const int_f *narg,
TIO_tf *err )
{
const void *datptr, *mixptr;
setpm(narg, datptr, mixptr, qdat, qmix);
*err = c2f_TIO( TIO_Write_UnstrQuant_Chunk( f2c_file(*fileID),
f2c_object(*quantID),
f2c_idx(*idx),
f2c_xfer(*xfer),
f2c_datatype(*datatype),
datptr,
mixptr ) );
return;
}
/***************************************************************************************************
*
* tio_read_quadquant_chunk_c
*
**************************************************************************************************/
void
F2C(tio_read_quadquant_chunk_c,TIO_READ_QUADQUANT_CHUNK_C)
( const TIO_File_tf *fileID,
const TIO_Object_tf *quantID,
const TIO_Size_tf *idx,
const int_f *xfer,
const int_f *datatype,
const TIO_Size_tf *nghosts,
int_f *ndims,
TIO_Size_tf *ni,
TIO_Size_tf *nj,
TIO_Size_tf *nk,
void *qdat,
TIO_Size_tf *nmixcomp,
void *qmix,
const int_f *narg,
TIO_tf *err )
{
TIO_Dims_t l_ndims;
TIO_Size_t l_ni, l_nj, l_nk, l_nmc;
void *datptr, *mixptr;
setpm(narg, datptr, mixptr, qdat, qmix);
*err = c2f_TIO( TIO_Read_QuadQuant_Chunk( f2c_file(*fileID),
f2c_object(*quantID),
f2c_idx(*idx),
f2c_xfer(*xfer),
f2c_datatype(*datatype),
f2c_ghosts(*nghosts),
&l_ndims,
&l_ni,
&l_nj,
&l_nk,
datptr,
&l_nmc,
mixptr ) );
if (*err != TIO_SUCCESS_F) return;
*ndims = c2f_size(l_ndims);
*ni = c2f_size(l_ni);
*nj = c2f_size(l_nj);
*nk = c2f_size(l_nk);
*nmixcomp = c2f_size(l_nmc);
return;
}
/***************************************************************************************************
*
* tio_read_unstrquant_chunk_c
*
**************************************************************************************************/
void
F2C(tio_read_unstrquant_chunk_c,TIO_READ_UNSTRQUANT_CHUNK_C)
( const TIO_File_tf *fileID,
const TIO_Object_tf *quantID,
const TIO_Size_tf *idx,
const int_f *xfer,
const int_f *datatype,
const TIO_Size_tf *nghosts,
TIO_Size_tf *nn,
void *qdat,
TIO_Size_tf *nmixcomp,
void *qmix,
const int_f *narg,
TIO_tf *err )
{
TIO_Size_t l_nn, l_nmc;
void *datptr, *mixptr;
setpm(narg, datptr, mixptr, qdat, qmix);
*err = c2f_TIO( TIO_Read_UnstrQuant_Chunk( f2c_file(*fileID),
f2c_object(*quantID),
f2c_idx(*idx),
f2c_xfer(*xfer),
f2c_datatype(*datatype),
f2c_ghosts(*nghosts),
&l_nn,
datptr,
&l_nmc,
mixptr ) );
if (*err != TIO_SUCCESS_F) return;
*nn = c2f_size(l_nn);
*nmixcomp = c2f_size(l_nmc);
return;
}
//-----------------------------------------------------------------------------------------------------------------------//
// main
//-----------------------------------------------------------------------------------------------------------------------//
int main(int argc, char * argv[])
{
int rc=0;
int rank=0;
#ifdef MPI
int comsize;
// init MPI
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &comsize);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
fprintf(stderr,"rank=%d\n", rank);
#ifdef BGQ
install_signal_handler();
#endif
#endif
args = parseargs(argc, argv);
// init, initcamera, initvolattrs
if ((rc=init(args, rank) != 0)) {
fprintf(stderr, "initialization failed: %d\n", rc);
return 0;
};
//---------------------------- Platform Specific Display and Interaction ----------------------------------------//
#if LOCAL
resettransforms();
mystate.alpha=0.25f;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(WINDOWWIDTH, WINDOWHEIGHT);
glutCreateWindow("iVR");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mousebutton);
glutMotionFunc(mousemotion);
// glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glDisable(GL_DEPTH_TEST);
glutMainLoop();
#elif MPI // BEGIN MPI CODE
#ifdef REMOTE // START OF REMOTE RENDERING HANDSHAKE
// connect to relay server
if (rank == 0) {
sockfd = initconnection(HOSTNAME, PORT);
if (sockfd == -1) {
fprintf(stderr,"remote connection failed, sockfd=%d\n",sockfd);
freeall();
exit(0);
}
fprintf(stderr,"relay connection succeeded\n");
}
PRINTDEBUG("%3d: \n", rank);
boolean_t connected = TRUE;
int ctr = 0;
while (connected) { // main loop when steering
fprintf(stderr,"%3d: before steering control\n", rank);
if (rank == 0) {
rc = recvstate(sockfd, &mystate);
fprintf(stderr,"bytes recvd=%d\n", rc);
if (mystate.finish) connected = 0;;
winwidth = mystate.winwidth;
winheight=mystate.winheight;
} // end if rank == 0 for remote visualization
// wait until we've completed the handshake with steering client before proceeding;
MPI_Barrier(MPI_COMM_WORLD);
MPI_Bcast(&connected, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (!connected) break;
MPI_Bcast((float *)&winwidth, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast((float *)&winheight, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast(&mystate.alpha, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast(mystate.newconst, 6, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast(mystate.mvm, 16, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast(mystate.pm, 16, MPI_FLOAT, 0, MPI_COMM_WORLD);
MPI_Bcast(mystate.vv, 4, MPI_FLOAT, 0, MPI_COMM_WORLD);
#endif
float planeconst[6] = {pzero[0], pzero[1], pzero[2], pzero[3], pzero[4], pzero[5]};
setviewport(&viewport, 0, 0, winwidth, winheight);
setplaneconst(planeconst, mystate.newconst);
setmvm(mvm, mystate.mvm);
setpm(pm, mystate.pm);
setfrustum(&viewvolume, mystate.vv);
updatevolbbox();
initcolbufs(rank);
// create and display the image
unsigned long long lstart, lstop;
for (int i=0; i<1; i++) {
TIME(RENDER, lstart);
createlocalimage(rank);
// can't composite until all ranks have completed local image generation
MPI_Barrier(MPI_COMM_WORLD);
compositelocalimage();
TIME(RENDER, lstop);
PERFORMANCE(lstart, lstop, framenum, elapsed, avg);
}
// wait until all ranks exit composite step before writing image
MPI_Barrier(MPI_COMM_WORLD);
writeimage(ctr++);
#ifdef REMOTE
} // end while remote loop
if (rank == 0) disconnect(sockfd);
#endif // END OF REMOTE CLIENT HANDSHAKE
fprintf(stderr,"%3d: finished\n", rank);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
#endif
// clean up
freeall();
exit(0);
}
