[mvapich-discuss] xcbrd tests
Bas van der Vlies
basv at sara.nl
Wed Apr 4 02:18:03 EDT 2007
Hello,
From our users we still get reports that there are errors with mvapich
version 1 and 2. So we did some tests with the Scalapack testsuite.
Attached you find the output of the xcbrd test program, part of the
Scalapack suit, in the TESTING directory.
I attached 4 cases:
topspin-g77: topspin mpich1 and infiniband, g77 compiler
This test runs ok
This is the infiniband stack from topspin/cisco and their
implementation of mvapich based on version
mpich1-gfortran: mvapich-0.9.8 with gfortran compiler
This test gives incorrect output, and takes a long time
to complete
mpich1-g77: mvapich-0.9.8 with g77 compiler
This test gives one line output and hangs
mpich2-gfortran: mvapich2-0.9.8
Same result as mpich1-gfortran
In all gfortran cases, the environment variable GFORTRAN_UNBUFFERED_ALL
was set to 'y'.
Other tests give various results: examples for mpich2-gfortran:
xsinv runs, put part of the output contains errors
xsqr seems to run fine.
Can you comment on this?
--
Willem Vermin tel (31)20 5923054/5923000
SARA, Kruislaan 415 fax (31)20 6683167
1098 SJ Amsterdam willem at sara.nl
Nederland
--
********************************************************************
* *
* Bas van der Vlies e-mail: basv at sara.nl *
* SARA - Academic Computing Services phone: +31 20 592 8012 *
* Kruislaan 415 fax: +31 20 6683167 *
* 1098 SJ Amsterdam *
* *
********************************************************************
-------------- next part --------------
SCALAPACK Bidiagonal reduction
'MPI machine'
Tests of the parallel complex single precision bidiagonal
reduction routines.
The following scaled residual checks will be computed:
||A - Q B P'|| / (||A|| * eps * N)
The matrix A is randomly generated for each test.
An explanation of the input/output parameters follows:
TIME : Indicates whether WALL or CPU time was used.
M : The number of rows of the matrix A.
N : The number of columns of the matrix A.
NB : The size of the square blocks the matrix A is split into.
P : The number of process rows.
Q : The number of process columns.
THRESH : If a residual value is less than THRESH, CHECK is flagged as PASSED
BRD time : Time in seconds to reduce the matrix
MFLOPS : Rate of execution for the bidiagonal reduction.
The following parameter values will be used:
M : 4 10 17 13
N : 4 12 13 13
NB : 2 3 4 5
P : 1 2 1 4
Q : 1 2 4 1
Relative machine precision (eps) is taken to be 0.596046E-07
Routines pass computational tests if scaled residual is less than 10.000
TIME M N NB P Q BRD Time MFLOPS Residual CHECK
---- ------ ------ --- ----- ----- --------- ----------- -------- ------
WALL 4 4 2 1 1 0.00 3.40 0.70 PASSED
WALL 4 4 3 1 1 0.00 6.56 0.66 PASSED
WALL 4 4 4 1 1 0.00 16.65 1.02 PASSED
WALL 4 4 5 1 1 0.00 17.07 1.02 PASSED
WALL 10 12 2 1 1 0.00 45.61 0.57 PASSED
WALL 10 12 3 1 1 0.00 42.93 0.59 PASSED
WALL 10 12 4 1 1 0.00 44.88 0.62 PASSED
WALL 10 12 5 1 1 0.00 54.59 0.51 PASSED
WALL 17 13 2 1 1 0.00 76.28 0.37 PASSED
WALL 17 13 3 1 1 0.00 73.34 0.37 PASSED
WALL 17 13 4 1 1 0.00 72.41 0.48 PASSED
WALL 17 13 5 1 1 0.00 75.44 0.46 PASSED
WALL 13 13 2 1 1 0.00 55.53 0.43 PASSED
WALL 13 13 3 1 1 0.00 52.43 0.43 PASSED
WALL 13 13 4 1 1 0.00 52.43 0.50 PASSED
WALL 13 13 5 1 1 0.00 57.02 0.59 PASSED
WALL 4 4 2 2 2 0.00 1.32 0.66 PASSED
WALL 4 4 3 2 2 0.00 1.50 1.12 PASSED
WALL 4 4 4 2 2 0.00 3.38 1.02 PASSED
WALL 4 4 5 2 2 0.00 3.65 1.02 PASSED
WALL 10 12 2 2 2 0.00 11.59 0.47 PASSED
WALL 10 12 3 2 2 0.00 11.55 0.84 PASSED
WALL 10 12 4 2 2 0.00 12.83 0.68 PASSED
WALL 10 12 5 2 2 0.00 16.31 0.84 PASSED
WALL 17 13 2 2 2 0.00 20.66 0.35 PASSED
WALL 17 13 3 2 2 0.00 22.04 0.44 PASSED
WALL 17 13 4 2 2 0.00 22.10 0.41 PASSED
WALL 17 13 5 2 2 0.00 24.38 0.39 PASSED
WALL 13 13 2 2 2 0.00 15.96 0.57 PASSED
WALL 13 13 3 2 2 0.00 15.48 0.40 PASSED
WALL 13 13 4 2 2 0.00 15.37 0.49 PASSED
WALL 13 13 5 2 2 0.00 17.46 0.52 PASSED
WALL 4 4 2 1 4 0.00 2.25 0.70 PASSED
WALL 4 4 3 1 4 0.00 1.95 0.90 PASSED
WALL 4 4 4 1 4 0.00 4.46 1.02 PASSED
WALL 4 4 5 1 4 0.00 4.35 1.02 PASSED
WALL 10 12 2 1 4 0.00 12.40 0.46 PASSED
WALL 10 12 3 1 4 0.00 11.72 0.57 PASSED
WALL 10 12 4 1 4 0.00 11.89 0.60 PASSED
WALL 10 12 5 1 4 0.00 15.07 0.71 PASSED
WALL 17 13 2 1 4 0.00 20.68 0.40 PASSED
WALL 17 13 3 1 4 0.00 20.05 0.38 PASSED
WALL 17 13 4 1 4 0.00 19.74 0.44 PASSED
WALL 17 13 5 1 4 0.00 22.88 0.42 PASSED
WALL 13 13 2 1 4 0.00 14.51 0.51 PASSED
WALL 13 13 3 1 4 0.00 14.26 0.45 PASSED
WALL 13 13 4 1 4 0.00 14.73 0.45 PASSED
WALL 13 13 5 1 4 0.00 16.00 0.49 PASSED
WALL 4 4 2 4 1 0.00 1.94 1.00 PASSED
WALL 4 4 3 4 1 0.00 1.43 0.68 PASSED
WALL 4 4 4 4 1 0.00 4.09 1.02 PASSED
WALL 4 4 5 4 1 0.00 3.71 1.02 PASSED
WALL 10 12 2 4 1 0.00 10.03 0.56 PASSED
WALL 10 12 3 4 1 0.00 9.64 0.67 PASSED
WALL 10 12 4 4 1 0.00 10.12 0.52 PASSED
WALL 10 12 5 4 1 0.00 13.81 0.61 PASSED
WALL 17 13 2 4 1 0.00 17.76 0.53 PASSED
WALL 17 13 3 4 1 0.00 16.10 0.46 PASSED
WALL 17 13 4 4 1 0.00 16.19 0.35 PASSED
WALL 17 13 5 4 1 0.00 18.28 0.42 PASSED
WALL 13 13 2 4 1 0.00 12.42 0.51 PASSED
WALL 13 13 3 4 1 0.00 10.87 0.43 PASSED
WALL 13 13 4 4 1 0.00 11.58 0.54 PASSED
WALL 13 13 5 4 1 0.00 13.09 0.51 PASSED
Finished 64 tests, with the following results:
64 tests completed and passed residual checks.
0 tests completed and failed residual checks.
0 tests skipped because of illegal input values.
END OF TESTS.
Takes a second or so to complete
-------------- next part --------------
SCALAPACK Bidiagonal reduction
'MPI machine'
Tests of the parallel complex single precision bidiagonal
reduction routines.
The following scaled residual checks will be computed:
||A - Q B P'|| / (||A|| * eps * N)
The matrix A is randomly generated for each test.
An explanation of the input/output parameters follows:
TIME : Indicates whether WALL or CPU time was used.
M : The number of rows of the matrix A.
N : The number of columns of the matrix A.
NB : The size of the square blocks the matrix A is split into.
P : The number of process rows.
Q : The number of process columns.
THRESH : If a residual value is less than THRESH, CHECK is flagged as PASSED
BRD time : Time in seconds to reduce the matrix
MFLOPS : Rate of execution for the bidiagonal reduction.
The following parameter values will be used:
M : 4 10 17 13
N : 4 12 13 13
NB : 2 3 4 5
P : 1 2 1 4
Q : 1 2 4 1
Relative machine precision (eps) is taken to be 0.596046E-07
Routines pass computational tests if scaled residual is less than 10.000
TIME M N NB P Q BRD Time MFLOPS Residual CHECK
---- ------ ------ --- ----- ----- --------- ----------- -------- ------
WALL 4 4 2 1 1 0.00 0.00 0.79 PASSED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 2 2 0.00 0.00 NaN FAILED
{ 0, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 1}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 2 2 0.00 0.00 NaN FAILED
{ 1, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 1, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 1, 1}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 2 1 4 0.00 0.00 NaN FAILED
{ 0, 3}: Memory overwrite in PCGEBRD
{ 0, 2}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 1 4 0.00 0.00 NaN FAILED
{ 0, 2}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 1 4 0.00 0.00 NaN FAILED
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 2}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 1 4 0.00 0.00 NaN FAILED
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 1 4 0.00 0.00 NaN FAILED
{ 3, 0}: Memory overwrite in PCGEBRD
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 2 4 1 0.00 0.00 NaN FAILED
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 2, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 4 1 0.00 0.00 NaN FAILED
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: Memory overwrite in PCGEBRD
{ 2, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 4 1 0.00 0.00 NaN FAILED
{ 2, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 1, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 4 1 0.00 0.00 NaN FAILED
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 4 1 0.00 0.00 NaN FAILED
Finished 64 tests, with the following results:
1 tests completed and passed residual checks.
63 tests completed and failed residual checks.
0 tests skipped because of illegal input values.
END OF TESTS.
This takes a long time to end
-------------- next part --------------
scalapack-1.7.5/TESTING/xcbrd
mvapich1/g77:
SCALAPACK Bidiagonal reduction
'MPI machine'
Tests of the parallel complex single precision bidiagonal
reduction routines.
The following scaled residual checks will be computed:
||A - Q B P'|| / (||A|| * eps * N)
The matrix A is randomly generated for each test.
An explanation of the input/output parameters follows:
TIME : Indicates whether WALL or CPU time was used.
M : The number of rows of the matrix A.
N : The number of columns of the matrix A.
NB : The size of the square blocks the matrix A is split into.
P : The number of process rows.
Q : The number of process columns.
THRESH : If a residual value is less than THRESH, CHECK is flagged as PASSED
BRD time : Time in seconds to reduce the matrix
MFLOPS : Rate of execution for the bidiagonal reduction.
The following parameter values will be used:
M : 4 10 17 13
N : 4 12 13 13
NB : 2 3 4 5
P : 1 2 1 4
Q : 1 2 4 1
Relative machine precision (eps) is taken to be 0.596046E-07
Routines pass computational tests if scaled residual is less than 10.000
TIME M N NB P Q BRD Time MFLOPS Residual CHECK
---- ------ ------ --- ----- ----- --------- ----------- -------- ------
WALL 4 4 2 1 1 0.00 0.00 0.70 PASSED
and hangs
-------------- next part --------------
SCALAPACK Bidiagonal reduction
'MPI machine'
Tests of the parallel complex single precision bidiagonal
reduction routines.
The following scaled residual checks will be computed:
||A - Q B P'|| / (||A|| * eps * N)
The matrix A is randomly generated for each test.
An explanation of the input/output parameters follows:
TIME : Indicates whether WALL or CPU time was used.
M : The number of rows of the matrix A.
N : The number of columns of the matrix A.
NB : The size of the square blocks the matrix A is split into.
P : The number of process rows.
Q : The number of process columns.
THRESH : If a residual value is less than THRESH, CHECK is flagged as PASSED
BRD time : Time in seconds to reduce the matrix
MFLOPS : Rate of execution for the bidiagonal reduction.
The following parameter values will be used:
M : 4 10 17 13
N : 4 12 13 13
NB : 2 3 4 5
P : 1 2 1 4
Q : 1 2 4 1
Relative machine precision (eps) is taken to be 0.596046E-07
Routines pass computational tests if scaled residual is less than 10.000
TIME M N NB P Q BRD Time MFLOPS Residual CHECK
---- ------ ------ --- ----- ----- --------- ----------- -------- ------
WALL 4 4 2 1 1 0.00 0.00 0.79 PASSED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 1 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 2 2 0.00 0.00 NaN FAILED
{ 0, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 1}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 2 2 0.00 0.00 NaN FAILED
{ 0, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 1, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 1, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 1, 1}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 2 2 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 2 1 4 0.00 0.00 NaN FAILED
{ 0, 2}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: Memory overwrite in PCGEBRD
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 1 4 0.00 0.00 NaN FAILED
{ 0, 2}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 1 4 0.00 0.00 NaN FAILED
{ 0, 2}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 1}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 0, 3}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 1 4 0.00 0.00 NaN FAILED
{ 0, 3}: Memory overwrite in PCGEBRD
{ 0, 3}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 1 4 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 1 4 0.00 0.00 NaN FAILED
{ 3, 0}: Memory overwrite in PCGEBRD
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 2 4 1 0.00 0.00 NaN FAILED
{ 2, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 3 4 1 0.00 0.00 NaN FAILED
{ 2, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 4 4 1 0.00 0.00 NaN FAILED
{ 2, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 1, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
{ 3, 0}: Memory overwrite in PCGEBRD
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 4 4 5 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 2 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 3 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 4 4 1 0.00 0.00 NaN FAILED
{ 3, 0}: Memory overwrite in PCGEBRD
{ 3, 0}: PCGEBRD memory overwrite in pre-guardzone: loc( 1) = -9923. + i* -9923.
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 10 12 5 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 2 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 3 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 4 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 17 13 5 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 2 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 3 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 4 4 1 0.00 0.00 NaN FAILED
||A - Q*B*P|| / (||A|| * N * eps) = NaN
WALL 13 13 5 4 1 0.00 0.00 NaN FAILED
Finished 64 tests, with the following results:
1 tests completed and passed residual checks.
63 tests completed and failed residual checks.
0 tests skipped because of illegal input values.
END OF TESTS.
Takes a long time to complete
More information about the mvapich-discuss
mailing list