Running the Speed Test Program
Keywords: running the speed test program cppad uniform_01 syntax purpose package ad double profile correct seed option_list onetape optimize atomic memory sparsity options boolsparsity colpack correctness results n_sweep link functions

| Prev | Next |  |  |  |  |  |

Running the Speed Test Program
Syntax
`speed/package/speed_package test seed option_list`
Purpose
A version of this program runs the correctness tests or the speed tests for one AD package identified by `package` .
package
AD Package
The command line argument `package` specifies one of the AD package. The CppAD distribution comes with support for the following packages: adolc , cppad , fadbad , sacado . You can extend this program to include other package. Such an extension need not include all the tests. For example, link_sparse_hessian just returns `false` for the fadbad and sacado packages.
double
The value `package` can be `double` in which case the function values (instead of derivatives) are computed using double precision operations. This enables one to compare the speed of computing function values in `double` to the speed of the derivative computations. (It is often useful to divide the speed of the derivative computation by the speed of the function evaluation in `double`.)
profile
In the special case where `package` is `profile`, the CppAD package is compiled and run with profiling to aid in determining where it is spending most of its time.
test
It the argument `test` specifies which test to run and has the following possible values: correct , speed , det_minor , det_lu , mat_mul , ode , poly , sparse_hessian , sparse_jacobian . You can experiment with changing the implementation of a particular test for a particular package.
correct
If `test` is equal to `correct`, all of the correctness tests are run.
speed
If `test` is equal to `speed`, all of the speed tests are run.
seed
The command line argument `seed` is a positive integer. The random number simulator uniform_01 is initialized with the call `
uniform_01(seed)
` before any of the testing routines (listed above) are called.
option_list
This is a list of options that follow `seed` value. The order of the options does not matter and the list can be empty. Each option in the list, must be separate command line argument to the main program. The documentation below specifics how CppAD uses these options, see the examples in speed_adolc for how another package might uses these options.
onetape
If the option `onetape` is present, the symbol `

         extern bool global_onetape

` is true and otherwise it is false. If this external symbol is true, CppAD will use one taping of the operation sequence for all the repetitions of that speed test. Otherwise, the operation sequence will be retaped for each test repetition. `
` All of the tests, except det_lu , have a fixed operations sequence. The operation sequence for `det_lu` may be different for each repetition of the test because it depends on the matrix for which the determinant is being calculated. For this reason, the CppAD test cppad_det_lu.cpp returns false (indicating that the test not implemented) when `global_onetape` is true.
optimize
If the option `optimize` is present, the symbol `

         extern bool global_optimize

` is true and otherwise it is false. If this external symbol is true, CppAD will optimize the operation sequence before doing computations. If it is false, this optimization will not be done.
atomic
If the option `atomic` is present, the symbol `

         extern bool global_atomic

` is true and otherwise it is false. If this external symbol is true, CppAD will use its user defined atomic operation is used for the test. If no such atomic operation exists, and atomic is chosen, CppAD returns false for the test.
memory
If the option `memory` is present, the symbol `

         extern bool global_memory

` is true and otherwise it is false. If it is true, the CppAD hold_memory routine will be called by the main program before any of the tests are executed. This should make the CppAD `thread_alloc` allocator faster. If it is false, CppAD will used standard memory allocation.
Sparsity Options
The following options only apply to the sparse_jacobian and sparse_hessian tests. The other tests will ignore these options:
boolsparsity
If the option `boolsparsity` is present, the symbol `

         extern bool global_boolsparsity

` is true and otherwise it is false. If it is true, CppAD will use a vector of bool for its sparsity patterns. Otherwise it will use a vector of sets .
colpack
If the option `colpack` is present, the symbol `

         extern bool global_colpack

` is true and otherwise it is false. If this external symbol is true, CppAD will use colpack to do the coloring for its Otherwise, it will use it's own coloring algorithm.
Correctness Results
One, but not both, of the following two output lines `
package_test_optionlist_available = false
package_test_optionlist_ok = flag
` is generated for each correctness test where `package` and `test` are as above, `optionlist` are the options (in `option_list` ) separated by the underbar `_` character (whereas they are separated by spaces in `option_list` ), and `flag` is `true` or `false`.
Speed Results
For each speed test, corresponds to three lines of the following form are generated: `
package_test_optionlist_ok = flag
package_test_size = [ size_1, ..., size_n ]
package_test_rate = [ rate_1, ..., rate_n ]
` The values `package` , `test` , `optionlist` , and `flag` are as in the correctness results above. The values `size_1` , ..., `size_n` are the size arguments used for the corresponding tests. The values `rate_1` , ..., `rate_n` are the number of times per second that the corresponding size problem executed.
n_sweep
The sparse_jacobian and sparse_hessian tests has an extra output line with the following form `
package_sparse_test_n_sweep = [ n_sweep_1, ..., n_sweep_n ]
` were `test` is `jacobian` (`hessian`). The values `n_sweep_1` , ..., `n_sweep_n` are the number of sweeps (colors) used for each sparse Jacobian (Hessian) calculation; see `n_sweep` for sparse_jacobian and sparse_hessian .
Link Functions
Each package defines it's own version of one of the link functions listed below. Each of these functions links this main program to the corresponding test:

link_det_lu | Speed Testing Gradient of Determinant Using Lu Factorization
link_det_minor | Speed Testing Gradient of Determinant by Minor Expansion
link_mat_mul | Speed Testing Derivative of Matrix Multiply
link_ode | Speed Testing the Jacobian of Ode Solution
link_poly | Speed Testing Second Derivative of a Polynomial
link_sparse_hessian | Speed Testing Sparse Hessian
link_sparse_jacobian | Speed Testing Sparse Jacobian

Input File: speed/main.cpp