#
# (C) 2004 by Argonne National Laboratory.
# See COPYRIGHT in top-level directory.
#
# Definitions for various MPI I/O Read/write tests
# If we want a separate step to check the file as written different
# from the read step, insert it here.
<checkfile>
</checkfile>
#
# If the open fails, jump to 111
<openfile>
call mpi_file_open( comm, filename, MPI_MODE_RDWR + MPI_MODE_CREATE, MPI_INFO_NULL, fh, ierr )
<checkErr/>
if (ierr .ne. MPI_SUCCESS) then
goto 111
endif
</openfile>
<closefile>
call mpi_file_close( fh, ierr )
<checkErr/>
</closefile>
<deletefile>
call mpi_barrier( comm, ierr )
call mpi_comm_rank( comm, r, ierr )
if (r .eq. 0) then
call mpi_file_delete( filename, MPI_INFO_NULL, ierr )
<checkErr/>
endif
call mpi_barrier( comm, ierr )
</deletefile>
# Common code to initialize the buffer for contiguous writes
<setContigBuffer>
do i=1, n
buf(i) = r*n + (k-1)*n*s + i-1
enddo
</setContigBuffer>
# This is for double buffered tests
<setContigBuffer2>
do i=1, n
buf2(i) = r*n + (k)*n*s + i-1
enddo
</setContigBuffer2>
<checkContigBuffer>
do i=1, n
ans = r*n + (k-1)*n*s + i-1
if (buf(i) .ne. ans) then
errs = errs + 1
if (errs .le. 10) then
print *, r, k, ' buf(',i,') = ', buf(i), ' expected ', ans
endif
endif
enddo
</checkContigBuffer>
<clearContigBuffer>
do i=1, n
buf(i) = - (r*n + (k-1)*n*s + i)
enddo
</clearContigBuffer>
<checkContigBuffer2>
do i=1, n
if (buf2(i) .ne. r*n + (k)*n*s + i-1) then
errs = errs + 1
if (errs .le. 10) then
print *, r,k,' buf2(',i,') = ', buf2(i)
endif
endif
enddo
</checkContigBuffer2>
<clearContigBuffer2>
do i=1, n
buf2(i) = - (r*n + (k)*n*s + i)
enddo
</clearContigBuffer2>
# Common error check
<checkErr>
if (ierr .ne. MPI_SUCCESS) then
errs = errs + 1
if (errs .le. 10) then
call MTestPrintError( ierr )
endif
endif
</checkErr>
# Common error check when MPI_ERR_IN_STATUS is a possibility
# (status array is then statuses, of length nreq (one status per request)
<checkErrInStatus>
if (ierr .ne. MPI_SUCCESS) then
errs = errs + 1
if (errs .le. 10) then
call MTestPrintError( ierr )
if (ierr .eq. MPI_ERR_IN_STATUS) then
do i=1, nreq
if (statuses(MPI_ERROR,i) .ne. MPI_SUCCESS) then
print *, 'For statuses[', i, '], error is:'
call MTestPrintError( statuses(MPI_ERROR,i) )
endif
enddo
endif
endif
endif
</checkErrInStatus>
# Common offset computation, based on the block, rank, size
<findOffset>
offset = (r * n + (k - 1) * n * s) * intsize
</findOffset>
# Set the view of the file for this process; suitable for
# collective I/O and independent file I/O without seek
<setcontigview>
call mpi_type_vector( b, n, n*s, MPI_INTEGER, filetype, ierr )
call mpi_type_commit( filetype, ierr )
offset = r * n * intsize
call mpi_file_set_view( fh, offset, MPI_INTEGER, filetype, "native", MPI_INFO_NULL, ierr )
<checkErr/>
call mpi_type_free( filetype, ierr )
</setcontigview>
# Some tests require that the individual processes proceed in order.
# The following definitions initialize the src and dest, and arrange
# to pass a token using MPI_Ssend
# Prereqs: r and s contain rank and size, and src,dest are declared.
# The ring is executed b times, with index variable k
<initRing>
src = mod( r + s - 1, s )
dest = mod( r + 1, s )
if (s .eq. 1) then
src = MPI_PROC_NULL
dest = MPI_PROC_NULL
endif
if (r .eq. s-1) then
call mpi_ssend( MPI_BOTTOM, 0, MPI_INTEGER, dest, 1, comm, ierr )
endif
</initRing>
<waitRing>
call mpi_recv( MPI_BOTTOM, 0, MPI_INTEGER, src, k, comm, MPI_STATUS_IGNORE, ierr )
</waitRing>
<nextRing>
if (r .eq. s-1) then
call mpi_ssend( MPI_BOTTOM, 0, MPI_INTEGER, dest, k+1, comm, ierr )
else
call mpi_ssend( MPI_BOTTOM, 0, MPI_INTEGER, dest, k, comm, ierr )
endif
</nextRing>
<endRing>
if (r .eq. 0) then
call mpi_recv( MPI_BOTTOM, 0, MPI_INTEGER, src, b+1, comm, MPI_STATUS_IGNORE, ierr )
endif
</endRing>
#
# ----------------------------------------------------------------------------
# This test uses the individual file pointers.
# To reach the correct locations, we seek to the position
<TESTDEFN filename="writef.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b
<setContigBuffer/>
<findOffset/>
call mpi_file_seek( fh, offset, MPI_SEEK_SET, ierr )
<checkErr/>
call mpi_file_write( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b
<clearContigBuffer/>
<findOffset/>
call mpi_file_seek( fh, offset, MPI_SEEK_SET, ierr )
<checkErr/>
call mpi_file_read( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses independent I/O with thread-safe, individual file pointers
<TESTDEFN filename="writeatf.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b
<setContigBuffer/>
<findOffset/>
call mpi_file_write_at( fh, offset, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b
<clearContigBuffer/>
<findOffset/>
call mpi_file_read_at( fh, offset, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses collective I/O with thread-safe, individual file pointers
<TESTDEFN filename="writeatallf.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b
<setContigBuffer/>
<findOffset/>
call mpi_file_write_at_all( fh, offset, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b
<clearContigBuffer/>
<findOffset/>
call mpi_file_read_at_all( fh, offset, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses nonblocking collective I/O with thread-safe, individual file pointers
<TESTDEFN filename="iwriteatallf.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer request
integer buf(MAX_BUFFER), ans
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b
<setContigBuffer/>
<findOffset/>
call mpi_file_iwrite_at_all( fh, offset, buf, n, MPI_INTEGER, request, ierr )
call mpi_wait(request, status, ierr)
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b
<clearContigBuffer/>
<findOffset/>
call mpi_file_iread_at_all( fh, offset, buf, n, MPI_INTEGER, request, ierr )
call mpi_wait(request, status, ierr)
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses collective I/O with thread-safe, individual file pointers
<TESTDEFN filename="writeatallbef.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b
<setContigBuffer/>
<findOffset/>
call mpi_file_write_at_all_begin( fh, offset, buf, n, MPI_INTEGER, ierr )
<checkErr/>
call mpi_file_write_at_all_end( fh, buf, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b
<clearContigBuffer/>
<findOffset/>
call mpi_file_read_at_all_begin( fh, offset, buf, n, MPI_INTEGER, ierr )
<checkErr/>
call mpi_file_read_at_all_end( fh, buf, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses nonblocking I/O with independent file pointers
<TESTDEFN filename="iwriteatf.f">
<writefiledecl>
integer statuses(MPI_STATUS_SIZE,2)
integer buf(MAX_BUFFER), buf2(MAX_BUFFER), ans
integer req(2), nreq
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b ,2
<setContigBuffer/>
<findOffset/>
nreq = 1
call mpi_file_iwrite_at( fh, offset, buf, n, MPI_INTEGER, req(1), ierr )
<checkErr/>
if (k+1 .le. b) then
offset = offset + (s * n) * intsize
<setContigBuffer2/>
nreq = nreq + 1
call mpi_file_iwrite_at( fh, offset, buf2, n, MPI_INTEGER, req(2), ierr )
<checkErr/>
endif
call mpi_waitall( nreq, req, statuses, ierr )
<checkErrInStatus/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b ,2
<clearContigBuffer/>
<findOffset/>
nreq = 1
call mpi_file_iread_at( fh, offset, buf, n, MPI_INTEGER, req(1), ierr )
<checkErr/>
if (k+1 .le. b) then
offset = offset + (s * n) * intsize
<clearContigBuffer2/>
nreq = nreq + 1
call mpi_file_iread_at( fh, offset, buf2, n, MPI_INTEGER, req(2), ierr )
<checkErr/>
endif
call mpi_waitall( nreq, req, statuses, ierr )
<checkErrInStatus/>
<checkContigBuffer/>
if (nreq .eq. 2) then
<checkContigBuffer2/>
endif
enddo
</readfile>
</TESTDEFN>
# This test uses nonblocking I/O with independent file pointers and explicit
# seeks
<TESTDEFN filename="iwritef.f">
<writefiledecl>
integer statuses(MPI_STATUS_SIZE,2)
integer buf(MAX_BUFFER), buf2(MAX_BUFFER), ans
integer req(2), nreq
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b ,2
<setContigBuffer/>
<findOffset/>
nreq = 1
call mpi_file_seek( fh, offset, MPI_SEEK_SET, ierr )
<checkErr/>
call mpi_file_iwrite( fh, buf, n, MPI_INTEGER, req(1), ierr )
<checkErr/>
if (k+1 .le. b) then
offset = offset + (s * n) * intsize
call mpi_file_seek( fh, offset, MPI_SEEK_SET, ierr )
<checkErr/>
<setContigBuffer2/>
nreq = nreq + 1
call mpi_file_iwrite( fh, buf2, n, MPI_INTEGER, req(2), ierr )
<checkErr/>
endif
call mpi_waitall( nreq, req, statuses, ierr )
<checkErrInStatus/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b ,2
<clearContigBuffer/>
<findOffset/>
nreq = 1
call mpi_file_seek( fh, offset, MPI_SEEK_SET, ierr )
<checkErr/>
call mpi_file_iread( fh, buf, n, MPI_INTEGER, req(1), ierr )
<checkErr/>
if (k+1 .le. b) then
offset = offset + (s * n) * intsize
call mpi_file_seek( fh, offset, MPI_SEEK_SET, ierr )
<clearContigBuffer2/>
nreq = nreq + 1
call mpi_file_iread( fh, buf2, n, MPI_INTEGER, req(2), ierr )
<checkErr/>
endif
call mpi_waitall( nreq, req, statuses, ierr )
<checkErrInStatus/>
<checkContigBuffer/>
if (nreq .eq. 2) then
<checkContigBuffer2/>
endif
enddo
</readfile>
</TESTDEFN>
# This test uses nonblocking I/O with shared file pointers
<TESTDEFN filename="iwriteshf.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
integer src, dest
integer req
</writefiledecl>
<writefile>
<initRing/>
do k=1, b
<waitRing/>
<setContigBuffer/>
call mpi_file_iwrite_shared( fh, buf, n, MPI_INTEGER, req, ierr )
<checkErr/>
call mpi_wait( req, status, ierr )
<nextRing/>
enddo
<endRing/>
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
<initRing/>
do k=1, b
<waitRing/>
<clearContigBuffer/>
call mpi_file_iread_shared( fh, buf, n, MPI_INTEGER, req, ierr )
<checkErr/>
call mpi_wait( req, status, ierr )
<checkContigBuffer/>
<nextRing/>
enddo
<endRing/>
</readfile>
</TESTDEFN>
# This test uses collective I/O
<TESTDEFN filename="writeallf.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
integer filetype
include 'iooffset.h'
</writefiledecl>
<writefile>
<setcontigview/>
do k=1, b
<setContigBuffer/>
call mpi_file_write_all( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
<setcontigview/>
do k=1, b
<clearContigBuffer/>
call mpi_file_read_all( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses split collective I/O
<TESTDEFN filename="writeallbef.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
integer filetype
include 'iooffset.h'
</writefiledecl>
<writefile>
<setcontigview/>
do k=1, b
<setContigBuffer/>
call mpi_file_write_all_begin( fh, buf, n, MPI_INTEGER, ierr )
<checkErr/>
call mpi_file_write_all_end( fh, buf, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
<setcontigview/>
do k=1, b
<clearContigBuffer/>
call mpi_file_read_all_begin( fh, buf, n, MPI_INTEGER, ierr )
<checkErr/>
call mpi_file_read_all_end( fh, buf, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses the shared file pointers collectively.
<TESTDEFN filename="writeordf.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b
<setContigBuffer/>
call mpi_file_write_ordered( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b
<clearContigBuffer/>
call mpi_file_read_ordered( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses the shared file pointers with split collectives.
<TESTDEFN filename="writeordbef.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
include 'iooffset.h'
</writefiledecl>
<writefile>
do k=1, b
<setContigBuffer/>
call mpi_file_write_ordered_begin( fh, buf, n, MPI_INTEGER, ierr )
<checkErr/>
call mpi_file_write_ordered_end( fh, buf, status, ierr )
<checkErr/>
enddo
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
do k=1, b
<clearContigBuffer/>
call mpi_file_read_ordered_begin( fh, buf, n, MPI_INTEGER, ierr )
<checkErr/>
call mpi_file_read_ordered_end( fh, buf, status, ierr )
<checkErr/>
<checkContigBuffer/>
enddo
</readfile>
</TESTDEFN>
# This test uses the shared file pointers independently.
# We pass a token to control the oredering
<TESTDEFN filename="writeshf.f">
<writefiledecl>
integer status(MPI_STATUS_SIZE)
integer buf(MAX_BUFFER), ans
integer src, dest
</writefiledecl>
<writefile>
<initRing/>
do k=1, b
<waitRing/>
<setContigBuffer/>
call mpi_file_write_shared( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
<nextRing/>
enddo
<endRing/>
</writefile>
# No extra declarations are needed for the read step
<readfiledecl>
</readfiledecl>
<readfile>
<initRing/>
do k=1, b
<waitRing/>
<clearContigBuffer/>
call mpi_file_read_shared( fh, buf, n, MPI_INTEGER, status, ierr )
<checkErr/>
<checkContigBuffer/>
<nextRing/>
enddo
<endRing/>
</readfile>
</TESTDEFN>