[mvapich-discuss] xcbrd tests
Bas van der Vlies
basv at sara.nl
Wed Apr 4 02:31:41 EDT 2007
Hello,
Our users still reports problems with mvapich version 1 and 2. So we
did some more testing with some programs from the Scalapack suit.
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 installation software stack from
topspin/cisco based on their implementation of
the mvapich software.
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