MPI Test Suite Test Descriptions

Each of the collapsible regions below corresponds to the test groups displayed in the MPI Test Suite Results table. Click the name of a test group to see the individual tests which comprise it. Some tests appear in multiple groups.
Back to Results Table

Topology

The Network Topology tests are designed to examine the operation of specific communication patterns such as Cartesian and Graph topology.

MPI_Cart_create() test 1

This test creates a cartesian mesh and tests for errors.

MPI_Cartdim_get() test

Check that the MPI implementation properly handles zero-dimensional Cartesian communicators - the original standard implies that these should be consistent with higher dimensional topologies and therefore should work with any MPI implementation. MPI 2.1 made this requirement explicit.

MPI_Cart_map() test 2

This test creates a cartesian map and tests for errrors.

MPI_Cart_shift() test

This test exercises MPI_Cart_shift().

MPI_Cart_sub() test

This test exercises MPI_Cart_sub().

MPI_Dims_create() test

This test uses multiple varies for the arguments of MPI_Dims_create() and tests whether the product of ndims (number of dimensions) and the returned dimensions are equal to nnodes (number of nodes) thereby determining if the decomposition is correct. The test also checks for compliance with the MPI_- standard section 6.5 regarding decomposition with increasing dimensions. The test considers dimensions 2-4.

MPI_Dims_create() test

This test is similar to topo/dims1 but only exercises dimensions 2 and 4 including test cases whether all all dimensions are specified.

MPI_Dims_create() test

This test is similar to topo/dims1 but only considers special cases using dimensions 3 and 4.

MPI_Dist_graph_create test

This test excercises MPI_Dist_graph_create() and MPI_Dist_graph_adjacent().

MPI_Graph_create() test 1

Create a communicator with a graph that contains null edges and one that contains duplicate edges.

MPI_Graph_create() test 2

Create a communicator with a graph that contains no processes.

MPI_Graph_map() test

Simple test of MPI_Graph_map().

MPI_Topo_test datatype test

Check that topo test returns the correct type, including MPI_UNDEFINED.

MPI_Topo_test dup test

Create a cartesian topology, get its characteristics, then dup it and check that the new communicator has the same properties.

MPI_Topo_test() test

Specify a distributed graph of a bidirectional ring of the MPI_COMM_WORLD communicator. Thus each node in the graph has a left and right neighbor.

Neighborhood routines test

A basic test for the 10 (5 patterns x {blocking,non-blocking}) MPI-3 neighborhood collective routines.

Basic Functionality

This group features tests that emphasize basic MPI functionality such as initializing MPI and retrieving its rank.

Basic Send/Recv Test

This test sends the length of a message, followed by the message body.

Const test

This test is designed to test the new MPI-3.0 const cast applied to a "const *" buffer pointer.

Elapsed walltime test

This test measures how accuractly MPI can measure 1 second.

Generalized request test

Simple test of generalized requests.This simple code allows us to check that requests can be created, tested, and waited on in the case where the request is complete before the wait is called.

Init argument test

In MPI-1.1, it is explicitly stated that an implementation is allowed to require that the arguments argc and argv passed by an application to MPI_Init in C be the same arguments passed into the application as the arguments to main. In MPI-2 implementations are not allowed to impose this requirement. Conforming implementations of MPI allow applications to pass NULL for both the argc and argv arguments of MPI_Init(). This test prints the result of the error status of MPI_Init(). If the test completes without error, it reports 'No errors.'

Input queuing test

Test of a large number of messages of MPI datatype messages with no preposted receive so that an MPI implementation may have to queue up messages on the sending side.

Intracomm communicator test

This program calls MPI_Reduce with all Intracomm Communicators.

MPI_ANY_{SOURCE,TAG} test

This test uses MPI_ANY_SOURCE and MPI_ANY_TAG on an MPI_Irecv().

MPI_Abort() return exit test

This program calls MPI_Abort and confirms that the exit status in the call is returned to the envoking environment.

MPI Attribues test

This is a test of creating and inserting attribues in different orders to ensure that the list management code handles all cases.

MPI_BOTTOM test

This test makes use of MPI_BOTTOM in communication.

MPI_Bsend() alignment test

Test bsend with a buffer with alignment between 1 and 7 bytes.

MPI_Bsend() detach test

Test the handling of MPI_Bsend() operations when a detach occurs before the bsend data has been sent.

MPI_Bsend() ordered test

Test bsend message handling where different messages are received in different orders.

MPI_Bsend() test 1

This is a simple program that tests MPI_Bsend().

MPI_Bsend() test 2

This is a simple program that tests bsend.

MPI_Bsend() test 3

This is a simple program that tests bsend.

MPI_Bsend() test 4

This is a simple program that tests bsend.

MPI_Bsend() test 5

This is a simple program that tests bsend.

MPI_Cancel() test 1

Test of various send cancel calls.

MPI_Cancel() test 2

Test of send cancel (failure) calls.

MPI_Finalized() test

This tests when MPI_Finalized() will work correctly if MPI_INit() was not called. This behaviour is not defined by the MPI standard, therefore this test is not garanteed.

MPI_Get_library_version test

MPI-3.0 Test returns MPI library version.

MPI_Get_version() test

This MPI_3.0 test prints the MPI version. If running a version of MPI < 3.0, it simply prints "No Errors".

MPI_Irecv() cancelled test

This test attempts to cancel a receive request.

MPI_{Is,Query}_thread() test

This test examines the MPI_Is_thread() and MPI_Query_thread() call after being initilized using MPI_Init_thread().

MPI_Isend()/MPI_Request test

Test MPI_Ibsend and MPI_Request_free.

MPI_Isend() root test 1

This is a simple test case of sending a non-blocking message to the root process.

MPI_Isend() root test 2

This is a simple test case of sending a non-blocking message to the root process.

MPI_Isend() root test 3

This test case sends a non-blocking synchonous send to the root process, cancels it, then attempts to read it.

MPI_Mprobe() test

This test MPI_Mprobe() to get the status of a pending receive, then calls MPI_Mrecv() with that status value.

MPI_Probe() test 1

This program verifies that MPI_Probe() is operating properly in the face of unexpected messages arriving after MPI_Probe() has been called. This program may hang if MPI_Probe() does not return when the message finally arrives.

MPI_Probe() test 2

This program checks that MPI_Iprobe and MPI_Probe correctly handle a source of MPI_PROC_NULL.

MPI_Request_get_status() test

Test MPI_Request_get_status(). The test also checks that MPI_REQUEST_NULL and MPI_STATUS_IGNORE work as arguments as required beginning with MPI-2.2.

MPI_Request() test 3

This test issues many non-blocking receives followed by many blocking MPI_Send() calls, then issues an MPI_Wait() on all pending receives. When complete, the program prints the amount of time transpired using MPI_Wtime().

MPI_{Send,Receive} test 1

This is a simple test of Send-Recv.

MPI_{Send,Receive} test 2

This is a simple test of various Send-Recv.

MPI_{Send,Receive} test 3

Head to head send-recv to test backoff in device when large messages are being transferred.

MPI_Send() intercomm test

Simple test of intercommunicator send and receive.

MPI_Status large count test

This test manipulates an MPI status object using MPI_Status_set_elements_x() with a large count value.

MPI_Test() pt2pt test

This test program checks that the point-to-point completion routines can be applied to an inactive persistent request, as required by the MPI-1 standard. See section 3.7.3, It is allowed to call MPI TEST with a null or inactive request argument. In such a case the operation returns with flag = true and empty status.

MPI_Waitany() test 1

Rhis is a simple test of MPI_Waitany().

MPI_Waitany() test 2

This program checks that the various MPI_Test and MPI_Wait routines allow both null requests and in the multiple completion cases, empty lists of requests.

MPI_Wtime() test

This program tests the ability of mpiexec to timeout a process after no more than 3 minutes. By default, it will run for 30 secs.

Many send/cancel test 1

Test of various send cancel calls.

Many send/cancel test 2

Test of various receive cancel calls, with multiple requests to cancel.

Message patterns test

This test sends/receives a number of messages in different patterns to make sure that all messages are received in the order they are sent. Two processes are used in the test.

Ping flood test

This test sends a large number of messages in a loop in the source processes, and receives a large number of messages in a loop in the destination process.

Preposted receive test

Test of sending to self (root) (with a preposted receive).

Race condition test

Run this test with 8 processes. This test was submitted as a result of problems seen with the ch3:shm device on a Solaris system. The symptom is that the test hangs; this is due to losing a message, probably due to a race condition in a message-queue update.

Send/Recv test 1

This is a basic test of the send/receive with a barrier using MPI_Send() and MPI_Recv().

Send/Recv test 2

This test uses MPI_Sendrecv() sent from and to rank=0.

Simple thread test 1

The test initializes a thread, then calls MPI_Finalize() and prints "No errors".

Simple thread test 2

The test here is a simple one that Finalize exits, so the only action is to write no error.

Communicator Testing

This group features tests that emphasize MPI calls that create, manipulate, and delete MPI Communicators.

Comm_create_group test 1

This test is create/frees groups using different schemes.

Comm_create_group test 2

This routine creates/frees groups using different schemes.

Comm_create_group test 3

This routine creates/frees groups using different schemes.

Comm_create_group test 4

This routine creates/frees groups using different schemes.

Comm_create_group test 5

This routine creates/frees groups using different schemes.

Comm_create_group test 7

This routine creates/frees groups using even-odd pairs.

Comm_create_group test 8

This routine create/frees groups using modulus 4 random numbers.

Comm_create group tests

Get the group of an intercommunicator.The following illustrates the use of the routines to run through a selection of communicators and datatypes.

Comm_create() test

This program tests that MPI_Comm_create applies to intercommunicators. This is an extension added in MPI-2.

Comm_creation_group test 6

This routine creates/frees groups using different schemes.

Comm creation test

Check that Communicators can be created from various subsets of the processes in the communicator.

Comm_{dup,free} test

This program tests the allocation (and deallocation) of contexts.

Comm_dup test 1

This test exercises MPI_Comm_dup().

Comm_dup test 2

Check that there are separate contexts. We do this by setting up non-blocking received on both communicators, and then sending to them. If the contexts are different, tests on the unsatisfied communicator should indicate no available message.

Comm_{get,set}_name test

Test MPI_Comm_get_name().

Comm_idup test 1

This test exercises MPI_Comm_idup().

Comm_idup test 2

Test plan: Make rank 0 wait in a blocking recv until all other processes have posted their MPI_Comm_idup ops, then post last. Should ensure that idup doesn't block on the non-zero ranks, otherwise we'll get a deadlock.

Comm_idup test 3

Test plan: Make rank 0 wait in a blocking recv until all other processes have posted their MPI_Comm_idup ops, then post last. Should ensure that idup doesn't block on the non-zero ranks, otherwise we'll get a deadlock.

Comm_idup test 4

Test creating multiple communicators with MPI_Comm_idup.

Comm_idup test 5

Each pair dups the communicator such that the dups are overlapping. If this were done with MPI_Comm_dup, this should deadlock.

Comm_split Test 1

This tests whether MPI_Comm_split() applies to intercommunicators which is an extension of MPI-2.

Comm_split test 2

This test ensures that MPI_Comm_split breaks ties in key values by using the original rank in the input communicator. This typically corresponds to the difference between using a stable sort or using an unstable sort. It checks all sizes from 1..comm_size(world)-1, so this test does not need to be run multiple times at process counts from a higher-level test driver.

Comm_split test 3

Test comm split.

Comm_split test 4

This test only checks that the MPI_Comm_split_type routine doesn't fail. It does not check for correct behavior.

Comm_with_info() test 1

This test exercises MPI_Comm_dup_with_info().

Comm_with_info test 2

This test exercises MPI_Comm_dup_with_info().

Comm_with_info test 3

This test exercises MPI_Comm_dup_with_info().

Context split test

This check is intended to fail if there is a leak of context ids. Because this is trying to exhaust the number of context ids, it needs to run for a longer time than many tests. The for loop uses 10000 iterations, which is adequate for MPICH (with only about 1k context ids available).

Easy thread test 1

This is a simple test of threads in MPI.

Easy thread test 2

This is a simple test of threads in MPI

Intercomm_create test 1

A simple test of the intercomm create routine, with a communication test.

Intercomm_create test 2

Regression test based on test code from N. Radclif@Cray.

Intercomm_merge test

Test intercomm merge, including the choice of the high value.

Intercomm_probe test

Test MPI_Probe() with an intercomm communicator.

MPI_Info_create() test

Comm_{set,get}_info test

Multiple threads test 1

This test creates communications concurrently in different threads.

Multiple threads test 2

This test creates communications concurrently in different threads.

Multiple threads test 3

This test repeatedly duplicates and frees communicators with multiple threads concurrently to stress the multithreaded aspects of the context ID allocation code. Thanks to IBM for providing the original version of this test.

Thread Group creation test

Every thread paticipates in a distinct MPI_Comm_create group, distinguished by its thread-id (used as the tag). Threads on even ranks join an even comm and threads on odd ranks join the odd comm.

Threaded group test

In this test a number of threads are created with a distinct MPI communicator (or comm) group distringuished by its thread-id (used as a tag). Threads on even ranks join an even comm and threads on odd ranks join the odd comm.

Error Processing

This group features tests of MPI error processing.

Error Handling test

Reports the default action taken on an error. It also reports if error handling can be changed to "returns", and if so, if this functions properly.

MPI_Add_error_class() test

Create NCLASSES new classes, each with 5 codes (160 total).

MPI_Comm_errhandler() test

Test comm_{set,call}_errhandle.

MPI_Error_string() test 1

Test that prints out MPI error codes from 0-53.

MPI_Error_string() test 2

Simple test where an MPI error class is created, and an error string introduced for that string.

MPI FILE I/O test

This test exercises MPI I/O and MPI error handling techniques.

User error handling test 1

Ensure that setting a user-defined error handler on predefined communicators does not cause a problem at finalize time. Regressiontest for ticket #1591.

User error handling test 2

Ensure that setting a user-defined error handler on predefined communicators does not cause a problem at finalize time. Regression test for ticket #1591.

UTK Test Suite

This group features the test suite developed at the University of Tennesss Knoxville for MPI-2.2 and earlier specifications. Though techically not a functional group, it was retained to allow comparison with the previous benchmark suite.

Alloc_mem test

Checks if MPI_Alloc_mem() is supported. If test passes, then the following is reported "MPI_Alloc_mem is supported." else, "MPI_Alloc_mem NOT supported" is reported.

Assignment constants test

This test was added to the UTK suite as a partial replacement for the "utk/constants" test for Named Constants supported in MPI-1.0 and higher. The test is a perl script that constructs a small seperate main program in either C or Fortran for each constant. The constants for this test are used to assign a value to a const integer type in C and an integer type in Fortran. This test is the de facto test for any constant recognized by the compiler.

NOTE: The constants used in this test are tested against both C and Fortran compilers. Some of the constants are optional and may not be supported by the MPI implementation. Failure to verify these constants does not necessarily constitute failure of the MPI implementation to satisfy the MPI specifications.

C/Fortran interoperability test

Checks if the C-Fortran (F77) interoperability functions are supported using MPI-2.2 specification.

Communicator attributes test

Returns all communicator attributes that are not supported. The test is run as a single process MPI job.

Compiletime constants test

The MPI-3.0 specifications require that some named constants be known at compiletime. The report includes a record for each constant of this class in the form "X MPI_CONSTANT is [not] verified by METHOD" where X is either 'c' for the C compiler, or 'F' for the FORTRAN 77 compiler. For a C langauge compile, the constant is used as a case label in a switch statement. For a FORTRAN language compile, the constant is assigned to a PARAMETER. The report sumarizes with the number of constants for each compiler that was successfully verified.

Datatypes test

This test was added to the UTK suite as a replacement for the "utk/datatypes" test for constants in MPI-1.0 and higher. The test is a constructs small seperate main programs in either C, FORTRAN77, or C++ for each datatype. If a test fails to compile, the datatype is reported as "not verified: (compilation)". If the test executes successfully, the report includes the size of the datatype (in bytes) and includes the words "is verified."

Deprecated routines test

Checks all MPI deprecated routines as of MPI-2.2.

Dynamic process management test

Checks if the dynamic process management routines through MPI-2.2 are defined. If the test passes, then "No errors" is reported.

Error Handling test

Reports the default action taken on an error. It also reports if error handling can be changed to "returns", and if so, if this functions properly.

Errorcodes test

The MPI-3.0 specifications require that the same constants be available for the C language and FORTRAN. The report includes a record for each errorcode of the form "X MPI_ERRCODE is [not] verified" where X is either 'c' for the C compiler, or 'F' for the FORTRAN 77 compiler. The report sumarizes with the number of errorcodes for each compiler that were successfully verified.

Extended collectives test

Checks if "extended collectives" are supported. If the test fails to compile, then "extended collectives" are not supported. If the test compiles, then a 4-process MPI job is executed. If the job aborts, then "Extended collectives NOT supported" is reported. If the job executes and the correct value is returned, then "Extended collectives ARE supported" is reported.

I/O modes test

Checks if all MPI predefined I/O modes are supported. If test passes, "No errors" is reported. Any modes not supported are indicated individually as not being supported.

I/O verification test 1

Reports if MPI I/O is supported. If the MPI-I/O routines terminate normally and provide correct results, MPI-I/O reportes "No errors", otherwise error messages are generated.

I/O verification test 2

This test is used to verify that the file created by io_test,c holds the correct values. If the test fails, the problem is reported. If all tests pass successfully it is reported that MPI-I/O is supported.

Init argument test

In MPI-1.1, it is explicitly stated that an implementation is allowed to require that the arguments argc and argv passed by an application to MPI_Init in C be the same arguments passed into the application as the arguments to main. In MPI-2 implementations are not allowed to impose this requirement. Conforming implementations of MPI allow applications to pass NULL for both the argc and argv arguments of MPI_Init(). This test prints the result of the error status of MPI_Init(). If the test completes without error, it reports 'No errors.'

MPI-2 Routines test 2

This test simply checks all MPI-2 routines that replaced some MPI-1 routines. Since these routines were added to avoid ambiquity with MPI-2 functionality, they do not add functionality to the test suite.

MPI-2 routines test 1

Checks all MPI-2.2 routines that replaced deprecated routines. If the test passes, then "No errors" is reported, otherwise, specific errors are reported."

Master/slave test

This test running as a single MPI process spawns four slave processes using MPI_Comm_spawn(). The master process sends and receives a message from each slave. If the test completes, it will report 'No errors.', otherwise specific error messages are listed.

One-sided communication test

Checks MPI-2.2 one-sided communication modes reporting those that are not defined. If the test compiles, then "No errors" is reported, else, all undefined modes are reported as "not defined."

One-sided fences test

Test Verifies that one-sided communication with active target synchronization with fences functions properly. If all operations succeed, one-sided communication with active target synchronization with fences is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with active target synchronization with fences is reported as NOT supported.

One-sided passive test

Verifies one-sided-communication with passive target synchronization functions properly. If all operations succeed, one-sided-communication with passive target synchronization is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with passive target synchronization with fences is reported as NOT supported.

One-sided post test

Verifies one-sided-communication with active target synchronization with post/start/complete/wait functions properly. If all operations succeed, one-sided communication with active target synchronization with post/start/complete/wait is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with active target synchronization with post/start/complete/wait is reported as NOT supported.

One-sided routines test

Reports if one-sided communication routines are defined. If this test compiles, one-sided communication is reported as defined, otherwise "not supported".

Thread support test

Reports the level of thread support provided. This is either MPI_THREAD_SINGLE, MPI_THREAD_FUNNELED, MPI_THREAD_SERIALIZED, or MPI_THREAD_MULTIPLE.

Group Communicator

This group features tests of MPI communicator group calls.

MPI_Group_Translate_ranks() test

Measure and compare the relative performance of MPI_Group_translate_ranks with small and large group2 sizes but a constant number of ranks. This serves as a performance sanity check for the Scalasca use case where we translate to MPI_COMM_WORLD ranks. The performance should only depend on the number of ranks passed, not the size of either group (especially group2). This test is probably only meaningful for large-ish process counts.

MPI_Group_excl() test

This is a test of MPI_Group_excl().

MPI_Group_incl() test 1

This is a simple test of creating a group array.

MPI_Group_incl() test 2

This is a test to determine if an empty group can be created.

MPI_Group irregular test

This is a test comparing small groups against larger groups, and use groups with irregular members (to bypass optimizations in group_translate_ranks for simple groups).

MPI_Group_translate_ranks test

This is a test of MPI_Group_translate_ranks().

Win_get_group test

This is a simple test of MPI_Win_get_group().

Parallel Input/Output

This group features tests that involve MPI parallel input/output operations.

Asynchronous IO test

Test contig asynchronous I/O. Each process writes to separate files and reads them back. The file name is taken as a command-line argument, and the process rank is appended to it.

Asynchronous IO test

Test asynchronous I/O with multiple completion. Each process writes to separate files and reads them back.

I/O modes test

Checks if all MPI predefined I/O modes are supported. If test passes, "No errors" is reported. Any modes not supported are indicated individually as not being supported.

I/O verification test 1

Reports if MPI I/O is supported. If the MPI-I/O routines terminate normally and provide correct results, MPI-I/O reportes "No errors", otherwise error messages are generated.

I/O verification test 2

This test is used to verify that the file created by io_test,c holds the correct values. If the test fails, the problem is reported. If all tests pass successfully it is reported that MPI-I/O is supported.

MPI FILE I/O test

This test exercises MPI I/O and MPI error handling techniques.

MPI_File_get_type_extent test

Test file_get_extent.

MPI_File_set_view() test

Test set_view with DISPLACEMENT_CURRENT. This test reads a header then sets the view to every "size" int, using set view and current displacement. The file is first written using a combination of collective and ordered writes.

MPI_File_write_ordered test 1

Test reading and writing ordered output.

MPI_File_write_ordered test 2

Test reading and writing data with zero length. The test then looks for errors in the MPI IO routines and reports any that were found, otherwise "No errors" is reported.

MPI_Info_set() test

Test file_set_view. Access style is explicitly described as modifiable. Values include read_once, read_mostly, write_once, write_mostly, random.

MPI_Type_create_resized test

Test file views with MPI_Type_create_resized.

MPI_Type_create_resized test

Test file views with MPI_Type_create_resized.

Non-blocking I/O test

Tests noncontiguous reads/writes using non-blocking I/O.

Datatypes

This group features tests that involve named MPI and user defined datatypes.

Blockindexed contiguous test 1

This test converts a block indexed datatype to a contiguous datatype.

Blockindexed contiguous test 2

This tests the behaviour with a zero-count blockindexed datatype.

C++ datatype test

This test checks for the existence of four new C++ named predefined datatypes that should be accessible from C and Fortran.

Contiguous bounds test

The default behavior of the test is be to indicate the cause of any errors.

Datatype inclusive test

Sample some datatypes. See 8.4, "Naming Objects" in MPI-2. The default name is the same as the datatype name.

Datatype match test

Test of type_match_size. Check the most likely cases. Note that it is an error to free the type returned by MPI_Type_match_size. Also note that it is an error to request a size not supported by the compiler, so Type_match_size should generate an error in that case.

Datatype reference count test

Test to check if freed datatypes have reference count semantics. The idea here is to create a simple but non-contiguous datatype, perform an irecv with it, free it, and then create many new datatypes. If the datatype was freed and the space was reused, this test may detect an error.

Datatypes test 1

Check for optional datatypes such as LONG_DOUBLE_INT.

Datatypes test 2

This program is derived from one in the MPICH-1 test suite. It tests a wide variety of basic and derived datatypes.

Datatypes test 3

This program is derived from one in the MPICH-1 test suite. This test sends and receives EVERYTHING from MPI_BOTTOM, by putting the data into a structure.

Datatypes test

This test was added to the UTK suite as a replacement for the "utk/datatypes" test for constants in MPI-1.0 and higher. The test is a constructs small seperate main programs in either C, FORTRAN77, or C++ for each datatype. If a test fails to compile, the datatype is reported as "not verified: (compilation)". If the test executes successfully, the report includes the size of the datatype (in bytes) and includes the words "is verified."

Datatype structs test

This test was motivated by the failure of an example program for RMA involving simple operations on a struct that included a struct. The observed failure was a SEGV in the MPI_Get.

Datatype test

This test creates a valid datatype, commits and frees the datatype, then repeats the process for a second datatype of the same size.

Derived HDF5 test

This test simulates a HDF5 structure type encountered by the HDF5 library. The test is run using 1 processor (submitted by Rob Latham robl@mcs.anl.gov.

Get_address test

This routine shows how math can be used on MPI addresses.

Get_elements Pair test

Send a { double, int, double} tuple and receive as a pair of MPI_DOUBLE_INTs. this should (a) be valid, and (b) result in an element count of 3.

Get_elements test

We use a contig of a struct in order to satisfy two properties: (A) a type that contains more than one element type (the struct portion) (B) a type that has an odd number of ints in its "type contents" (1 in this case). This triggers a specific bug in some versions of MPICH.

Get_elements test

Receive partial datatypes and check that MPI_Getelements gives the correct version.

LONG_DOUBLE size test

This test ensures that simplistic build logic/configuration did not result in a defined, yet incorrectly sized, MPI predefined datatype for long double and long double Complex. Based on a test suggested by Jim Hoekstra @ Iowa State University. The test also considers other datatypes that are optional in the MPI-3 specification.

Large count test

This test checks for large count functionality ("MPI_Count") mandated by MPI-3, as well as behavior of corresponding pre-MPI-3 interfaces that have better defined behavior when an "int" quantity would overflow.

MPI_Type_struct test 1

This is a very simple where a MPI_Type-struct() datatype is created and transfered to a second processor where the size of the structure is confirmed.

MPI_Type_struct test 2

Tests behavior with an empty struct type.

MPI datatype test

Tests behavior with a zero-count struct of builtins.

Noncontiguous datatypes test

This test uses a structure datatype that describes data that is contiguous, but is is manipulated as if it is noncontiguous. The test is designed to expose flaws in MPI memory management should they exist.

Pack, Unpack test 1

This test confirms that packed structures unpack properly.

Pack,Unpack test 2

This test confirms that packed structures unpack properly.

Pack, Unpack test

This test confirms that sliced array pack and unpack properly.

Pack,Unpack test

This test confirms that an MPI packed matrix can be unpacked correctly by the MPI infrastructure.

Pack_external_size test

Tests functionality of MPI_Type_get_envelope() and MPI_Type_get_contents() on a MPI_FLOAT. Returns the number of errors encountered.

Pack test

This test users MPI_Pack() on a communication buffer, then call MPU_Unpack() to confirm that the unpacked data matches the original. This routine performs all work within a simple processor.

Pack test

Tests functionality of MPI_Type_get_envelope() and MPI_Type_get_contents() on a MPI_FLOAT. Returns the number of errors encountered.

Simple datatype test 1

This test checks to see if we can create a simple datatype made from many contiguous copies of a single struct. The struct is built with monotone decreasing displacements to avoid any struct->config optimizations.

Simple datatype test 2

Tests behaviour with a zero count contig.

Type_commit test

Tests that verifies that the MPI_Type_commit succeeds.

Type_commit test

This test builds datatypes using various components and confirms that MPI_Type_commit() succeeded.

Type_contiguous test

This test checks that MPI can handle large datatypes.

Type_create_darray packing test

Performs a sequence of tests building darrays with single-element blocks, running through all the various positions that the element might come from. Returns the number of errors encountered.

Type_create_darray test

Cyclic check of a custom struct darray.

Type_create_darray test

The default behavior of the test is be to indicate the cause of any errors.

Type_create_hindexed_block test 1

Tests behavior with a hindexed_block that can be converted to a contig easily. This is specifically for coverage. Returns the number of errors encountered.

Type_create_hindexed_block test 2

This test is a simple check of MPI_Type_create_hindexed_block() using MPI_Type_get_envelope() and MPI_Type_get_contents().

Type_create_resized() test 1

Test of MPI datatype resized with non-zero lower bound.

Type_create_resized() test 2

Test of MPI datatype resized with 0 lower bound.

Type_create_resized test

Tests behavior with resizing of a simple derived type.

Type_create_subarray test 1

This test creates a subarray and confirms its contents.

Type_create_subarray test 2

This test confirms that a packed sub-array can be properly unpacked.

Type_free test

This test is used to confirm that memory is properly recovered from freed datatypes. The test may be run with valgrind or similar tools, or it may be run with MPI implementation specific options. For this test it is run only with standard MPI error checking enabled.

Type_get_envelope test

This tests the functionality of MPI_Type_get_envelope() and MPI_Type_get_contents().

Type_get_extent test

This test confirms that MPI_Type_get_extent() works properly.

Type_hindexed test

Tests with an hindexed type with all zero length blocks.

Type_hvector_blklen test

Inspired by the Intel MPI_Type_hvector_blklen test. Added to include a test of a dataloop optimization that failed.

Type_hvector test

Based on code from Jeff Parker at IBM.

Type_indexed test

Tests behavior with an indexed array that can be compacted but should continue to be stored as an indexed type. Specifically for coverage. Returns the number of errors encountered.

Type_indexed test

Author: Rob Ross
Date: November 2, 2005

This test allocates 1024 indexed datatypes with 1024 distinct blocks each. It's possible that a low memory machine will run out of memory running this test. This test requires approximately 25MBytes of memory at this time.

Type_{lb,ub,extent} test

This test checks that both the upper and lower boundary of an hindexed MPI type is correct.

Type_struct() alignment test

This routine checks the alignment of a custom datatype.

Type_struct test

This test creates an MPI_Type_struct() datatype, assigns data and sends the strufcture to a second process. The second process receives the structure and conforms that the information contained in the structure agrees with the original data.

Type_vector_blklen test

This test is inspired by the Intel MPI_Type_vector_blklen test. The test fundamentally tries to deceive MPI into scrambling the data using padded struct types, and MPI_Pack() and MPI_Unpack(). The data is then checked to make sure the original data was not lost in the process. If "No errors" is reported, then the MPI functions that manipulated the data did not corrupt the test data.

Unpack() test

Test sent in by Avery Ching to report a bug in MPICH. Adding it as a regression test. Note: Unpack without a Pack is not technically correct, but should work with MPICH. This may not be supported with other MPI variants.

Zero size block test

This test creates an empty packed indexed type, and then checks that the last 40 entrines of the unpacked recv_buffer have the corresponding elements from the send buffer.

Collectives

This group features tests of utilizing MPI collectives.

Allgather test 1

This is a test of MPI_Allgather() using the MPI_IN_PLACE argument.

Allgather test 2

This test is similar to coll/allgather2, but it tests a zero byte gather operation.

Allgather test 3

Gather data from a vector to contiguous datatype. Use IN_PLACE. This is the trivial version based on the coll/allgather test with constant data sizes.

Allgather test 4

Gather data from a vector to contiguous datatype. This is the trivial version based on the allgather test (allgatherv but with constant data sizes).

Allgather test

Simple intercomm allgather test.

Allgatherv test

This test uses MPI_Allgatherv() to define a two-dimensional table.

Allgatherv test

This test if the same as coll/coll6 except that the size of the table is greater than the number of processors.

Allgatherv test

Simple intercomm allgatherv test.

Allreduce test 1

This test all possible MPI operation codes using the MPI_Allreduce() routine.

Allreduce test 2

MPI_Allreduce() Test using MPI_IN_PLACE.

Allreduce test 3

This test implements a simple matrix-matrix multiply. This is an associative but not commutative operation where matSize=matrix. The number of matrices is the count argument. The matrix is stored in C order, so that c(i,j) = cin[j+i*matSize].

Allreduce test 4

This example is similar to coll/allred3, but uses 3x3 matrices with integer-valued entries. This is an associative but not commutative operation. The number of matrices is the count argument. The matrix is stored in C order, such that

c(i,j) is cin[j+i*3]
I = identity matrix

A = (1 0 0    B = (0 1 0
     0 0 1         1 0 0
     0 1 0)        0 0 1)

The product:

I^k A I^(p-2-k-j) B I^j

is

(0 1 0
0 0 1
1 0 0)

for all values of k, p, and j.

Allreduce test 5

This test implements a simple matrix-matrix multiply. The operation is associative but not commutative where matSize=matrix. The number of matrices is the count argument. The matrix is stored in C order, so that c(i,j) is cin[j+i*matSize].

Allreduce test 6

This is a comprehensive test of MPI_Allreduce().

Allreduce test 7

This example should be run with 2 processes and tests the ability of the implementation to handle a flood of one-way messages.

Allreduce test

Simple intercomm allreduce test.

Allreduce test

User-defined operation on a long value (tests proper handling of possible pipelining in the implementation of reductions with user-defined operations).

Alltoall test 8

The test illustrates the use of MPI_Alltoall() to run through a selection of communicators and datatypes.

Alltoall test

This is a test contributed by hook@nas.nasa.gov. It is another test of MPI_Alltoall().

Alltoall test

Simple intercomm alltoall test.

Alltoall thread test

The LISTENER THREAD waits for communication from any source (including calling thread) messages which it receives that has tag REQ_TAG. Each thread enters an infinite loop that will stop only if every node in the MPI_COMM_WORLD send message containing -1.

Alltoallv test 1

This tests MPI_Alltoallv() by having each processor send data to two neighbors only, using counts of 0 for the other neighbors. This idiom is sometimes used for halo exchange operations. The test uses MPI_INT which is adequate for testing systems that use point-to-point operations.

Alltoallv test 2

This program tests MPI_Alltoallv() by having each processor send different amounts of data to each neighboring processor. The test uses only MPI_INT which is adequate for testing systems that use point-to-point operations.

Alltoallv test

This program tests MPI_Alltoallv by having processor i send different amounts of data to each processor. Because there are separate send and receive types to alltoallv, there need to be tests to rearrange data on the fly. The first test sends i items to processor i from all processors. Currently, the test uses only MPI_INT which is adequate for testing systems using point-to-point operations.

Alltoallw test

Based on a test case contributed by Michael Hofmann. This test makes sure that zero counts with non-zero-sized types on the send (recv) side match and don't cause a problem with non-zero counts and zero-sized types on the recv (send) side when using MPI_Alltoallw and MPI_Alltoallv.

Alltoallw test

This program tests MPI_Alltoallw by having processor i send different amounts of data to each processor. This is just the MPI_Alltoallv test, but with displacements in bytes rather than units of the datatype. Because there are separate send and receive types to alltoallw, there need to be tests to rearrange data on the fly.

The first test sends i items to processor i from all processors. Currently, the test uses only MPI_INT; this is adequate for testing systems that use point-to-point operations.

BAND operations test 1

Test MPI_BAND operations on optional datatypes.

BOR Operations test

Test MPI_BXOR operations on optional datatypes.

BOR operations test 2

Test MPI_BOR operations on optional datatypes.

Barrier test

This only checks that the Barrier operation accepts intercommunicators. It does not check for the semantics of a intercomm barrier (all processes in the local group can exit when (but not before) all processes in the remote group enter the barrier.

Bcast test 1

Test of broadcast with various roots and datatypes and sizes that are not powers of two.

Bcast test 2

Test of broadcast with various roots and datatypes and sizes that are not powers of two.

Bcast test 3

Various tests of MPI_Bcast() using MPI_INIT with data sizes that are in powers of two.

Bcast test 4

Tests broadcast behavior with non-zero counts but zero-sized types.

Bcast test

Simple intercomm broadcast test.

Exscan Exclusive Scan test

Test Simple test of MPI_Exscan().

Exscan exclusive scan test

The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes.

Extended collectives test

Checks if "extended collectives" are supported. If the test fails to compile, then "extended collectives" are not supported. If the test compiles, then a 4-process MPI job is executed. If the job aborts, then "Extended collectives NOT supported" is reported. If the job executes and the correct value is returned, then "Extended collectives ARE supported" is reported.

Gather test

This test uses MPI_Gather() to define a two-dimensional table.

Gather test

This test gathers data from a vector to contiguous datatype. The test does not use MPI_IN_PLACE.

Gather test

This tests gathers data from a vector to contiguous datatype. The test uses the IN_PLACE option.

Gather test

Simple intercomm gather test.

Gatherv test

This test uses MPI_Gatherv() to define a two-dimensional table. This test is similar to coll/coll2.

Gatherv test

Simple intercomm gatherv test.

Iallreduce test

This test illustrates the use of MPI_Iallreduce() and MPI_Allreduce().

Ibarrier test

This test calls MPI_Ibarrier() followed by an conditional loop containing usleep(1000) and MPI_Test(). This test hung indefinitely under some MPI implementations. Successfully completing this test indicates the error has been corrected.

Ibcast,Wait,Ibarrier test 1

This is a basic test of all 17 non-blocking collective operations specified by the MPI-3 standard. It only exercises the intracommunicator functionality, does not use MPI_IN_PLACE, and only transmits/receives simple integer types with relatively small counts. It does check a few fancier issues, such as ensuring that "premature user releases" of MPI_Op and MPI_Datatype objects does not result in a segfault.

Ibcast,Wait,Ibarrier test 2

This test attempts to execute multiple simultaneous non-blocking collective (NBC) MPI routines at the same time, and manages their completion with a variety of routines (MPI_{Wait,Test}{,_all,_any,_some}). The test also exercises a few point-to-point operations.

LAND operations test

Test MPI_LAND operations on optional datatypes.

LOR operations test

Test MPI_LOR operations on optional datatypes.

LXOR operations test

Test MPI_LXOR operations on optional datatypes.

MAXLOC operations test

Test MPI_LAXLOC operations on optional datatypes.

MAX operations test

Test MPI_MAX operations on optional datatypes.

MINLOC operations test

Test MPI_MINLOC operations on optional datatypes.

MIN operations test

Test MPI_Min operations on optional datatypes.

MScan test

The operation is inoutvec[i] = invec[i] op inoutvec[i] (see MPI-1.3 Message-Passing INterface section 4.9.4). The order of operation is important. Note that the computation is in process rank (in the communicator) order independant of the root process.

Matrix transpose test 1

This somewhat detailed example test was taken from MPI-The complete reference, Vol 1, p 222-224. Please refer to this reference for more details of the test.

Matrix transpose test 2

This program tests MPI_Alltoallw() by having the ith processor send different amounts of data to all processors. This is similar to the coll/alltoallv test, but with displacements in bytes rather than units of the datatype. Currently, the test uses only MPI_INT which is adequate for testing systems that use point-to-point operations.

Non-blocking collectives test

This is a weak sanity test that all non-blocking collectives specified by MPI-3 are present in the library and accept arguments as expected. This test does not check for progress, matching issues, or sensible output buffer values.

Op_{create,commute,free} test

A simple test of MPI_Op_Create/commute/free.

PROD operations test

Test MPI_PROD operations on optional datatypes.

Reduce/Bcast/Allreduce test

This test uses various calls to MPI_Reduce(), MPI_Bcast(), and MPI_Allreduce().

Reduce/Bcast test

This test repeats pairs of calls to MPI_Reduce() and MPI_Bcast() using different reduction operations while looking for errors.

Reduce/Bcast test

This test uses various calls to MPI_Reduce(), MPI_Bcast(), and MPI_Allreduce().

Reduce/Bcast tests

The operation is inoutvec[i] = invec[i] op inoutvec[i] (see MPI-1.3 Message-Passing INterface section 4.9.4). The order of operation is important. Note that the computation is in process rank (in the communicator) order independant of the root process.

Reduce_Scatter test 1

Test of reduce scatter. Checks that the non-communcative operations are not commuted and that all of the operations are performed.

Reduce_Scatter test 2

Test of reduce scatter with large data (needed to trigger the long-data algorithm). Each processor contributes its rank + index to the reduction, then receives the "ith" sum. Can be run with any number of processors, bit currently uses 1 processor due to the high demand on memory.

Reduce_Scatter test 3

Test of reduce scatter block with large data on an intercommunicator (needed in MPICH to trigger the long-data algorithm). Each processor contributes its rank + the index to the reduction, then receives the ith sum. Can be called with any number of processors.

Reduce_Scatter test 4

Test of reduce scatter with large data (needed in MPICH to trigger the long-data algorithm). Each processor contributes its rank + the index to the reduction, then receives the ith sum. Can be called with any number of processors.

Reduce_local test

A simple test of MPI_Reduce_local(). Uses MPI_SUM as well as user defined operators.

Reduce_scatter_block test 1

Test of reduce scatter with large data (needed in MPICH to trigger the long-data algorithm). Each processor contributes its rank + the index to the reduction, then receives the ith sum. Can be called with any number of processors.

Reduce_scatter_block test 2

Each process contributes its rank plus the index to the reduction, then receives the ith sum. Can be called with any number of processors.

Reduce_scatter test 1

Each processor contribues its rank plus the index to the reduction, then receives the ith sum. Can be called with any number of processors.

Reduce_scatter test 2

Test of reduce scatter with large data on an intercommunicator (needed in MPICH to trigger the long-data algorithm). Each processor contributes its rank + the index to the reduction, then receives the ith sum. Can be called with any number of processors.

Reduce test 1

This tests implements a simple matrix-matrix multiply. This is an associative but not comutative operation. For a matrix size of matsize, the matrix is stored in C order where c(i,j) is cin[j+i*matSize].

Reduce test 2

This tests implements a simple matrix-matrix multiply. This is an associative but not comutative operation. For a matrix size of matsize, the matrix is stored in C order where c(i,j) is cin[j+i*matSize].

Reduce test

Simple intercomm reduce test.

Reduce test

A simple test of MPI_Reduce() with the rank of the root process shifted through each possible value.

Reduce test

Test user-defined operations with a large number of elements. Added because a talk at EuroMPI'12 claimed that these failed with more than 64k elements.

SUM operations test

This test looks at integer or integer drelated atatypes not required my the MPI-3.0 standard (e.g. long long). Note that failure to support these datatypes is not an indication of a non-compliant MPI implementation.

Scan test

A simple test of MPI_Scan(). The operation is inoutvec[i] = invec[i] op inoutvec[i] (see 4.9.4 of the MPI standard 1.3). The order is important. Note that the computation is in process rank (in the communicator) order, independent of the root.

Scatter test 1

This test sends a vector and receives individual elements, except for the root process that does not receive any data.

Scatter test 2

This test sends contiguous data and receives a vector on some nodes and contiguous data on others. There is some evidence that some MPI implementations do not check recvcount on the root process. This test checks for that case.

Scatter test 3

This test sends a vector and receives individual elements.

Scatter test

This test uses MPI_Scatter() to define a two-dimensional table. See also test coll2 and coll3 for similar tests.

Scatter test

Simple intercomm scatter test.

Scatterv test

This test uses MPI_SCatterv() to define a two-dimensional table.

Scatterv test

Simple intercomm scatterv test.

Scatterv test

This is an example of using scatterv to send a matrix from one process to all others, with the matrix stored in Fortran order. Note the use of an explicit upper bound (UB) to enable the sources to overlap. This tests uses scatterv to make sure that it uses the datatype size and extent correctly. It requires the number of processors used in the call to MPI_Dims_create.

Wait test

This is a very weak sanity test that all non-blocking collectives specified by MPI-3 are present in the library and take arguments as expected. This test does not check for progress, matching issues, or sensible output buffer values.

MPI_Info Objects

The info tests emphasize the MPI Info object functionality.

MPI_Info_delete() test

This test exercises the MPI_Info_delete().

MPI_Info_dup() test

This test exercises the MPI_Info_dup().

MPI_Info_{get,send} test

Simple info test.

MPI_Info_get() test 1

This is a simple test of MPI_Info_get().

MPI_Info_get() test 2

Test of info that makes use of the extended handles, including inserts and deletes.

MPI_Info_get() test 3

Test of info that makes use of the extended handles.

MPI_Info_get() test 4

This is a simple test that illustrates how named keys are ordered.

MPI_Info_get() test 5

Simple info test.

Dynamic Process Management

This group features tests that add processes to a running communicator, joining separately started applications, then handling faults/failures.

Creation group intercomm test

James Dinan dinan@mcs.anl.gov
May, 2011

In this test processes create an intracommunicator, and creation is collective only on the members of the new communicator, not on the parent communicator. This is accomplished by building up and merging intercommunicators starting with MPI_COMM_SELF for each process involved.

Dynamic process management test

Checks if the dynamic process management routines through MPI-2.2 are defined. If the test passes, then "No errors" is reported.

MPI_Comm_accept() test

This tests exercises MPI_Open_port(), MPI_Comm_accept(), and MPI_Comm_disconnect().

MPI_Comm_connect() test 1

This test checks to make sure that two MPI_Comm_connect calls to two different MPI ports match their corresponding MPI_Comm_accept calls.

MPI_Comm_connect() test 2

This test checks to make sure that two MPI_Comm_connect calls to two different MPI ports match their corresponding MPI_Comm_accept calls.

MPI_Comm_disconnect() test 1

A simple test of Comm_disconnect.

MPI_Comm_disconnect() test 2

In this program, the return codes from the MPI routines are checked. Since the error handlers for the communicators are not set to MPI_ERRORS_RETURN, any error should cause an abort rather than a return. The test on the return value is an extra safety check; note that a return value of other than MPI_SUCCESS in these routines indicates an error in the error handling by the MPI implementation.

MPI_Comm_disconnect() test 3

This test tests the disconnect code for processes that span process groups. This test spawns a group of processes and then merges them into a single communicator. Then the single communicator is split into two communicators, one containing the even ranks and the other the odd ranks. Then the two new communicators do MPI_Comm_accept/connect/disconnect calls in a loop. The even group does the accepting while the odd group does the connecting.

MPI_Comm_disconnect() test 4

A simple test of Comm_connect/accept/disconnect.

MPI_Comm_disconnect() test

A simple test of Comm_disconnect.

MPI_Comm_disconnect() test

A simple test of Comm_disconnect.

MPI_Comm_join() test

A simple test of Comm_join.

MPI_Comm_spawn_multiple() test 1

A simple test of Comm_spawn_multiple with info.

MPI_Comm_spawn_multiple() test 2

This tests spawn_mult by using the same executable and no command-line options. The attribute MPI_APPNUM is used to determine which executable is running.

MPI_Comm_spawn() test 1

A simple test of Comm_spawn.

MPI_Comm_spawn() test 2

A simple test of Comm_spawn, called twice.

MPI_Comm_spawn() test 3

A simple test of Comm_spawn, with complex arguments.

MPI_Comm_spawn() test 4

A simple test of Comm_spawn with info.

MPI_Comm_spawn() test 5

A simple test of Comm_spawn, followed by intercomm merge.

MPI_Comm_spawn() test 6

A simple test of Comm_spawn, with many arguments.

MPI_Intercomm_creat() test

Use Spawn to create an intercomm, then create a new intercomm that includes processes not in the initial spawn intercomm.This test ensures that spawned processes are able to communicate with processes that were not in the communicator from which they were spawned.

MPI_Publish_name() test

This test confirms the functionality of MPI_Open_port() and MPI_Publish_name().

MPI spawn processing test 1

In this program, the return codes from the MPI routines are checked. Since the error handlers for the communicators are not set to MPI_ERRORS_RETURN, any error should cause an abort rather than a return. The test on the return value is an extra safety check; note that a return value of other than MPI_SUCCESS in these routines indicates an error in the error handling by the MPI implementation.

MPI spawn processing test 2

In this program, the return codes from the MPI routines are checked. Since the error handlers for the communicators are not set to MPI_ERRORS_RETURN, any error should cause an abort rather than a return. The test on the return value is an extra safety check; note that a return value of other than MPI_SUCCESS in these routines indicates an error in the error handling by the MPI implementation.

MPI spawn test with pthreads

Create a thread for each task. Each thread will spawn a child process to perform its task.

Multispawn test

This (is a placeholder for a) test that creates 4 threads, each of which does a concurrent spawn of 4 more processes, for a total of 17 MPI processes. The resulting intercomms are tested for consistency (to ensure that the spawns didn't get confused among the threads). As an option, it will time the Spawn calls. If the spawn calls block the calling thread, this may show up in the timing of the calls.

PGROUP creation test

James Dinan dinan@mcs.anl.gov
May, 2011

In this test, processes create an intracommunicator, and creation is collective only on the members of the new communicator, not on the parent communicator. This is accomplished by building up and merging intercommunicators using Connect/Accept to merge with a master/controller process.

Taskmaster test

This is a simple test that creates threads to verifiy compatibility between MPI and the pthread library.

Threads

This group features tests that utilize thread compliant MPI implementations. This includes the threaded environment provided by MPI-3.0, as well as POSIX compliant threaded libraries such as PThreads.

Alltoall thread test

The LISTENER THREAD waits for communication from any source (including calling thread) messages which it receives that has tag REQ_TAG. Each thread enters an infinite loop that will stop only if every node in the MPI_COMM_WORLD send message containing -1.

Easy thread test 1

This is a simple test of threads in MPI.

Easy thread test 2

This is a simple test of threads in MPI

MPIT multithreaded test

This test is adapted from test/mpi/mpi_t/mpit_vars.c. But this is a multithreading version in which multiple threads will call MPI_T routines.

With verbose set, thread 0 will prints out MPI_T control variables, performance variables and their categories.

Multiple threads test 1

This test creates communications concurrently in different threads.

Multiple threads test 2

This test creates communications concurrently in different threads.

Multiple threads test 3

This test repeatedly duplicates and frees communicators with multiple threads concurrently to stress the multithreaded aspects of the context ID allocation code. Thanks to IBM for providing the original version of this test.

Multispawn test

This (is a placeholder for a) test that creates 4 threads, each of which does a concurrent spawn of 4 more processes, for a total of 17 MPI processes. The resulting intercomms are tested for consistency (to ensure that the spawns didn't get confused among the threads). As an option, it will time the Spawn calls. If the spawn calls block the calling thread, this may show up in the timing of the calls.

Multi-threaded blocking test

The tests blocking and non-blocking capability within MPI.

Multi-threaded send/receive test

The buffer size needs to be large enough to cause the rndv protocol to be used. If the MPI provider doesn't use a rndv protocol then the size doesn't matter.

Simple thread test 1

The test initializes a thread, then calls MPI_Finalize() and prints "No errors".

Simple thread test 2

The test here is a simple one that Finalize exits, so the only action is to write no error.

Taskmaster test

This is a simple test that creates threads to verifiy compatibility between MPI and the pthread library.

Thread Group creation test

Every thread paticipates in a distinct MPI_Comm_create group, distinguished by its thread-id (used as the tag). Threads on even ranks join an even comm and threads on odd ranks join the odd comm.

Thread/RMA interaction test

This is a simple test of threads in MPI.

Threaded group test

In this test a number of threads are created with a distinct MPI communicator (or comm) group distringuished by its thread-id (used as a tag). Threads on even ranks join an even comm and threads on odd ranks join the odd comm.

Threaded ibsend test

This program performs a short test of MPI_BSEND in a multithreaded environment. It starts a single receiver thread that expects NUMSENDS messages and NUMSENDS sender threads, that use MPI_Bsend to send a message of size MSGSIZE to its right neigbour or rank 0 if (my_rank==comm_size-1), i.e. target_rank = (my_rank+1)%size.

After all messages have been received, the receiver thread prints a message, the threads are joined into the main thread and the application terminates.

Threaded multi-target test 1

Run concurrent sends to different target processes. Stresses an implementation that permits concurrent sends to different targets. By turning on verbose output, some simple performance data will be output.

Threaded multi-target test 2

Run concurrent sends to different target processes. Stresses an implementation that permits concurrent sends to different targets. By turning on verbose output, some simple performance data will be output. Use non-blocking sends, and have a single thread complete all I/O.

Threaded multi-target test 3

Run concurrent sends to different target processes. Stresses an implementation that permits concurrent sends to different targets. By turning on verbose output, some simple performance data will be output. Use non-blocking sends, and have a single thread complete all I/O.

Threaded multi-target test 3

Run concurrent sends to different target processes. Stresses an implementation that permits concurrent sends to different targets. By turning on verbose output, some simple performance data will be output. Use non-blocking sends, and have a single thread complete all I/O.

Threaded multi-target test 4

Send to self in a threaded program.

Threaded request test

Threaded generalized request tests.

Threaded wait/test test

Threaded wait/test request tests.

MPI-Toolkit Interface

This group features tests that involve the MPI Tool interface available in MPI-3.0 and higher.

MPI_T calls test 1

This test writes to control variables exposed by MPI_T functionality of MPI_3.0.

MPI_T calls test 2

A test that MPI_T string handling is working as expected.

MPI_T calls test 3

To print out all MPI_T control variables, performance variables and their categories in the MPI implementation.

MPIT multithreaded test

This test is adapted from test/mpi/mpi_t/mpit_vars.c. But this is a multithreading version in which multiple threads will call MPI_T routines.

With verbose set, thread 0 will prints out MPI_T control variables, performance variables and their categories.

Toolkit varlist test

This program, copyrighted (c) 2014, Lawrence Livermore National Security, LLC., accesses the performance and control variables as defined by under MPI-3.0 and newer.

MPI-3.0

This group features tests that exercises MPI-3.0 and higher functionality. Note that the test suite was designed to be compiled and executed under all versions of MPI. If the current version of MPI the test suite is less that MPI-3.0, the executed code will report "MPI-3.0 or higher required" and will exit.

C++ datatype test

This test checks for the existence of four new C++ named predefined datatypes that should be accessible from C and Fortran.

Comm_create_group test 1

This test is create/frees groups using different schemes.

Comm_create_group test 2

This routine creates/frees groups using different schemes.

Comm_create_group test 3

This routine creates/frees groups using different schemes.

Comm_create_group test 4

This routine creates/frees groups using different schemes.

Comm_create_group test 5

This routine creates/frees groups using different schemes.

Comm_create_group test 7

This routine creates/frees groups using even-odd pairs.

Comm_create_group test 8

This routine create/frees groups using modulus 4 random numbers.

Comm_creation_group test 6

This routine creates/frees groups using different schemes.

Comm_idup test 1

This test exercises MPI_Comm_idup().

Comm_idup test 2

Test plan: Make rank 0 wait in a blocking recv until all other processes have posted their MPI_Comm_idup ops, then post last. Should ensure that idup doesn't block on the non-zero ranks, otherwise we'll get a deadlock.

Comm_idup test 3

Test plan: Make rank 0 wait in a blocking recv until all other processes have posted their MPI_Comm_idup ops, then post last. Should ensure that idup doesn't block on the non-zero ranks, otherwise we'll get a deadlock.

Comm_idup test 4

Test creating multiple communicators with MPI_Comm_idup.

Comm_idup test 5

Each pair dups the communicator such that the dups are overlapping. If this were done with MPI_Comm_dup, this should deadlock.

Comm_split test 4

This test only checks that the MPI_Comm_split_type routine doesn't fail. It does not check for correct behavior.

Comm_with_info() test 1

This test exercises MPI_Comm_dup_with_info().

Comm_with_info test 2

This test exercises MPI_Comm_dup_with_info().

Comm_with_info test 3

This test exercises MPI_Comm_dup_with_info().

Compare_and_swap test

This function compares one element of type datatype in the compare buffer compare_addr with the buffer at offset target_disp in the target window specified by target_rank and window. It replaces the value at the target with the value in the origin buffer if both buffers are identical. The original value at the target is returned in the result buffer.

Datatype structs test

This test was motivated by the failure of an example program for RMA involving simple operations on a struct that included a struct. The observed failure was a SEGV in the MPI_Get.

Easy thread test 2

This is a simple test of threads in MPI

Fetch_and_op test

This is a simple test that executes the MPI_Fetch_and op() calls on RMA windows.

Get_acculumate test 1

Get Accumalated Test. This is a simple test of MPI_Get_accumulate().

Get_accumulate test 2

Get Accumulate Test. This is a simple test of MPI_Get_accumulate().

Iallreduce test

This test illustrates the use of MPI_Iallreduce() and MPI_Allreduce().

Ibarrier test

This test calls MPI_Ibarrier() followed by an conditional loop containing usleep(1000) and MPI_Test(). This test hung indefinitely under some MPI implementations. Successfully completing this test indicates the error has been corrected.

Ibcast,Wait,Ibarrier test 1

This is a basic test of all 17 non-blocking collective operations specified by the MPI-3 standard. It only exercises the intracommunicator functionality, does not use MPI_IN_PLACE, and only transmits/receives simple integer types with relatively small counts. It does check a few fancier issues, such as ensuring that "premature user releases" of MPI_Op and MPI_Datatype objects does not result in a segfault.

Ibcast,Wait,Ibarrier test 2

This test attempts to execute multiple simultaneous non-blocking collective (NBC) MPI routines at the same time, and manages their completion with a variety of routines (MPI_{Wait,Test}{,_all,_any,_some}). The test also exercises a few point-to-point operations.

Large count test

This test checks for large count functionality ("MPI_Count") mandated by MPI-3, as well as behavior of corresponding pre-MPI-3 interfaces that have better defined behavior when an "int" quantity would overflow.

Linked_list construction test 1

Construct a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. Each process p then appends N new elements to the list when the tail reaches process p-1.

Linked_list construction test 2

MPI-3 distributed linked list construction example. Construct a distributed shared linked list using proposed MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. Each process "p" then appends N new elements to the list when the tail reaches process "p-1". The test uses the MPI_LOCK_EXCLUSIVE argument with MPI_Win_lock().

Linked-list construction test 3

This test constructs a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. Each process "p" then appends N new elements to the list when the tail reaches process "p-1". This test is similar to "rma/linked_list_bench_lock_excl" but uses an MPI_LOCK_SHARED parameter to MPI_Win_Lock().

Linked_list construction test 4

This test constructs a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to an RMA window, and broadcasts the pointer to all processes. All processes then concurrently append N new elements to the list. When a process attempts to attach its element to the tail of list it may discover that its tail pointer is stale and it must chase ahead to the new tail before the element can be attached.

Linked list construction test 5

This test constructs a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. All processes then concurrently append N new elements to the list. When a process attempts to attach its element to the tail of list it may discover that its tail pointer is stale and it must chase ahead to the new tail before the element can be attached.

Linked list construction test 6

Construct a distributed shared linked list using MPI-3 dynamic RMA windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. All processes then concurrently append N new elements to the list. When a process attempts to attach its element to the tail of list it may discover that its tail pointer is stale and it must chase ahead to the new tail before the element can be attached. This version of the test suite uses MPI_Win_lock_all() instead of MPI_Win_lock(MPI_LOCK_EXCLUSIVE, ...).

MCS_Mutex_trylock test

This test exercises the MCS_Mutex_lock calls.

MPI_Dist_graph_create test

This test excercises MPI_Dist_graph_create() and MPI_Dist_graph_adjacent().

MPI_Get_library_version test

MPI-3.0 Test returns MPI library version.

MPI_Info_create() test

Comm_{set,get}_info test

MPI_Info_get() test 1

This is a simple test of MPI_Info_get().

MPI_Mprobe() test

This test MPI_Mprobe() to get the status of a pending receive, then calls MPI_Mrecv() with that status value.

MPI_PROC_NULL test

Test the MPI_PROC_NULL as a valid target.

MPI RMA read-and-ops test

This test exercises atomic, one-sided read-and-operation calls.

MPI_Status large count test

This test manipulates an MPI status object using MPI_Status_set_elements_x() with a large count value.

MPI_T calls test 1

This test writes to control variables exposed by MPI_T functionality of MPI_3.0.

MPI_T calls test 2

A test that MPI_T string handling is working as expected.

MPI_T calls test 3

To print out all MPI_T control variables, performance variables and their categories in the MPI implementation.

MPIT multithreaded test

This test is adapted from test/mpi/mpi_t/mpit_vars.c. But this is a multithreading version in which multiple threads will call MPI_T routines.

With verbose set, thread 0 will prints out MPI_T control variables, performance variables and their categories.

MPI_Win_allocate_shared test

Test MPI_WIN_ALLOCATE and MPI_WIN_ALLOCATE_SHARED when allocating SHM memory with size of 1GB per process.

Matched Probe test

written Dr. Michael L. Stokes, Michael.Stokes@UAH.edu

This routine is designed to test the MPI-3.0 matched probe support. The support provided in MPI-2.2 was not thread safe allowing other threads to usurp messages probed in other threads.

The rank=0 process generates a random array of floats that is sent to mpi rank 1. Rank 1 send a message back to rank 0 with the message length of the received array. Rank 1 spawns 2 or more threads that each attempt to read the message sent by rank 0. In general, all of the threads have equal access to the data, but the first one to probe the data will eventually end of processing the data, and all the others will relent. The threads use MPI_Improbe(), so if there is nothing to read, the thread will rest for 0.1 secs before reprobing. If nothing is probed within a fixed number of cycles, the thread exists and sets it thread exit status to 1. If a thread is able to read the message, it returns an exit status of 0.

Multiple threads test 1

This test creates communications concurrently in different threads.

Multiple threads test 2

This test creates communications concurrently in different threads.

Non-blocking collectives test

This is a weak sanity test that all non-blocking collectives specified by MPI-3 are present in the library and accept arguments as expected. This test does not check for progress, matching issues, or sensible output buffer values.

One-Sided accumulate test 4

Author: James Dinan dinan@mcs.anl.gov
Date: December, 201

This code performs N strided put operations followed by get operations into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

One-Sided accumulate test 8

Author: James Dinan dinan@mcs.anl.gov
Date: November, 2012

This code performs N strided put operations followed by get operations into a 2-D patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

One-sided accumulate test 5

Author: James Dinan dinan@mcs.anl.gov
Date: November, 2012

This code performs N strided put operations followed by get operations into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

RMA Shared Memory test

This simple test uses MPI_Win_allocate_shared() with MPI_Win_fence(), MPI_Put() calls with assertions.

RMA compliance test

The test uses various combinations of either zero size datatypes or zero size counts. All tests should pass to be compliant with the MPI-3.0 specification.

RMA zero-byte transfers test

Test loops are used to run through a series of communicators that are subsets of MPI_COMM_WORLD.

Request-based ops test

Example 11.21 from the MPI 3.0 spec. The following example shows how request-based operations can be used to overlap communication with computation. Each process fetches, processes, and writes the result for NSTEPS chunks of data. Instead of a single buffer, M local buffers are used to allow up to M communication operations to overlap with computation.

Thread/RMA interaction test

This is a simple test of threads in MPI.

Threaded group test

In this test a number of threads are created with a distinct MPI communicator (or comm) group distringuished by its thread-id (used as a tag). Threads on even ranks join an even comm and threads on odd ranks join the odd comm.

Toolkit varlist test

This program, copyrighted (c) 2014, Lawrence Livermore National Security, LLC., accesses the performance and control variables as defined by under MPI-3.0 and newer.

Type_contiguous test

This test checks that MPI can handle large datatypes.

Type_create_hindexed_block test 1

Tests behavior with a hindexed_block that can be converted to a contig easily. This is specifically for coverage. Returns the number of errors encountered.

Type_create_hindexed_block test 2

This test is a simple check of MPI_Type_create_hindexed_block() using MPI_Type_get_envelope() and MPI_Type_get_contents().

Wait test

This is a very weak sanity test that all non-blocking collectives specified by MPI-3 are present in the library and take arguments as expected. This test does not check for progress, matching issues, or sensible output buffer values.

Win_allocate_shared test

Test MPI_WIN_ALLOCATE_SHARED when size of total shared memory region is 0.

Win_create_dynamic test

This test exercises dynamic RMA windows using the MPI_Win_create_dynamic() and MPI_Accumulate() operations.

Win_flush() test

Window Flush. This simple test flushes a shared window.

Win_get_attr test

This test determines which "flavor" of RMA is created.

Win_info test

This test creates an RMA info object, sets key/value pairs on the object, then duplicates the info object and confirms that the key/value pairs are in the same order as the original.

Win_shared_query test 1

This simple test exercises the MPI_Win_shared_query().

Win_shared_query test 2

This test exercises MPI_Win_shared_query().

Win_shared_query test 3

MPI_Put test with noncontiguous datatyes.

MPI-2.2

This group features tests that exercises MPI functionality of MPI-2.2 and earlier.

Alloc_mem test

Checks if MPI_Alloc_mem() is supported. If test passes, then the following is reported "MPI_Alloc_mem is supported." else, "MPI_Alloc_mem NOT supported" is reported.

C/Fortran interoperability test

Checks if the C-Fortran (F77) interoperability functions are supported using MPI-2.2 specification.

Comm_create() test

This program tests that MPI_Comm_create applies to intercommunicators. This is an extension added in MPI-2.

Comm_split Test 1

This tests whether MPI_Comm_split() applies to intercommunicators which is an extension of MPI-2.

Communicator attributes test

Returns all communicator attributes that are not supported. The test is run as a single process MPI job.

Deprecated routines test

Checks all MPI deprecated routines as of MPI-2.2.

Dynamic process management test

Checks if the dynamic process management routines through MPI-2.2 are defined. If the test passes, then "No errors" is reported.

Error Handling test

Reports the default action taken on an error. It also reports if error handling can be changed to "returns", and if so, if this functions properly.

Extended collectives test

Checks if "extended collectives" are supported. If the test fails to compile, then "extended collectives" are not supported. If the test compiles, then a 4-process MPI job is executed. If the job aborts, then "Extended collectives NOT supported" is reported. If the job executes and the correct value is returned, then "Extended collectives ARE supported" is reported.

I/O modes test

Checks if all MPI predefined I/O modes are supported. If test passes, "No errors" is reported. Any modes not supported are indicated individually as not being supported.

I/O verification test 1

Reports if MPI I/O is supported. If the MPI-I/O routines terminate normally and provide correct results, MPI-I/O reportes "No errors", otherwise error messages are generated.

I/O verification test 2

This test is used to verify that the file created by io_test,c holds the correct values. If the test fails, the problem is reported. If all tests pass successfully it is reported that MPI-I/O is supported.

Init argument test

In MPI-1.1, it is explicitly stated that an implementation is allowed to require that the arguments argc and argv passed by an application to MPI_Init in C be the same arguments passed into the application as the arguments to main. In MPI-2 implementations are not allowed to impose this requirement. Conforming implementations of MPI allow applications to pass NULL for both the argc and argv arguments of MPI_Init(). This test prints the result of the error status of MPI_Init(). If the test completes without error, it reports 'No errors.'

MPI-2 Routines test 2

This test simply checks all MPI-2 routines that replaced some MPI-1 routines. Since these routines were added to avoid ambiquity with MPI-2 functionality, they do not add functionality to the test suite.

MPI-2 routines test 1

Checks all MPI-2.2 routines that replaced deprecated routines. If the test passes, then "No errors" is reported, otherwise, specific errors are reported."

MPI_Topo_test() test

Specify a distributed graph of a bidirectional ring of the MPI_COMM_WORLD communicator. Thus each node in the graph has a left and right neighbor.

Master/slave test

This test running as a single MPI process spawns four slave processes using MPI_Comm_spawn(). The master process sends and receives a message from each slave. If the test completes, it will report 'No errors.', otherwise specific error messages are listed.

One-sided communication test

Checks MPI-2.2 one-sided communication modes reporting those that are not defined. If the test compiles, then "No errors" is reported, else, all undefined modes are reported as "not defined."

One-sided fences test

Test Verifies that one-sided communication with active target synchronization with fences functions properly. If all operations succeed, one-sided communication with active target synchronization with fences is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with active target synchronization with fences is reported as NOT supported.

One-sided passive test

Verifies one-sided-communication with passive target synchronization functions properly. If all operations succeed, one-sided-communication with passive target synchronization is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with passive target synchronization with fences is reported as NOT supported.

One-sided post test

Verifies one-sided-communication with active target synchronization with post/start/complete/wait functions properly. If all operations succeed, one-sided communication with active target synchronization with post/start/complete/wait is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with active target synchronization with post/start/complete/wait is reported as NOT supported.

One-sided routines test

Reports if one-sided communication routines are defined. If this test compiles, one-sided communication is reported as defined, otherwise "not supported".

Reduce_local test

A simple test of MPI_Reduce_local(). Uses MPI_SUM as well as user defined operators.

Thread support test

Reports the level of thread support provided. This is either MPI_THREAD_SINGLE, MPI_THREAD_FUNNELED, MPI_THREAD_SERIALIZED, or MPI_THREAD_MULTIPLE.

RMA

This group features tests that involve Remote Memory Access, sometimes called one-sided communication. Remote Memory Access is similar in fuctionality to shared memory access.

ADLB mimic test

This test uses one server process (S), one target process (T) and a bunch of origin processes (O). 'O' PUTs (LOCK/PUT/UNLOCK) data to a distinct part of the window, and sends a message to 'S' once the UNLOCK has completed. The server forwards this message to 'T'. 'T' GETS the data from this buffer after it receives the message from 'S', to see if it contains the correct contents.

diagram showing communication steps between the S, O, and T processes

Accumulate with Lock test

Accumulate Lock. This test uses MAXLOC and MINLOC with MPI_Accumulate

Accumulate with fence test 1

This simple test of Accumulate/Replace with fence.

Accumulate with fence test 2

Accumulate Fence. Test MPI_Accumulate with fence. This test is the same as accfence2 except that it uses alloc_mem() to allocate memory.

Accumulate() with fence test 3

Accumulate Fence. Test MPI_Accumulate with fence. The test illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes.

Alloc_mem test

Checks if MPI_Alloc_mem() is supported. If test passes, then the following is reported "MPI_Alloc_mem is supported." else, "MPI_Alloc_mem NOT supported" is reported.

Alloc_mem test

Allocate Memory. Simple test where MPI_Alloc_mem() and MPI_Free_mem() work together.

Another one-sided accumulate test 2

This code performs one-sided accumulate into a 2-D patch of a shared array.

Attributes order test

Test creating and inserting attributes in different orders to ensure the list management code handles all cases.

Compare_and_swap test

This function compares one element of type datatype in the compare buffer compare_addr with the buffer at offset target_disp in the target window specified by target_rank and window. It replaces the value at the target with the value in the origin buffer if both buffers are identical. The original value at the target is returned in the result buffer.

Contented Put test 1

Contented RMA put test by James Dinan dinan@mcs.anl.gov. Each process issues COUNT put and get operations to non-overlapping locations on every other process.

Contented Put test 2

Contented RMA put test by James Dinan dinan@mcs.anl.gov. Each process issues COUNT put operations to non-overlapping locations on every other process.

Contiguous Get test

This program calls MPI_Get with an indexed datatype. The datatype comprises a single integer at an initial displacement of 1 integer. That is, the first integer in the array is to be skipped. This program found a bug in IBM's MPI in which MPI_Get ignored the displacement and got the first integer instead of the second. Run with one (1) process.

Fetch_and_add test 1

Fetch and add example from Using MPI-2 (the non-scalable version,Fig. 6.12).

Fetch_and_add test 2

MPI fetch and add test. Fetch and add example from Using MPI-2 (the non-scalable version,Fig. 6.12). This test is the same as rma/fetchandadd but uses alloc_mem.

Fetch_and_add test 3

This is the tree-based scalable version of the fetch-and-add example from the book Using MPI-2, p. 206-207. This test is functionally attempting to perform an atomic read-modify-write sequence using MPI-2 one-sided operations.

Fetch_and_add test 4

This is the tree-based scalable version of the fetch-and-add example from Using MPI-2, pg 206-207. The code in the book (Fig 6.16) has bugs that are fixed in this test.

Fetch_and_op test

This is a simple test that executes the MPI_Fetch_and op() calls on RMA windows.

{Get,set}_name test

This simple test exercises the MPI_Win_set_name().

Get_acculumate test 1

Get Accumalated Test. This is a simple test of MPI_Get_accumulate().

Get_accumulate test 2

Get Accumulate Test. This is a simple test of MPI_Get_accumulate().

Get test 1

Tests a series of Gets. Run with 2 processors. Same as rma/test5 but uses alloc_mem.

Get test 2

Tests a series of Gets. Runs using exactly two processors.

Get with fence test

Get with Fence. This is a simple test using MPI_Get() with fence.

Keyvalue create/delete test

Free keyval window. Test freeing keyvals while still attached to an RMA windown, then make sure that the keyval delete code is still executed.

Linked_list construction test 1

Construct a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. Each process p then appends N new elements to the list when the tail reaches process p-1.

Linked_list construction test 2

MPI-3 distributed linked list construction example. Construct a distributed shared linked list using proposed MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. Each process "p" then appends N new elements to the list when the tail reaches process "p-1". The test uses the MPI_LOCK_EXCLUSIVE argument with MPI_Win_lock().

Linked-list construction test 3

This test constructs a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. Each process "p" then appends N new elements to the list when the tail reaches process "p-1". This test is similar to "rma/linked_list_bench_lock_excl" but uses an MPI_LOCK_SHARED parameter to MPI_Win_Lock().

Linked_list construction test 4

This test constructs a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to an RMA window, and broadcasts the pointer to all processes. All processes then concurrently append N new elements to the list. When a process attempts to attach its element to the tail of list it may discover that its tail pointer is stale and it must chase ahead to the new tail before the element can be attached.

Linked list construction test 5

This test constructs a distributed shared linked list using MPI-3 dynamic windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. All processes then concurrently append N new elements to the list. When a process attempts to attach its element to the tail of list it may discover that its tail pointer is stale and it must chase ahead to the new tail before the element can be attached.

Linked list construction test 6

Construct a distributed shared linked list using MPI-3 dynamic RMA windows. Initially process 0 creates the head of the list, attaches it to the window, and broadcasts the pointer to all processes. All processes then concurrently append N new elements to the list. When a process attempts to attach its element to the tail of list it may discover that its tail pointer is stale and it must chase ahead to the new tail before the element can be attached. This version of the test suite uses MPI_Win_lock_all() instead of MPI_Win_lock(MPI_LOCK_EXCLUSIVE, ...).

Lock-single_op-unlock test

Test passive target RMA on 2 processes wtih the original datatype derived from the target datatype.

Locks with no RMA ops test

This test creates a window, clears the memory in it using memset(), locks and unlocks it, then terminates.

MCS_Mutex_trylock test

This test exercises the MCS_Mutex_lock calls.

MPI_PROC_NULL test

Test the MPI_PROC_NULL as a valid target.

MPI RMA read-and-ops test

This test exercises atomic, one-sided read-and-operation calls.

MPI_Win_allocate_shared test

Test MPI_WIN_ALLOCATE and MPI_WIN_ALLOCATE_SHARED when allocating SHM memory with size of 1GB per process.

Matrix transpose test 1

Transposes a matrix using put, fence, and derived datatypes. Uses vector and hvector (Example 3.32 from MPI 1.1 Standard). Run using 2 processors.

Matrix transpose test 2

Transposes a matrix using put, fence, and derived datatypes. Uses vector and struct (Example 3.33 from MPI 1.1 Standard). We could use vector and type_create_resized instead. Run using exactly 2 processors.

Matrix transpose test 3

Transposes a matrix using post/start/complete/wait and derived datatypes. Uses vector and hvector (Example 3.32 from MPI 1.1 Standard). Run using 2 processors.

Matrix transpose test 4

Transposes a matrix using passive target RMA and derived datatypes. Uses vector and hvector (Example 3.32 from MPI 1.1 Standard). Run using 2 processors.

Matrix transpose test 5

This does a transpose-accumulate operation. Uses vector and hvector datatypes (Example 3.32 from MPI 1.1 Standard). Run using 2 processors.

Matrix transpose test 6

This does a local transpose-accumulate operation. Uses vector and hvector datatypes (Example 3.32 from MPI 1.1 Standard). Run using exactly 1 processor.

Matrix transpose test 7

This test transpose a matrix with a get operation, fence, and derived datatypes. Uses vector and hvector (Example 3.32 from MPI 1.1 Standard). Run using exactly 2 processorss.

Mixed synchronization test

Perform several communication operations, mixing synchronization types. Use multiple communication to avoid the single-operation optimization that may be present.

One-Sided accumulate test 1

Author: James Dinan dinan@mcs.anl.gov
Date: December, 201

This code performs N accumulates into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

One-Sided accumulate test 3

Author: James Dinan dinan@mcs.anl.gov
Date: December, 2010

This code performs N accumulates into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI subarray type.

One-Sided accumulate test 4

Author: James Dinan dinan@mcs.anl.gov
Date: December, 201

This code performs N strided put operations followed by get operations into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

One-Sided accumulate test 6

Author: James Dinan dinan@mcs.anl.gov
Date: December, 2010

This code performs N strided put operations followed by get operations into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

One-Sided accumulate test 8

Author: James Dinan dinan@mcs.anl.gov
Date: November, 2012

This code performs N strided put operations followed by get operations into a 2-D patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

One-sided accumulate test 5

Author: James Dinan dinan@mcs.anl.gov
Date: November, 2012

This code performs N strided put operations followed by get operations into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed type.

One-sided accumulate test 7

Author: James Dinan dinan@mcs.anl.gov
Date: December, 2010

This code performs N strided put operations followed by get operations into a 2-D patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI indexed datatype.

One-sided communication test

Checks MPI-2.2 one-sided communication modes reporting those that are not defined. If the test compiles, then "No errors" is reported, else, all undefined modes are reported as "not defined."

One-sided fences test

Test Verifies that one-sided communication with active target synchronization with fences functions properly. If all operations succeed, one-sided communication with active target synchronization with fences is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with active target synchronization with fences is reported as NOT supported.

One-sided passive test

Verifies one-sided-communication with passive target synchronization functions properly. If all operations succeed, one-sided-communication with passive target synchronization is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with passive target synchronization with fences is reported as NOT supported.

One-sided post test

Verifies one-sided-communication with active target synchronization with post/start/complete/wait functions properly. If all operations succeed, one-sided communication with active target synchronization with post/start/complete/wait is reported as supported. If one or more operations fail, the failures are reported and one-sided-communication with active target synchronization with post/start/complete/wait is reported as NOT supported.

One-sided routines test

Reports if one-sided communication routines are defined. If this test compiles, one-sided communication is reported as defined, otherwise "not supported".

Parallel pi calculation test

This test calculates pi by integrating the function 4/(1+x*x). It was converted from an interactive program to a batch program to facilitate it's use in the test suite.

Put,Gets,Accumulate test 1

Tests a series of put, get, and accumulate on 2 processes using fence. This test is the same as rma/test1 but uses alloc_mem.

Put,Gets,Accumulate test 2

Tests a series of puts, gets, and accumulate on 2 processes using fence.

Put,Gets,Accumulate test 3

Tests a series of puts, gets, and accumulate on 2 processes using fence. Same as rma/test1 but uses derived datatypes to receive data.

Put,Gets,Accumulate test 4

Tests put and get with post/start/complete/wait on 2 processes. Same as rma/test1 but uses alloc_mem.

Put,Gets,Accumulate test 5

Tests put and get with post/start/complete/wait on 2 processes.

Put,Gets,Accumulate test 6

Tests the example in Fig 6.8, pg 142, MPI-2 standard. Process 1 has a blocking MPI_Recv between the Post and Wait. Therefore, this example will not run if the one-sided operations are simply implemented on top of MPI_Isends and Irecvs. They either need to be implemented inside the progress engine or using threads with Isends and Irecvs. In MPICH-2, they are implemented in the progress engine. This test is the same as rma/test3 but uses alloc_mem.

Put,Gets,Accumulate test 7

Tests the example in Fig 6.8, pg 142, MPI-2 standard. Process 1 has a blocking MPI_Recv between the Post and Wait. Therefore, this example will not run if the one-sided operations are simply implemented on top of MPI_Isends and Irecvs. They either need to be implemented inside the progress engine or using threads with Isends and Irecvs. In MPICH-2 (in MPICH), they are implemented in the progress engine.

Put,Gets,Accumulate test 8

Tests passive target RMA on 2 processes. tests the lock-single_op-unlock optimization. Same as rma/test4 but uses alloc_mem.

Put,Gets,Accumulate test 9

Tests passive target RMA on 2 processes using a lock-single_op-unlock optimization.

Put() with fences test

Put with Fences used to seperate epochs. This test looks at the behavior of MPI_Win_fence and epochs. Each MPI_Win_fence may both begin and end both the exposure and access epochs. Thus, it is not necessary to use MPI_Win_fence in pairs.

The tests have the following form:

      Process A             Process B
        fence                 fence
        put,put
        fence                 fence
                              put,put
        fence                 fence
        put,put               put,put
        fence                 fence
      

RMA Shared Memory test

This simple test uses MPI_Win_allocate_shared() with MPI_Win_fence(), MPI_Put() calls with assertions.

RMA attributes test

This test creates a window, then extracts its attributes through a series of MPI calls.

RMA compliance test

The test uses various combinations of either zero size datatypes or zero size counts. All tests should pass to be compliant with the MPI-3.0 specification.

RMA contention test 1

Test for lock contention. Tests for lock contention, including special cases within the MPI implementation; in this case, our coverage analysis showed that the lockcontention test was not covering all cases, and in fact, this test revealed a bug in the code). In all of these tests, each process writes (or accesses) the values rank + i*size_of_world for NELM times. This test strives to avoid operations not strictly permitted by MPI RMA, for example, it doesn't target the same locations with multiple put/get calls in the same access epoch.

RMA contention test 2

Additional test for lock contention. Additional tests for lock contention. These are designed to exercise some of the optimizations within MPICH, but all are valid MPI programs. Tests structure includes:

lock local (must happen at this time since application can use load store after thelock)
send message to partner

receive message
send ack

receive ack
Provide a delay so that the partner will see the conflict

partner executes:
lock // Note: this may block rma operations (see below)
unlock
send back to partner

unlock
receive from partner
check for correct data

The delay may be implemented as a ring of message communication; this is likely to automatically scale the time to what is needed.

RMA contention test 3

This is a modified version of rma/test4. Submitted by Liwei Peng, Microsoft. tests passive target RMA on 3 processes. Tests the lock-single_op-unlock optimization.

RMA contiguous calls test

This test exercises the one-sided contiguous MPI calls.

RMA fence test 1

This simple test creates a window then performs a post/start/complete/wait operation.

RMA fence test 2

This test checks an oddball case for generalized active target synchronization where the start occurs before the post. Since start can block until the corresponding post, the group passed to start must be disjoint from the group passed to post for processes to avoid a circular wait. Here, odd/even groups are used to accomplish this and the even group reverses its start/post calls.

RMA fence test 3

Base Author: James Dinan dinan@mcs.anl.gov This code performs N strided put operations into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI datatype. This test generates a datatype that is relative to an arbitrary base address in memory and tests the RMA implementation's ability to perform the correct transfer.

RMA fence test 4

One-Sided MPI 2-D Strided Put Test. This code performs N strided put operations into a 2d patch of a shared array. The array has dimensions [X, Y] and the subarray has dimensions [SUB_X, SUB_Y] and begins at index [0, 0]. The input and output buffers are specified using an MPI datatype. This test generates a datatype that is relative to MPI_BOTTOM and tests the RMA implementation's ability to perform the correct transfer.

RMA fence test 5

This test illustrates the use of MPI routines to run through a selection of communicators and datatypes.

RMA fence test 6

One MPI Implementation fails this test with sufficiently large values of blksize - it appears to convert this type to an incorrect contiguous move.

RMA fence test 7

This test illustrates the use of MPI routines to run through a selection of communicators and datatypes.

RMA many ops test 1

This test is a simplification of the one in "perf/manyrma" that tests for correct handling of the case where many RMA operations occur between synchronization events. This is one of the ways that RMA may be used, and is used in the reference implementation of the graph500 benchmark.

RMA many ops test 2

Many RMA operations. This simple test creates an RMA window, locks it, and performs many accumulate operations on it.

RMA post/start/complete test

Tests put and get with post/start/complete/test on 2 processes. Same as rma/test2, but uses win_test instead of win_wait.

RMA post/start/complete/wait test

Accumulate Post-Start-Complete-Wait. This test uses accumulate/replace with post/start/complete/wait.

RMA (rank=0) test

Test that calls many RMA calls to root=0.

RMA zero-byte transfers test

Test loops are used to run through a series of communicators that are subsets of MPI_COMM_WORLD.

Request-based ops test

Example 11.21 from the MPI 3.0 spec. The following example shows how request-based operations can be used to overlap communication with computation. Each process fetches, processes, and writes the result for NSTEPS chunks of data. Instead of a single buffer, M local buffers are used to allow up to M communication operations to overlap with computation.

Thread/RMA interaction test

This is a simple test of threads in MPI.

Win_allocate_shared test

Test MPI_WIN_ALLOCATE_SHARED when size of total shared memory region is 0.

Win_create_dynamic test

This test exercises dynamic RMA windows using the MPI_Win_create_dynamic() and MPI_Accumulate() operations.

Win_create_errhandler test

This test creates 1000 RMA windows using MPI_Alloc_mem(), then frees the dynamic memory and the RMA windows that were created.

Win_errhandler test

This test creates and frees MPI error handlers in a loop (1000 iterations) to test the internal MPI RMA memory allocation routines.

Win_flush() test

Window Flush. This simple test flushes a shared window.

Win_get_attr test

This test determines which "flavor" of RMA is created.

Win_get_group test

This is a simple test of MPI_Win_get_group().

Win_info test

This test creates an RMA info object, sets key/value pairs on the object, then duplicates the info object and confirms that the key/value pairs are in the same order as the original.

Win_shared_query test 1

This simple test exercises the MPI_Win_shared_query().

Win_shared_query test 2

This test exercises MPI_Win_shared_query().

Win_shared_query test 3

MPI_Put test with noncontiguous datatyes.

Attributes Tests

This group features tests that involve attributes objects.

At_Exit test 1

The MPI-2.2 specification makes it clear that attributes are called on MPI_COMM_WORLD and MPI_COMM_SELF at the very beginning of MPI_Finalize in LIFO order with respect to the order in which they are set. This is useful for tools that want to perform the MPI equivalent of an "at_exit" action.

This test uses 20 attribues to ensure that the hash-table based MPI implementations do not accidentally pass the test except by being extremely "lucky". There are (20!) possible permutations providing about a 1 in 2.43e18 chance of getting LIFO ordering out of a hash table assuming a decent hash function is used.

At_Exit test 2

This test demonstrates how to attach an "at-exit()" function to MPI_Finalize().

Attribute Callback Functions test

This test exercises attribute routines. It checks for correct behavior of the copy and delete functions on an attribute, particularly the correct behavior when the routine returns failure.

MPI 1.2 Clarification: Clarification of Error Behavior of Attribute Callback Functions. Any return value other than MPI_SUCCESS is erroneous. The specific value returned to the user is undefined (other than it can't be MPI_SUCCESS). Proposals to specify particular values (e.g., user's value) failed. This test is similar in function to attrerr but uses a different set of tests.

Attribute/Datatype test

This program creates a contiguous datatype from type MPI_INT, attaches an attribute to the type, duplicates it, then deletes both the original and duplicate type.

Attribute Error test

This test exercises attribute routines. It checks for correct behavior of the copy and delete functions on an attribute, particularly the correct behavior when the routine returns a failure.

MPI 1.2 Clarification: Clarification of Error Behavior of Attribute Callback Functions. Any return value other than MPI_SUCCESS is erroneous. The specific value returned to the user is undefined (other than it can't be MPI_SUCCESS). Proposals to specify particular values (e.g., user's value) failed.

Attribute delete/get test

This program illustrates the use of MPI_Comm_create_keyval() that creates a new attribute key.

Attribute error test

This test checks for correct behavior of the copy and delete functions on an attribute, particularly the correct behavior when the routine returns failure.

Any return value other than MPI_SUCCESS is erroneous. The specific value returned to the user is undefined (other than it can't be MPI_SUCCESS). Proposals to specify particular values (e.g., user's value) have not been successful.

Attribute order test

This test creates and inserts attribues in different orders to ensure that the list management code handles all cases properly.

Base attribute test

This program tests the integrity of the MPI-3.0 base attributes. The attribute keys tested are:

  1. MPI_TAG_UB
  2. MPI_HOST
  3. MPI_IO
  4. MPI_WTIME_IS_GLOBAL
  5. MPI_APPNUM
  6. MPI_UNIVERSE_SIZE
  7. MPI_LASTUSEDCODE

Basic Attributes test

This test accesses many attribues such as MPI_TAG_UB, MPI_HOST, MPI_IO, MPI_WTIME_IS_GLOBAL, and many others and reports any errors.

Communicator Attribute Order test

This test creates and inserts attributes in different orders to ensure that the list management code handles all cases properly.

Communicator attributes test

Returns all communicator attributes that are not supported. The test is run as a single process MPI job.

Communicator test

This test is similar to attr/attrordertype but uses a different strategy of mixing attribute order, types, and with different types of communicators.

Function keyval test

This test illustrates the use of the copy and delete functions used in the manipulation of keyvals. It also tests to confirm that attributes are copied when communicators are duplicated.

Intercommunicators test

This test exercises communicator routines from intercommunicators.

Keyval communicators test

This test tests freeing of keyvals while still attached to a communicator, then tests to make sure that the keyval delete and copy functions are executed properly.

Keyval test with types test

This tests illustrates the use of keyvals associated with datatypes.

Multiple keyval_free test

This tests multiple invocations of keyval_free on the same keyval.

RMA attributes test

This test creates a window, then extracts its attributes through a series of MPI calls.

Type Attribute Order test

This test creates and inserts attributes in different orders to ensure that the list management codes handles all cases properly.

Performance

This group features tests that involve realtime latency performance analysis of MPI appications. Although performance testing is not an established goal of this test suite, these few tests were included because there has been discussion of including performance testing in future versions of the test suite. Such tests might be useful to aide users in determining what MPI features should be used for their particular application. These tests are exemplary of what future tests could provide.

Datatype creation test

Make sure datatype creation is independent of data size. However, that there is no guarantee or expectation that the time would be constant. In particular, some optimizations might take more time than others.

The real goal of this is to ensure that the time to create a datatype doesn't increase strongly with the number of elements within the datatype, particularly for these datatypes that are quite simple patterns.

Group creation test

This is a performance test indexed by group number. The cost should be linear or at worst ts*log(ts), where ts <= number of communicators.

MPI_Group_Translate_ranks() test

Measure and compare the relative performance of MPI_Group_translate_ranks with small and large group2 sizes but a constant number of ranks. This serves as a performance sanity check for the Scalasca use case where we translate to MPI_COMM_WORLD ranks. The performance should only depend on the number of ranks passed, not the size of either group (especially group2). This test is probably only meaningful for large-ish process counts.

MPI-Tracing package test

This code is intended to test the trace overhead when using an MPI tracing package. The test is currently run in verbose mode with the number of processes set to 32 to run on the greatest number of HPC systems.

MPI_{pack,unpack}() test 1

This code may be used to test the performance of some of the noncontiguous datatype operations, including vector and indexed pack and unpack operations. To simplify the use of this code for tuning an MPI implementation, it uses no communication, just the MPI_Pack and MPI_Unpack routines. In addition, the individual tests are in separate routines, making it easier to compare the compiler-generated code for the user (manual) pack/unpack with the code used by the MPI implementation. Further, to be fair to the MPI implementation, the routines are passed the source and destination buffers; this ensures that the compiler can't optimize for statically allocated buffers.

MPI_{pack,unpack}() test 2

Tests that basic optimizations are performed on indexed datatypes. If PACK_IS_NATIVE is defined, MPI_Pack stores exactly the same bytes as the user would pack manually; in that case, there is a consistency check.

MPI_{pack,unpack}() test 3

Tests that the performance of a struct that contains a vector type exploits the vector type correctly. If PACK_IS_NATIVE is defined, MPI_Pack stores exactly the same bytes as the user would pack manually; in that case, there is a consistency check.

MPI_{pack,unpack}() test 4

Tests that basic optimizations are performed on vector of vector datatypes. As the "leaf" element is a large block (when properly optimized), the performance of an MPI datatype should be nearly as good (if not better) than manual packing (the threshold used in this test is *very* forgiving). This test may be run with one process.

If PACK_IS_NATIVE is defined, MPI_Pack stores exactly the same bytes as the user would pack manually; in that case, there is a consistency check.

Network tests

This test calculates bulk transfer rates and latency as a function of message buffer size. The arguments are:

  1. -reps #iterations
  2. -time stop_time
  3. -start initial_msg_size
  4. -end final_msg_size
  5. -out outputfile
  6. -nocache
  7. -headtohead
  8. -pert
  9. -noprint
  10. -onebuffer largest_buffer_size

This test requires exactly two processes.

Send/Receive test

This program provides a simple test of send-receive performance between two (or more) processes. This test is sometimes called head-to-head or ping-ping test, as both processes send at the same time.

Synchonization test

This test compares the time it takes between a synchronization step between rank 0 and rank 1. If that difference is greater than 10 percent, it is considered an error.

Timer test

Check that the timer produces monotone nondecreasing times and that the tick is reasonable.

Transposition test

This test transposes a (100x100) two-dimensional array using various options and times the resulting operations.

Variable message length test

This test measures the latency involved in sending/receiving messages of varying size.