Kokkos Node API and Local Linear Algebra Kernels Version of the Day
Classes | Functions
TSQR::Test Namespace Reference

Accuracy and performance tests for TSQR. More...

Classes

class  CombineBenchmarkParameters
 Parameters for the TSQR::Combine benchmarks. More...
class  CombineBenchmarker
 Benchmark TSQR::Combine, and also calibrate number of trials. More...
class  LapackBenchmarker
 Template version of LAPACK QR benchmark. More...
class  SeqTsqrBenchmarker
 Template version of SequentialTsqr benchmark. More...
class  TsqrInaccurate
 Signals that a TSQR test failed due to insufficient accuracy. More...
class  FullTsqrVerifier
 Test (correctness and) accuracy of Tsqr for one Scalar type. More...
class  FullTsqrVerifierCallerImpl
 This class implements a "function template specialization.". More...
class  FullTsqrVerifierCaller
 Invokes FullTsqrVerifier::run() over all Scalar types in a type list. More...
class  DistTsqrVerifier
 Generic version of DistTsqr accuracy test. More...
class  DistTsqrBenchmarker
 Generic version of DistTsqr performance test. More...
class  Cons
 Typedef container enabling iteration over compile-time type list. More...
class  NullCons
 Base case for Cons template recursion. More...

Functions

template<class TimerType >
double computeTimerResolution ()
 Compute resolution in seconds of the TimerType timer.
template<class Ordinal , class Scalar >
static std::vector< typename
ScalarTraits< Scalar >
::magnitude_type > 
verifyCombineTemplate (TSQR::Random::NormalGenerator< Ordinal, Scalar > &gen, TSQR::Random::NormalGenerator< Ordinal, typename ScalarTraits< Scalar >::magnitude_type > &magGen, const Ordinal numRows, const Ordinal numCols, const bool debug)
 Test accuracy of TSQR::Combine.
template<class Ordinal , class Scalar >
static std::vector< typename
ScalarTraits< Scalar >
::magnitude_type > 
verifyCombineSeqTemplate (TSQR::Random::NormalGenerator< Ordinal, Scalar > &gen, TSQR::Random::NormalGenerator< Ordinal, typename ScalarTraits< Scalar >::magnitude_type > &magGen, const Ordinal numRows, const Ordinal numCols, const bool debug)
 Simulate one combine step of Sequential TSQR.
void verifyCombine (const int numRows, const int numCols, const bool testReal, const bool testComplex, const bool printFieldNames, const bool simulateSequentialTsqr, const bool debug)
 Test accuracy of TSQR::Combine.
template<class Ordinal , class Scalar , class Generator >
void nodeTestProblem (Generator &generator, const Ordinal nrows, const Ordinal ncols, Scalar A[], const Ordinal lda, const bool numerically_interesting)
template<class Ordinal , class Scalar >
static void verifySeqTsqrTemplate (std::ostream &out, TSQR::Random::NormalGenerator< Ordinal, Scalar > &generator, const std::string &datatype, const std::string &shortDatatype, const Ordinal nrows, const Ordinal ncols, const size_t cache_size_hint, const bool contiguous_cache_blocks, const bool save_matrices, const std::string &additionalFieldNames, const std::string &additionalData, const bool printFieldNames, const bool human_readable, const bool b_debug)
void verifySeqTsqr (std::ostream &out, const int nrows, const int ncols, const size_t cache_size_hint, const bool test_complex_arithmetic, const bool save_matrices, const bool contiguous_cache_blocks, const std::string &additionalFieldNames, const std::string &additionalData, const bool printFieldNames, const bool human_readable=false, const bool b_debug=false)
 Test accuracy of SequentialTsqr.
void verifyLapack (std::ostream &out, const int nrows, const int ncols, const bool test_complex_arithmetic, const std::string &additionalFieldNames, const std::string &additionalData, const bool printFieldNames, const bool human_readable, const bool b_debug=false)
 Test accuracy of LAPACK's QR factorization.
void benchmarkLapack (std::ostream &out, const int numRows, const int numCols, const int numTrials, const bool testComplex, const std::string &additionalFieldNames, const std::string &additionalData, const bool printFieldNames, const bool humanReadable)
 Test performance of LAPACK's QR factorization.
void benchmarkSeqTsqr (std::ostream &out, const int numRows, const int numCols, const int numTrials, const size_t cacheSizeHint, const bool contiguousCacheBlocks, const bool testComplex, const std::string &additionalFieldNames, const std::string &additionalData, const bool printFieldNames, const bool humanReadable)
 Test performance of SequentialTsqr.
template<class Ordinal , class Scalar >
void verifyTbbTsqr (const std::string &scalarTypeName, TSQR::Random::NormalGenerator< Ordinal, Scalar > &generator, const Ordinal nrows, const Ordinal ncols, const int num_cores, const size_t cache_size_hint, const bool contiguous_cache_blocks, const bool printFieldNames, const bool human_readable, const bool b_debug=false)
template<class Ordinal , class Scalar >
void benchmarkTbbTsqr (const std::string &scalarTypeName, const int ntrials, const Ordinal nrows, const Ordinal ncols, const int num_cores, const size_t cache_size_hint, const bool contiguous_cache_blocks, const bool printFieldNames, const bool human_readable)
template<class TimerType >
double verifyTimerConcept ()
 Ensure that TimerType has the required interface.
template<class Ordinal , class Scalar , class Generator >
static void generateStack (Generator &generator, Matrix< Ordinal, Scalar > &A_global, const typename Teuchos::ScalarTraits< Scalar >::magnitudeType singularValues[], const int numProcs, const Ordinal numCols)
 Generate a random "R stack" test problem on one MPI process.
template<class Ordinal , class Scalar , class Generator >
void par_tsqr_test_problem (Generator &generator, Matrix< Ordinal, Scalar > &A_local, Matrix< Ordinal, Scalar > &A_global, const Ordinal ncols, const Teuchos::RCP< MessengerBase< Scalar > > &messenger)
 Generate a random test problem for the distributed-memory part of TSQR.
template<class MatrixViewType , class Generator >
void distributedTestProblem (Generator &generator, MatrixViewType &A_local, MessengerBase< typename MatrixViewType::ordinal_type > *const ordinalComm, MessengerBase< typename MatrixViewType::scalar_type > *const scalarComm)
template<class NodeType >
Teuchos::RCP
< Teuchos::ParameterList
getValidNodeParameters ()
 Return valid parameter list with default values.
template<class NodeType >
Teuchos::RCP< const NodeType > getNode (const Teuchos::RCP< Teuchos::ParameterList > &plist)
 Return a Kokkos Node instance with the given parameters.
template<class Ordinal , class Scalar , class Generator >
void verifyTsqr (const std::string &which, const std::string &scalarTypeName, Generator &generator, const Ordinal nrows_global, const Ordinal ncols, const Teuchos::RCP< MessengerBase< Ordinal > > &ordinalComm, const Teuchos::RCP< MessengerBase< Scalar > > &scalarComm, const int num_cores=1, const size_t cache_size_hint=0, const bool contiguousCacheBlocks, const bool printFieldNames, const bool human_readable=false, const bool b_debug=false)
 Test and print to stdout the accuracy of parallel TSQR.
template<class Ordinal , class Scalar , class Generator , class TimerType >
void benchmarkTsqr (const std::string &which, const std::string &scalarTypeName, Generator &generator, const int ntrials, const Ordinal nrows_global, const Ordinal ncols, const Teuchos::RCP< MessengerBase< Ordinal > > &ordinalComm, const Teuchos::RCP< MessengerBase< Scalar > > &scalarComm, const Ordinal num_cores, const size_t cache_size_hint, const bool contiguousCacheBlocks, const bool printFieldNames, const bool human_readable, const bool b_debug)
 Benchmark parallel TSQR and report timings to stdout.

Detailed Description

Accuracy and performance tests for TSQR.

The classes and routines here are not intended for consumers of TSQR, but may be helpful as examples.


Function Documentation

template<class TimerType >
TSQR::Test::computeTimerResolution ( )

Compute resolution in seconds of the TimerType timer.

The timer resolution is the smallest time interval for which TimerType reports a nonzero time. We measure the timer's resolution in seconds with a timing loop that does some fake sequential floating-point work. We keep increasing the number of iterations in the timing loop until the timer says that the loop took nonzero time, and return that nonzero time.

Definition at line 65 of file Tsqr_CombineBenchmarker.hpp.

template<class Ordinal , class Scalar >
static std::vector< typename ScalarTraits< Scalar >::magnitude_type > TSQR::Test::verifyCombineTemplate ( TSQR::Random::NormalGenerator< Ordinal, Scalar > &  gen,
TSQR::Random::NormalGenerator< Ordinal, typename ScalarTraits< Scalar >::magnitude_type > &  magGen,
const Ordinal  numRows,
const Ordinal  numCols,
const bool  debug 
) [static]

Test accuracy of TSQR::Combine.

1. [R1; R2] where R1 and R2 are both ncols by ncols upper triangular.

2. [R; A] where R is ncols by ncols upper triangular, and A is nrows by ncols general dense.

Returns:
($\|A - QR\|_F$, $\|I - Q^* Q\|_F$, $\|A\|_F$) for each test problem (so, a vector of six elements).

Definition at line 225 of file Tsqr_CombineTest.cpp.

template<class Ordinal , class Scalar >
static std::vector< typename ScalarTraits< Scalar >::magnitude_type > TSQR::Test::verifyCombineSeqTemplate ( TSQR::Random::NormalGenerator< Ordinal, Scalar > &  gen,
TSQR::Random::NormalGenerator< Ordinal, typename ScalarTraits< Scalar >::magnitude_type > &  magGen,
const Ordinal  numRows,
const Ordinal  numCols,
const bool  debug 
) [static]

Simulate one combine step of Sequential TSQR.

Definition at line 425 of file Tsqr_CombineTest.cpp.

void TSQR::Test::verifyCombine ( const int  numRows,
const int  numCols,
const bool  testReal,
const bool  testComplex,
const bool  printFieldNames,
const bool  simulateSequentialTsqr,
const bool  debug 
)

Test accuracy of TSQR::Combine.

Test the accuracy of TSQR::Combine, and print the results to stdout. Rather than template on Ordinal and Scalar, as with the full TSQR tests, we pick Ordinal=int and try four different Scalar types (the same four that LAPACK supports: double, float, complex<double>, complex<float> -- i.e., S,D,C,Z).

Parameters:
numRows[in] When testing the [R; A] routines, the number of rows in the cache block A.
numCols[in] Number of columns in the test matrices.
testReal[in] Whether or not to test TSQR::Combine for real arithmetic. For now, this means Scalar={float,double}.
testComplex[in] Whether or not to test TSQR::Combine for complex arithmetic. For now, this means Scalar={std::complex<float>, std::complex<double>}.
printFieldNames[in] Whether to print field names (to make machine parsing of results easier).
simulateSequentialTsqr[in] Whether to use TSQR::Combine to simulate SequentialTsqr.
debug[in] Whether to print (possibly verbose) debugging output to stderr.
Note:
This routine will only test Combine if at least one of testReal and testComplex is true.

Definition at line 568 of file Tsqr_CombineTest.cpp.

template<class Ordinal , class Scalar , class Generator >
void TSQR::Test::nodeTestProblem ( Generator &  generator,
const Ordinal  nrows,
const Ordinal  ncols,
Scalar  A[],
const Ordinal  lda,
const bool  numerically_interesting 
)

Fill in the nrows by ncols matrix A (with leading dimension lda) with a test problem for single-node TSQR.

Definition at line 48 of file Tsqr_nodeTestProblem.hpp.

template<class Ordinal , class Scalar >
static void TSQR::Test::verifySeqTsqrTemplate ( std::ostream &  out,
TSQR::Random::NormalGenerator< Ordinal, Scalar > &  generator,
const std::string &  datatype,
const std::string &  shortDatatype,
const Ordinal  nrows,
const Ordinal  ncols,
const size_t  cache_size_hint,
const bool  contiguous_cache_blocks,
const bool  save_matrices,
const std::string &  additionalFieldNames,
const std::string &  additionalData,
const bool  printFieldNames,
const bool  human_readable,
const bool  b_debug 
) [static]

Test the accuracy of sequential TSQR on an nrows by ncols matrix (using the given cache block size (in bytes)), and print the results to stdout.

Definition at line 132 of file Tsqr_SeqTest.cpp.

void TSQR::Test::verifySeqTsqr ( std::ostream &  out,
const int  nrows,
const int  ncols,
const size_t  cache_size_hint,
const bool  test_complex_arithmetic,
const bool  save_matrices,
const bool  contiguous_cache_blocks,
const std::string &  additionalFieldNames,
const std::string &  additionalData,
const bool  printFieldNames,
const bool  human_readable = false,
const bool  b_debug = false 
)

Test accuracy of SequentialTsqr.

Test the accuracy of our sequential TSQR implementation (SequentialTsqr), on an nrows by ncols matrix, using the given cache size hint (in bytes). Print the results to the given output stream out.

Definition at line 353 of file Tsqr_SeqTest.cpp.

void TSQR::Test::verifyLapack ( std::ostream &  out,
const int  nrows,
const int  ncols,
const bool  test_complex_arithmetic,
const std::string &  additionalFieldNames,
const std::string &  additionalData,
const bool  printFieldNames,
const bool  human_readable,
const bool  b_debug = false 
)

Test accuracy of LAPACK's QR factorization.

Test the accuracy of LAPACK's QR factorization (_GEQRF + _ORGQR) on an nrows by ncols matrix, and print the results to the given output stream out.

Definition at line 579 of file Tsqr_SeqTest.cpp.

void TSQR::Test::benchmarkLapack ( std::ostream &  out,
const int  numRows,
const int  numCols,
const int  numTrials,
const bool  testComplex,
const std::string &  additionalFieldNames,
const std::string &  additionalData,
const bool  printFieldNames,
const bool  humanReadable 
)

Test performance of LAPACK's QR factorization.

Test the run time over numTrials trials of LAPACK QR (_GEQRF + _ORGQR), on a numRows by numCols matrix, and print the results to the given output stream out.

Parameters:
humanReadable[in] If true, print the benchmark results to out in human-readable format. Otherwise, print them as two rows of comma-delimited ASCII, in an abbreviated format suitable for automatic processing.

Definition at line 827 of file Tsqr_SeqTest.cpp.

void TSQR::Test::benchmarkSeqTsqr ( std::ostream &  out,
const int  numRows,
const int  numCols,
const int  numTrials,
const size_t  cacheSizeHint,
const bool  contiguousCacheBlocks,
const bool  testComplex,
const std::string &  additionalFieldNames,
const std::string &  additionalData,
const bool  printFieldNames,
const bool  humanReadable 
)

Test performance of SequentialTsqr.

Test the run time over ntrials trials of sequential TSQR, on an nrows by ncols matrix (using the given cache block size (in bytes)), and print the results to the given output stream out.

Parameters:
human_readable[in] If true, print the benchmark results to stdout in human-readable format. Otherwise, print them as two rows of comma-delimited ASCII, in an abbreviated format suitable for automatic processing.

Definition at line 1061 of file Tsqr_SeqTest.cpp.

template<class Ordinal , class Scalar >
void TSQR::Test::verifyTbbTsqr ( const std::string &  scalarTypeName,
TSQR::Random::NormalGenerator< Ordinal, Scalar > &  generator,
const Ordinal  nrows,
const Ordinal  ncols,
const int  num_cores,
const size_t  cache_size_hint,
const bool  contiguous_cache_blocks,
const bool  printFieldNames,
const bool  human_readable,
const bool  b_debug = false 
)

Test the accuracy of Intel TBB TSQR on an nrows by ncols matrix (using the given number of cores and the given cache block size (in bytes)), and print the results to stdout.

Definition at line 73 of file Tsqr_TbbTest.hpp.

template<class Ordinal , class Scalar >
void TSQR::Test::benchmarkTbbTsqr ( const std::string &  scalarTypeName,
const int  ntrials,
const Ordinal  nrows,
const Ordinal  ncols,
const int  num_cores,
const size_t  cache_size_hint,
const bool  contiguous_cache_blocks,
const bool  printFieldNames,
const bool  human_readable 
)

Benchmark Intel TBB TSQR vs. LAPACK's QR, and print the results to stdout.

Note:
c++0x support is need in order to have a default template parameter argument for a template function, otherwise we would have templated this function on TimerType and made Teuchos::Time the default.

Definition at line 258 of file Tsqr_TbbTest.hpp.

template<class TimerType >
double TSQR::Test::verifyTimerConcept ( )

Ensure that TimerType has the required interface.

verifyTimerConcept Our TSQR benchmarks are templated on TimerType, in order to avoid depending on a particular timer implementation. TimerType should support the following interface (modeled after the Teuchos::Time class):

  • Construction using a const std::string& or something convertible to that (to name the timer). Semantically, the constructor should not start the timer.
  • name(): Returns the name of the timer, as it was set in the constructor (it does not change the string).
  • start(bool reset=false): Returns nothing, starts the timer, resets it first if reset==true).
  • stop(): Returns a double-precision floating-point value, which is the number of seconds elapsed since calling start().
  • isRunning(): Returns a Boolean saying whether the timer is currently running. start() should make the timer start running, and stop() shoudl make it stop running.

TimerType need not be able to handle recursive calls, though this might be helpful. The intended use case is that start() and stop() wrap some timing loop, and the loop does not reference the timer at all. We include this concept check in all of our TSQR benchmark routines via

 verifyTimerConcept<TimerType>();

If TimerType does not satisfy this interface, that line of code will fail to compile. The compiler should give an informative error message about a missing method. verifyTimerConcept() also checks some semantic properties of TimerType.

Definition at line 78 of file Tsqr_verifyTimerConcept.hpp.

template<class Ordinal , class Scalar , class Generator >
static void TSQR::Test::generateStack ( Generator &  generator,
Matrix< Ordinal, Scalar > &  A_global,
const typename Teuchos::ScalarTraits< Scalar >::magnitudeType  singularValues[],
const int  numProcs,
const Ordinal  numCols 
) [static]

Generate a random "R stack" test problem on one MPI process.

Generate a (pseudo)random test problem consisting of numProcs different numRows by numCols upper triangular matrices, stacked vertically.

Parameters:
generator[in/out] (Pseudo)random number generator, that generates according to a normal(0,1) distribution.
A_global[out] Matrix to fill. Should be empty on input. Output will be on Proc 0 only. We will set dimensions, allocate, and fill.
singularValues[in] ncols singular values to use
numProcsNumber of (MPI) processes
numColsNumber of columns in the output matrix A_global

Definition at line 69 of file Tsqr_generateStack.hpp.

template<class Ordinal , class Scalar , class Generator >
void TSQR::Test::par_tsqr_test_problem ( Generator &  generator,
Matrix< Ordinal, Scalar > &  A_local,
Matrix< Ordinal, Scalar > &  A_global,
const Ordinal  ncols,
const Teuchos::RCP< MessengerBase< Scalar > > &  messenger 
)

Generate a random test problem for the distributed-memory part of TSQR.

Specifically, this routine generates an "R stack" test problem, where each (MPI) process has a square ncols by ncols upper triangular matrix A_local. TSQR is supposed to factor the distributed matrix formed by "stacking" the A_local matrices on top of each other, so that MPI Rank 0's matrix is on top, Rank 1's matrix is below that, and so on. (Ranks here are computed with respect to the given MessengerBase communicator wrapper.)

Parameters:
A_local[out] ncols by ncols upper triangular matrix (on each MPI process)
A_global[out] Empty on all procs but Proc 0, where it starts empty (not required, but this is more efficient) and gets resized here
ncols[in] Number of columns in the matrix to generate. Number of rows in the matrix will be (# MPI processes)*ncols.
generator[in/out] Normal(0,1) (pseudo)random number generator
messenger[in/out] MPI communicator object for Scalars

Definition at line 116 of file Tsqr_generateStack.hpp.

template<class MatrixViewType , class Generator >
void TSQR::Test::distributedTestProblem ( Generator &  generator,
MatrixViewType &  A_local,
MessengerBase< typename MatrixViewType::ordinal_type > *const  ordinalComm,
MessengerBase< typename MatrixViewType::scalar_type > *const  scalarComm 
)
Parameters:
generator[in/out] Proc 0 is the only MPI process that generates pseudorandom numbers. This allows us to use a sequential PRNG. Otherwise, we would have to use a parallel PRNG, in order to prevent correlations between numbers generated on different MPI processes. On processes other than Proc 0, generator is not touched.

Definition at line 65 of file Tsqr_TestSetup.hpp.

template<class NodeType >
TSQR::Test::getValidNodeParameters ( )

Return valid parameter list with default values.

The returned parameter list corresponds to the given NodeType (Kokkos Node type), and is meant to be the input argument of getNode().

template<class NodeType >
Teuchos::RCP<const NodeType> TSQR::Test::getNode ( const Teuchos::RCP< Teuchos::ParameterList > &  plist)

Return a Kokkos Node instance with the given parameters.

Parameters:
plist[in/out] Return value of getValidNodeParameters() for the given NodeType. This function reserves the right to modify the input parameter list (for example, to fill in any missing parameters with defaults). Do not rely on this behavior.

Definition at line 134 of file Tsqr_TestUtils.hpp.

template<class Ordinal , class Scalar , class Generator >
void TSQR::Test::verifyTsqr ( const std::string &  which,
const std::string &  scalarTypeName,
Generator &  generator,
const Ordinal  nrows_global,
const Ordinal  ncols,
const Teuchos::RCP< MessengerBase< Ordinal > > &  ordinalComm,
const Teuchos::RCP< MessengerBase< Scalar > > &  scalarComm,
const int  num_cores = 1,
const size_t  cache_size_hint = 0,
const bool  contiguousCacheBlocks,
const bool  printFieldNames,
const bool  human_readable = false,
const bool  b_debug = false 
)

Test and print to stdout the accuracy of parallel TSQR.

verifyTsqr

Parameters:
which[in] Valid values: "MpiTbbTSQR" (for TBB-parallel node-level TSQR underneath MPI-parallel TSQR), "MpiSeqTSQR" (for cache-blocked sequential node-level TSQR underneath MPI-parallel TSQR)
scalarTypeName[in] Name of the Scalar type
generator[in/out] Normal(0,1) (pseudo)random number generator. Only touched on MPI process 0. Used to generate random test matrices for the factorization.
nrows_global[in] Number of rows in the entire test matrix (over all processes) to generate. The matrix will be divided up in blocks of contiguous rows among the processes.
ncols[in] Number of columns in the test matrix to generate.
ordinalComm[in/out] Object for communicating Ordinal (integer index) objects among the processes
scalarComm[in/out] Object for communicating Scalar (matrix data) objects among the processes
num_cores[in] Number of cores to use per MPI process for Intel TBB parallelism within that process
cache_size_hint[in] Cache size hint (per core) in bytes. If zero, a sensible default is used.
contiguousCacheBlocks[in] Whether cache blocks should be stored contiguously
printFieldNames[in] Whether to print field names (only appliable if not human_readable)
human_readable[in] Whether output should be human readable, or machine parseable
b_debug[in] Whether to print debug output

Definition at line 199 of file Tsqr_TsqrTest.hpp.

template<class Ordinal , class Scalar , class Generator , class TimerType >
void TSQR::Test::benchmarkTsqr ( const std::string &  which,
const std::string &  scalarTypeName,
Generator &  generator,
const int  ntrials,
const Ordinal  nrows_global,
const Ordinal  ncols,
const Teuchos::RCP< MessengerBase< Ordinal > > &  ordinalComm,
const Teuchos::RCP< MessengerBase< Scalar > > &  scalarComm,
const Ordinal  num_cores,
const size_t  cache_size_hint,
const bool  contiguousCacheBlocks,
const bool  printFieldNames,
const bool  human_readable,
const bool  b_debug 
)

Benchmark parallel TSQR and report timings to stdout.

benchmarkTsqr Benchmark the MPI-parallel TSQR implementation specified by the "which" parameter (either with cache-blocked TSQR or TBB-parallel cache-blocked TSQR as the node-level implementation), for "ntrials" trials. Print the stdout the cumulative run time (in seconds) for all ntrials trials.

Parameters:
which[in] Valid values: "MpiTbbTSQR" (for TBB-parallel node-level TSQR underneath MPI-parallel TSQR), "MpiSeqTSQR" (for cache-blocked sequential node-level TSQR underneath MPI-parallel TSQR)
scalarTypeName[in] Name of the Scalar type
generator[in/out] Normal(0,1) (pseudo)random number generator. Only touched on MPI process 0. Used to generate random test matrices for the factorization.
ntrials[in] Number of trials to use in the benchmark. Reported timings are cumulative over all trials.
nrows_global[in] Number of rows in the entire test matrix (over all processes) to generate. The matrix will be divided up in blocks of contiguous rows among the processes.
ncols[in] Number of columns in the test matrix to generate.
ordinalComm[in/out] Object for communicating Ordinal (integer index) objects among the processes
scalarComm[in/out] Object for communicating Scalar (matrix data) objects among the processes
num_cores[in] Number of cores to use per MPI process for Intel TBB parallelism within that process
cache_size_hint[in] Cache block size (per core) in bytes. If zero, a sensible default is used.
contiguousCacheBlocks[in] Whether cache blocks should be stored contiguously
printFieldNames[in] Whether to print field names (only appliable if not human_readable)
human_readable[in] Whether output should be human readable, or machine parseable
b_debug[in] Whether to print debug output

Definition at line 584 of file Tsqr_TsqrTest.hpp.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends