Checkpointing Functions
Keywords: checkpointing functions syntax purpose reduce memory faster recording method constructor base advector name ax ay sparsity size_var option algo atom_fun clear restriction example

| Prev | Next |  |  |  |  |  |  |

Checkpointing Functions
Syntax
`checkpoint<Base> atom_fun(name, algo, ax, ay, sparsity)
sv = atom_fun.size_var()
atom_fun.option(option_value)
algo(ax, ay)
atom_fun(ax, ay)
checkpoint<Base>::clear()`
Purpose
Reduce Memory
You can reduce the size of the tape and memory required for AD by checkpointing functions of the form y = f ( x ) where f : B n → B m . The operation sequence representing f ( x ) cannot depend on the value of x .
Faster Recording
It may also reduce the time to make a recording the same function for different values of the independent variable. Note that the operation sequence for a recording that uses f ( x ) may depend on its independent variables.
Method
The `checkpoint` class is derived from `atomic_base` and makes this easy. It implements all the `atomic_base` virtual functions and hence its source code `cppad/local/checkpoint.hpp` provides an example implementation of atomic_base . The difference is that `checkpoint.hpp` uses AD instead of user provided derivatives.
constructor
The syntax for the checkpoint constructor is `
checkpoint<Base> atom_fun(name, algo, ax, ay)
`

1. This constructor cannot be called in parallel mode.
2. You cannot currently be recording `AD<Base>` operations when the constructor is called.
3. This object `atom_fun` must not be destructed for as long as any `ADFun<Base>` object uses its atomic operation.
4. This class is implemented as a derived class of atomic_base and hence some of its error message will refer to `atomic_base`.

Base
The type `Base` specifies the base type for AD operations.
ADVector
The type `ADVector` must be a simple vector class with elements of type `AD<Base>` .
name
This `checkpoint` constructor argument has prototype `
const char* name
` It is the name used for error reporting. The suggested value for `name` is `atom_fun` ; i.e., the same name as used for the object being constructed.
ax
This argument has prototype `
const ADVector& ax
` and size must be equal to `n` . It specifies vector x ∈ B n at which an `AD<Base>` version of y = f ( x ) is to be evaluated.
ay
This argument has prototype `
ADVector& ay
` Its input size must be equal to `m` and does not change. The input values of its elements do not matter. Upon return, it is an `AD<Base>` version of y = f ( x ) .
sparsity
This argument has prototype `
atomic_base<Base>::option_enum sparsity
` It specifies sparsity in the `atomic_base` constructor and must be either `atomic_base<Base>::pack_sparsity_enum` , `atomic_base<Base>::bool_sparsity_enum` , or `atomic_base<Base>::set_sparsity_enum` . This argument is optional and its default value is unspecified.
size_var
This `size_var` member function return value has prototype `
size_t sv
` It is the size_var for the `ADFun<Base>` object is used to store the operation sequence corresponding to `algo` .
option
The `option` syntax can be used to set the type of sparsity pattern used by `atom_fun` . This is an `atomic_base<Base>` function and its documentation can be found at atomic_option .
algo
The type of `algo` is arbitrary, except for the fact that the syntax `
algo(ax, ay)
` must evaluate the function y = f ( x ) using `AD<Base>` operations. In addition, we assume that the operation sequence does not depend on the value of `ax` .
atom_fun
Given `ax` it computes the corresponding value of `ay` using the operation sequence corresponding to `algo` . If `AD<Base>` operations are being recorded, it enters the computation as single operation in the recording see start recording . (Currently each use of `atom_fun` actually corresponds to `m+n+2` operations and creates `m` new variables, but this is not part of the CppAD specifications and my change.)
clear
The `atomic_base` class holds onto static work space in order to increase speed by avoiding system memory allocation calls. This call makes to work space available to for other uses by the same thread. This should be called when you are done using the user atomic functions for a specific value of `Base` .
Restriction
The `clear` routine cannot be called while in parallel execution mode.
Example
The file checkpoint.cpp contains an example and test of these operations. It returns true if it succeeds and false if it fails.

Input File: cppad/local/checkpoint.hpp