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}} }@)@

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

uniform_01(*seed*)

before any of the testing routines (listed above) are called.
This global variable has prototype

The syntaxexternstd::map<std::string, bool> global_option;

global_option["*option*"]

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

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

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

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

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.

hes2jac

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.

subgraph

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

boolsparsity

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

revsparsity

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

subsparsity

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

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

symmetric

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.

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`

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

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