Prev Next

@(@\newcommand{\W}[1]{ \; #1 \; } \newcommand{\R}[1]{ {\rm #1} } \newcommand{\B}[1]{ {\bf #1} } \newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} } \newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} } \newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} } \newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }@)@This is cppad-20221105 documentation. Here is a link to its current documentation .
Running the Speed Test Program

speed/package/speed_package test seed option_list

A version of this program runs the correctness tests or the speed tests for one AD package identified by 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 , cppadcg . You can extend this program to include other package; see speed_xpackage .

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.)

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.

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.

If test is equal to correct, all of the correctness tests are run.

If test is equal to speed, all of the speed tests are run.

The command line argument seed is an unsigned integer (all its characters are between 0 and 9). The random number simulator uniform_01 is initialized with the call
before any of the testing routines (listed above) are called.

Global Options
This global variable has prototype

    extern std::map<std::string, bool> global_option;
The syntax
has the value true, if option is present, and false otherwise. This is true for each option that follows seed . The order of the options does not matter and the list can be empty. Each option, is be a separate command line argument to the main program. The documentation below specifics how the speed_cppad program uses these options. It is the intention that other packages use each option in a similar way or make it invalid. The implementation of each test should check that the option setting are valid for that test and if not it should return false; for example, see the source code for adolc_sparse_hessian.cpp .

If this option is present, speed_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 the same operation sequence for each repetition. The operation sequence for det_lu may be different because it depends on the matrix for which the determinant is being calculated. For this reason, cppad_det_lu.cpp returns false, to indicate that the test not implemented, when global_onetape is true.

This option is special because individual CppAD speed tests need not do anything different if this option is true or false. If the memory option is present, the CppAD hold_memory routine will be called by the speed test main program before any of the tests are executed This should make the CppAD thread_alloc allocator faster. If it is not present, CppAD will used standard memory allocation. Another package might use this option for a different memory allocation method.

If this option is present, CppAD will optimize the operation sequence before doing computations. If it is false, this optimization will not be done. Note that this option is usually slower unless it is combined with the onetape option.

If this option is present, CppAD will use a user defined atomic operation is used for the test. So far, CppAD has only implemented the mat_mul test as an atomic operation.

If this option is present, speed_cppad will compute hessians as the Jacobian of the gradient. This is accomplished using multiple levels of AD. So far, CppAD has only implemented the sparse_hessian test in this manner.

If this option is present, speed_cppad will compute sparse Jacobians using subgraphs. The CppAD sparse_jacobian test is implemented for this option. In addition, the CppAD sparse_hessian test is implemented for this option when hes2jac is present.

Sparsity Options
The following options only apply to the sparse_jacobian and sparse_hessian tests. The other tests return false when any of these options are present.

If this option is present, CppAD will use a vectors of bool to compute sparsity patterns. Otherwise CppAD will use vectors of sets .

If this option is present, CppAD will use reverse mode for to compute sparsity patterns. Otherwise CppAD will use forward mode.

If this option is present, CppAD will use subgraphs to compute sparsity patterns. If boolsparsity, revsparsity, or colpack is also present, the CppAD speed tests will return false; i.e., these options are not supported by subgraph_sparsity .

If this option is present, CppAD will use colpack to do the coloring. Otherwise, it will use it's own coloring algorithm.

If this option is present, CppAD will use a symmetric coloring method for computing Hessian sparsity patterns. Otherwise, it will use a general coloring method. The CppAD sparse_hessian test is implemented for this option.

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
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.

The sparse_jacobian and sparse_hessian tests has an extra output line with the following form
package_sparse_test_n_color = [ n_color_1...n_color_n ]
were test is jacobian (hessian). The values n_color_1 , ..., n_color_n are the number of colors used for each sparse Jacobian (Hessian) calculation; see n_color for sparse_jac and n_sweep for sparse_hessian .

Link Routines
Each package defines it's own version of one of the link_routines listed below. Each of these routines 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 Link to Speed Test Sparse Hessian
link_sparse_jacobian Speed Testing Sparse Jacobians

Input File: speed/main.cpp