void escrita() { int i; MPI_Type_contiguous(TAMTUPLA, MPI_INT,&tupla); MPI_Type_commit(&tupla); ret = MPI_File_open( MPI_COMM_WORLD, "arquivofinal.dat", MPI_MODE_WRONLY | MPI_MODE_CREATE, MPI_INFO_NULL, &arquivofinal); if (ret == 0) printf("Arquivo final aberto com sucesso no processo %d \n", meu_ranque); else { printf("Arquivo final aberto com erro no processo %d \n", meu_ranque); MPI_Abort(MPI_COMM_WORLD, 1); } MPI_File_set_view( arquivofinal, 0, MPI_INT, MPI_INT, "native", MPI_INFO_NULL); for (i = 0; i < TAMBUF; i+=TAMTUPLA) MPI_File_write_ordered( arquivofinal, buf_leitura + i, 1, tupla, MPI_STATUS_IGNORE); MPI_File_close(&arquivofinal); }
FORT_DLL_SPEC void FORT_CALL mpi_file_write_ordered_ ( MPI_Fint *v1, void*v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ) { #ifdef MPI_MODE_RDONLY *ierr = MPI_File_write_ordered( MPI_File_f2c(*v1), v2, *v3, (MPI_Datatype)(*v4), (MPI_Status *)(v5) ); #else *ierr = MPI_ERR_INTERN; #endif }
FORTRAN_API void FORT_CALL mpi_file_write_ordered_(MPI_Fint *fh,void *buf,MPI_Fint *count, MPI_Fint *datatype,MPI_Status *status, MPI_Fint *ierr ) { MPI_File fh_c; fh_c = MPI_File_f2c(*fh); *ierr = MPI_File_write_ordered(fh_c,buf,*count,*datatype,status); }
void mpi_file_write_ordered_(MPI_Fint *fh,void *buf,MPI_Fint *count, MPI_Fint *datatype,MPI_Status *status, MPI_Fint *ierr ) { MPI_File fh_c; MPI_Datatype datatype_c; fh_c = MPI_File_f2c(*fh); datatype_c = MPI_Type_f2c(*datatype); *ierr = MPI_File_write_ordered(fh_c,buf,*count,datatype_c,status); }
int main( int argc, char *argv[] ) { int errs = 0; int size, rank, i, *buf, rc; MPI_File fh; MPI_Comm comm; MPI_Status status; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_File_open( comm, (char*)"test.ord", MPI_MODE_RDWR | MPI_MODE_CREATE | MPI_MODE_DELETE_ON_CLOSE, MPI_INFO_NULL, &fh ); MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); buf = (int *)malloc( size * sizeof(int) ); buf[0] = rank; rc = MPI_File_write_ordered( fh, buf, 1, MPI_INT, &status ); if (rc) { MTestPrintErrorMsg( "File_write_ordered", rc ); errs++; } /* make sure all writes finish before we seek/read */ MPI_Barrier(comm); /* Set the individual pointer to 0, since we want to use a read_all */ MPI_File_seek( fh, 0, MPI_SEEK_SET ); MPI_File_read_all( fh, buf, size, MPI_INT, &status ); for (i=0; i<size; i++) { if (buf[i] != i) { errs++; fprintf( stderr, "%d: buf[%d] = %d\n", rank, i, buf[i] ); } } MPI_File_seek_shared( fh, 0, MPI_SEEK_SET ); for (i=0; i<size; i++) buf[i] = -1; MPI_File_read_ordered( fh, buf, 1, MPI_INT, &status ); if (buf[0] != rank) { errs++; fprintf( stderr, "%d: buf[0] = %d\n", rank, buf[0] ); } free( buf ); MPI_File_close( &fh ); MTest_Finalize( errs ); MPI_Finalize(); return 0; }
FORT_DLL_SPEC void FORT_CALL mpi_file_write_ordered_ ( MPI_Fint *v1, void*v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ #ifdef MPI_MODE_RDONLY #ifndef HAVE_MPI_F_INIT_WORKS_WITH_C if (MPIR_F_NeedInit){ mpirinitf_(); MPIR_F_NeedInit = 0; } #endif if (v5 == MPI_F_STATUS_IGNORE) { v5 = (MPI_Fint*)MPI_STATUS_IGNORE; } *ierr = MPI_File_write_ordered( MPI_File_f2c(*v1), v2, (int)*v3, (MPI_Datatype)(*v4), (MPI_Status *)v5 ); #else *ierr = MPI_ERR_INTERN; #endif }
JNIEXPORT void JNICALL Java_mpi_File_writeOrdered( JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db, jint off, jint count, jlong jType, jint bType, jlongArray stat) { MPI_Datatype type = (MPI_Datatype)jType; void *ptr; ompi_java_buffer_t *item; ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType); MPI_Status status; int rc = MPI_File_write_ordered((MPI_File)fh, ptr, count, type, &status); ompi_java_exceptionCheck(env, rc); ompi_java_releaseReadPtr(ptr, item, buf, db); ompi_java_status_set(env, stat, &status); }
void mpi_file_write_ordered_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_Fint *datatype, MPI_Fint *status, MPI_Fint *ierr) { MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; #if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif /* See if we got MPI_STATUS_IGNORE */ if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) { c_status = MPI_STATUS_IGNORE; } else { /* If sizeof(int) == sizeof(INTEGER), then there's no translation necessary -- let the underlying functions write directly into the Fortran status */ #if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; #endif } *ierr = OMPI_FINT_2_INT(MPI_File_write_ordered(c_fh, OMPI_F2C_BOTTOM(buf), OMPI_FINT_2_INT(*count), c_type, c_status)); #if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); } #endif }
void ExporterVTK<MeshType,N>::saveNodeData( typename timeset_type::step_ptrtype step, Iterator __var, Iterator en, vtkSmartPointer<vtkout_type> out ) const { while ( __var != en ) { if ( !__var->second.worldComm().isActive() ) return; /* handle faces data */ #if 0 if ( boption( _name="exporter.ensightgold.save-face" ) ) { BOOST_FOREACH( auto m, __mesh->markerNames() ) { if ( m.second[1] != __mesh->nDim-1 ) continue; VLOG(1) << "writing face with marker " << m.first << " with id " << m.second[0]; auto pairit = __mesh->facesWithMarker( m.second[0], this->worldComm().localRank() ); auto fit = pairit.first; auto fen = pairit.second; Feel::detail::MeshPoints<float> mp( __mesh.get(), this->worldComm(), fit, fen, true, true, true ); int __ne = std::distance( fit, fen ); int nverts = fit->numLocalVertices; DVLOG(2) << "Faces : " << __ne << "\n"; if( this->worldComm().isMasterRank() ) { size = sizeof(buffer); } else { size = 0; } memset(buffer, '\0', sizeof(buffer)); strcpy( buffer, "part" ); MPI_File_write_ordered(fh, buffer, size, MPI_CHAR, &status); int32_t partid = m.second[0]; if( this->worldComm().isMasterRank() ) { size = 1; } else { size = 0; } MPI_File_write_ordered(fh, &partid, size, MPI_INT32_T, &status); if( this->worldComm().isMasterRank() ) { size = sizeof(buffer); } else { size = 0; } memset(buffer, '\0', sizeof(buffer)); strcpy( buffer, "coordinates" ); MPI_File_write_ordered(fh, buffer, size, MPI_CHAR, &status); // write values fit = pairit.first; fen = pairit.second; uint16_type nComponents = __var->second.nComponents; if ( __var->second.is_vectorial ) nComponents = 3; int nfaces = mp.ids.size(); std::vector<float> field( nComponents*nfaces, 0.0 ); for( ; fit != fen; ++fit ) { for ( uint16_type c = 0; c < nComponents; ++c ) { for ( size_type j = 0; j < nverts; j++ ) { size_type pid = mp.old2new[fit->point( j ).id()]-1; size_type global_node_id = nfaces*c + pid ; if ( c < __var->second.nComponents ) { size_type thedof = __var->second.start() + boost::get<0>(__var->second.functionSpace()->dof()->faceLocalToGlobal( fit->id(), j, c )); field[global_node_id] = __var->second.globalValue( thedof ); } else { field[global_node_id] = 0; } } } } /* Write each component separately */ for ( uint16_type c = 0; c < __var->second.nComponents; ++c ) { MPI_File_write_ordered(fh, field.data() + nfaces * c, nfaces, MPI_FLOAT, &status); } } // boundaries loop } #endif /* handle elements */ uint16_type nComponents = __var->second.nComponents; VLOG(1) << "nComponents field: " << nComponents; if ( __var->second.is_vectorial ) { nComponents = 3; VLOG(1) << "nComponents field(is_vectorial): " << nComponents; } /* we get that from the local processor */ /* We do not need the renumbered global index */ //auto r = markedelements(__mesh, M_markersToWrite[i], EntityProcessType::ALL); auto r = elements( step->mesh() ); auto elt_it = r.template get<1>(); auto elt_en = r.template get<2>(); Feel::detail::MeshPoints<float> mp( step->mesh().get(), this->worldComm(), elt_it, elt_en, false, true, true, 0 ); // previous implementation //size_type __field_size = mp.ids.size(); //int nelts = std::distance(elt_it, elt_en); int npts = mp.ids.size(); size_type __field_size = npts; if ( __var->second.is_vectorial ) __field_size *= 3; std::vector<float> __field( __field_size, 0.0 ); size_type e = 0; VLOG(1) << "field size=" << __field_size; if ( !__var->second.areGlobalValuesUpdated() ) __var->second.updateGlobalValues(); vtkSmartPointer<vtkFloatArray> da = vtkSmartPointer<vtkFloatArray>::New(); da->SetName(__var->first.c_str()); /* set array parameters */ /* no need for preallocation if we are using Insert* methods */ da->SetNumberOfComponents(nComponents); da->SetNumberOfTuples(npts); /* std::cout << this->worldComm().rank() << " nbPts:" << npts << " nComp:" << nComponents << " __var->second.nComponents:" << __var->second.nComponents << std::endl; */ /* std::cout << this->worldComm().rank() << " marker=" << *mit << " nbPts:" << npts << " nComp:" << nComponents << " __evar->second.nComponents:" << __var->second.nComponents << std::endl; */ /* loop on the elements */ int index = 0; for ( ; elt_it != elt_en; ++elt_it ) { VLOG(3) << "is ghost cell " << elt_it->isGhostCell(); /* looop on the ccomponents is outside of the loop on the vertices */ for ( uint16_type c = 0; c < nComponents; ++c ) { for ( uint16_type p = 0; p < step->mesh()->numLocalVertices(); ++p, ++e ) { size_type ptid = mp.old2new[elt_it->point( p ).id()]; size_type global_node_id = ptid * nComponents + c; //size_type global_node_id = mp.ids.size()*c + ptid ; //LOG(INFO) << elt_it->get().point( p ).id() << " " << ptid << " " << global_node_id << std::endl; DCHECK( ptid < step->mesh()->numPoints() ) << "Invalid point id " << ptid << " element: " << elt_it->id() << " local pt:" << p << " mesh numPoints: " << step->mesh()->numPoints(); DCHECK( global_node_id < __field_size ) << "Invalid dof id : " << global_node_id << " max size : " << __field_size; if ( c < __var->second.nComponents ) { size_type dof_id = boost::get<0>( __var->second.functionSpace()->dof()->localToGlobal( elt_it->id(), p, c ) ); __field[global_node_id] = __var->second.globalValue( dof_id ); //__field[npts*c + index] = __var->second.globalValue( dof_id ); //DVLOG(3) << "v[" << global_node_id << "]=" << __var->second.globalValue( dof_id ) << " dof_id:" << dof_id; DVLOG(3) << "v[" << (npts*c + index) << "]=" << __var->second.globalValue( dof_id ) << " dof_id:" << dof_id; } else { __field[global_node_id] = 0.0; //__field[npts*c + index] = 0.0; } } } /* increment index of vertex */ index++; } /* insert data into array */ for(int i = 0; i < npts; i++) { da->SetTuple(mp.ids[i], __field.data() + i * nComponents); } /* add data array into the vtk object */ out->GetPointData()->AddArray(da); /* Set the first scalar/vector/tensor data, we process as active */ if( __var->second.is_scalar && !(out->GetPointData()->GetScalars())) { out->GetPointData()->SetActiveScalars(da->GetName()); } if( __var->second.is_vectorial && !(out->GetPointData()->GetVectors())) { out->GetPointData()->SetActiveVectors(da->GetName()); } if( __var->second.is_tensor2 && !(out->GetPointData()->GetTensors())) { out->GetPointData()->SetActiveTensors(da->GetName()); } DVLOG(2) << "[ExporterVTK::saveNodal] saving " << __var->first << "done\n"; ++__var; } }
int main(int argc, char *argv[]) { int width, height, maxiter, flag; double x[2], y[2], c[2]; char *image, *stats; int comm_sz, my_rank; double t1, t2, delta; // Get and parse the program parameters getParams(argv, &flag, c, x, y, &width, &height, &maxiter, &image, &stats); // Allocate space for the image int *iterations = (int*)malloc( sizeof(int) * width * height ); assert(iterations != NULL); // Start MPI MPI_Init(NULL, NULL); MPI_Comm_size(MPI_COMM_WORLD, &comm_sz); MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); // Begin process timer t1 = MPI_Wtime(); /* compute set */ int maxCount = parallelJulia(x, width, y, height, c, flag, maxiter, iterations, my_rank, comm_sz, MPI_COMM_WORLD); // Stop timer and compute time elapse t2 = MPI_Wtime(); delta = t2 - t1; if (my_rank == 0) { /* save our picture for the viewer */ printf("\nMaster process %d creating image...\n", my_rank); saveBMP(image, iterations, width, height); printf("\nFinished image creation\n"); } // Wait for all processes to finish Julia computations MPI_Barrier(MPI_COMM_WORLD); // Open stats file MPI_File statsFile; if (MPI_File_open(MPI_COMM_WORLD, stats, MPI_MODE_CREATE|MPI_MODE_WRONLY, MPI_INFO_NULL, &statsFile) == MPI_SUCCESS) { // Generate statistic string char message[100]; sprintf(message, "process %d: max iterations reached = %d, time elapsed = %lf\n", my_rank, maxCount, delta); MPI_File_write_ordered(statsFile, message, strlen(message), MPI_CHAR, MPI_STATUS_IGNORE); MPI_File_close(&statsFile); } else printf("Problem opening file on process %d\n", my_rank); // Close MPI environment MPI_Finalize(); // Free reserved memory free(iterations); return 0; }
int main(int argc, char **argv) { int *buf, i, rank, nprocs, len, sum; int global_sum; int errs=0, toterrs, errcode; char *filename; MPI_File fh; MPI_Status status; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); double wr_stime, wr_etime, wr_time, wr_sumtime; double rd_stime, rd_etime, rd_time, rd_sumtime; /* process 0 takes the file name as a command-line argument and broadcasts it to other processes */ if (!rank) { i = 1; while ((i < argc) && strcmp("-fname", *argv)) { i++; argv++; } if (i >= argc) { fprintf(stderr, "\n*# Usage: shared_fp -fname filename\n\n"); MPI_Abort(MPI_COMM_WORLD, 1); } argv++; len = strlen(*argv); filename = (char *) malloc(len+10); strcpy(filename, *argv); MPI_Bcast(&len, 1, MPI_INT, 0, MPI_COMM_WORLD); MPI_Bcast(filename, len+10, MPI_CHAR, 0, MPI_COMM_WORLD); } else { MPI_Bcast(&len, 1, MPI_INT, 0, MPI_COMM_WORLD); filename = (char *) malloc(len+10); MPI_Bcast(filename, len+10, MPI_CHAR, 0, MPI_COMM_WORLD); } buf = (int *) malloc(COUNT * sizeof(int)); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); for (i=0; i<COUNT; i++) buf[i] = COUNT*rank + i; errcode = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_CREATE | MPI_MODE_RDWR, MPI_INFO_NULL, &fh); if (errcode != MPI_SUCCESS) { handle_error(errcode, "MPI_File_open"); } wr_stime = MPI_Wtime(); errcode = MPI_File_write_ordered(fh, buf, COUNT, MPI_INT, &status); if (errcode != MPI_SUCCESS) { handle_error(errcode, "MPI_File_write_shared"); } wr_etime = MPI_Wtime(); for (i=0; i<COUNT; i++) buf[i] = 0; MPI_Barrier(MPI_COMM_WORLD); rd_stime = MPI_Wtime(); errcode = MPI_File_seek_shared(fh, 0, MPI_SEEK_SET); if (errcode != MPI_SUCCESS) { handle_error(errcode, "MPI_File_seek_shared"); } errcode = MPI_File_read_ordered(fh, buf, COUNT, MPI_INT, &status); if (errcode != MPI_SUCCESS) { handle_error(errcode, "MPI_File_read_shared"); } rd_etime = MPI_Wtime(); MPI_File_close(&fh); sum = 0; for (i=0; i<COUNT; i++) sum += buf[i]; MPI_Allreduce(&sum, &global_sum, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); wr_time = wr_etime - wr_stime; rd_time = rd_etime - rd_stime; MPI_Allreduce(&wr_time, &wr_sumtime, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD); MPI_Allreduce(&rd_time, &rd_sumtime, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD); if (global_sum != (((COUNT*nprocs - 1)*(COUNT*nprocs))/2)) { errs++; fprintf(stderr, "Error: sum %d, global_sum %d, %d\n", sum, global_sum,(((COUNT*nprocs - 1)*(COUNT*nprocs))/2)); } free(buf); free(filename); MPI_Allreduce( &errs, &toterrs, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD ); if (rank == 0) { if( toterrs > 0) { fprintf( stderr, "Found %d errors\n", toterrs ); } else { fprintf( stdout, " No Errors\n" ); #ifdef TIMING fprintf( stderr, "nprocs: %d bytes: %d write: %f read %f\n", nprocs, COUNT*sizeof(int), wr_sumtime, rd_sumtime); #endif } } MPI_Finalize(); return 0; }
int main( int argc, char *argv[] ) { int errs = 0; int size, rank, i, *buf, count, rc; MPI_File fh; MPI_Comm comm; MPI_Status status; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; rc = MPI_File_open( comm, (char*)"test.ord", MPI_MODE_RDWR | MPI_MODE_CREATE | MPI_MODE_DELETE_ON_CLOSE, MPI_INFO_NULL, &fh ); if (rc) { MTestPrintErrorMsg( "File_open", rc ); errs++; /* If the open fails, there isn't anything else that we can do */ goto fn_fail; } MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); buf = (int *)malloc( size * sizeof(int) ); buf[0] = rank; /* Write to file */ rc = MPI_File_write_ordered( fh, buf, 1, MPI_INT, &status ); if (rc) { MTestPrintErrorMsg( "File_write_ordered", rc ); errs++; } else { MPI_Get_count( &status, MPI_INT, &count ); if (count != 1) { errs++; fprintf( stderr, "Wrong count (%d) on write-ordered\n", count ); } } /* Set the individual pointer to 0, since we want to use a read_all */ MPI_File_seek( fh, 0, MPI_SEEK_SET ); /* Read nothing (check status) */ memset( &status, 0xff, sizeof(MPI_Status) ); MPI_File_read( fh, buf, 0, MPI_INT, &status ); MPI_Get_count( &status, MPI_INT, &count ); if (count != 0) { errs++; fprintf( stderr, "Count not zero (%d) on read\n", count ); } /* Write nothing (check status) */ memset( &status, 0xff, sizeof(MPI_Status) ); MPI_File_write( fh, buf, 0, MPI_INT, &status ); if (count != 0) { errs++; fprintf( stderr, "Count not zero (%d) on write\n", count ); } /* Read shared nothing (check status) */ MPI_File_seek_shared( fh, 0, MPI_SEEK_SET ); /* Read nothing (check status) */ memset( &status, 0xff, sizeof(MPI_Status) ); MPI_File_read_shared( fh, buf, 0, MPI_INT, &status ); MPI_Get_count( &status, MPI_INT, &count ); if (count != 0) { errs++; fprintf( stderr, "Count not zero (%d) on read shared\n", count ); } /* Write nothing (check status) */ memset( &status, 0xff, sizeof(MPI_Status) ); MPI_File_write_shared( fh, buf, 0, MPI_INT, &status ); if (count != 0) { errs++; fprintf( stderr, "Count not zero (%d) on write\n", count ); } MPI_Barrier( comm ); MPI_File_seek_shared( fh, 0, MPI_SEEK_SET ); for (i=0; i<size; i++) buf[i] = -1; MPI_File_read_ordered( fh, buf, 1, MPI_INT, &status ); if (buf[0] != rank) { errs++; fprintf( stderr, "%d: buf = %d\n", rank, buf[0] ); } free( buf ); MPI_File_close( &fh ); fn_fail: MTest_Finalize( errs ); MPI_Finalize(); return 0; }
/* * access style is explicitly described as modifiable. values include * read_once, read_mostly, write_once, write_mostlye, random * * */ int main(int argc, char *argv[]) { int errs = 0, err; int buf[10]; int rank; MPI_Comm comm; MPI_Status status; MPI_File fh; MPI_Info infoin, infoout; char value[1024]; int flag, count; MTest_Init(&argc, &argv); comm = MPI_COMM_WORLD; MPI_Comm_rank(comm, &rank); MPI_Info_create(&infoin); MPI_Info_set(infoin, (char *) "access_style", (char *) "write_once,random"); MPI_File_open(comm, (char *) "testfile", MPI_MODE_RDWR | MPI_MODE_CREATE, infoin, &fh); buf[0] = rank; err = MPI_File_write_ordered(fh, buf, 1, MPI_INT, &status); if (err) { errs++; MTestPrintError(err); } MPI_Info_set(infoin, (char *) "access_style", (char *) "read_once"); err = MPI_File_seek_shared(fh, 0, MPI_SEEK_SET); if (err) { errs++; MTestPrintError(err); } err = MPI_File_set_info(fh, infoin); if (err) { errs++; MTestPrintError(err); } MPI_Info_free(&infoin); buf[0] = -1; err = MPI_File_read_ordered(fh, buf, 1, MPI_INT, &status); if (err) { errs++; MTestPrintError(err); } MPI_Get_count(&status, MPI_INT, &count); if (count != 1) { errs++; printf("Expected to read one int, read %d\n", count); } if (buf[0] != rank) { errs++; printf("Did not read expected value (%d)\n", buf[0]); } err = MPI_File_get_info(fh, &infoout); if (err) { errs++; MTestPrintError(err); } MPI_Info_get(infoout, (char *) "access_style", 1024, value, &flag); /* Note that an implementation is allowed to ignore the set_info, * so we'll accept either the original or the updated version */ if (!flag) { ; /* * errs++; * printf("Access style hint not saved\n"); */ } else { if (strcmp(value, "read_once") != 0 && strcmp(value, "write_once,random") != 0) { errs++; printf("value for access_style unexpected; is %s\n", value); } } MPI_Info_free(&infoout); err = MPI_File_close(&fh); if (err) { errs++; MTestPrintError(err); } MPI_Barrier(comm); MPI_Comm_rank(comm, &rank); if (rank == 0) { err = MPI_File_delete((char *) "testfile", MPI_INFO_NULL); if (err) { errs++; MTestPrintError(err); } } MTest_Finalize(errs); return MTestReturnValue(errs); }