How to use a global tape

[bradbell]

The bash script below:

1. clones the xad repsoitory into xad.git
2. installs xad into xad.git/build/prefix
3. creates the my_test.cpp example
4. compiles and runs the example

See the comments at the top of the script that describe the problem.

my_script.sh

#! /usr/bin/env bash
set -e -u
# -----------------------------------------------------------------------------
# If I execute this script I get:
# terminate called after throwing an instance of 'xad::OutOfRange'
# what():  given derivative slot is out of range - did you register the outputs?
# ./my_test.sh: line 133: 105089 Aborted             (core dumped) ./my_test
# my_test.sh: Error
#
# if I change '# define M 1' to '# define M 0' I get my_test.sh: OK
# -----------------------------------------------------------------------------
#
# xad.git
if [ ! -e xad.git ] ; then
   git clone https://github.com/auto-differentiation/xad.git xad.git
fi
cd xad.git
#
# xad.git/build
if [ ! -e build ] ; then
   mkdir build
fi
cd build
#
# xad.git/build/CMakeCache.txt
if [ -e CMakeCache.txt ]; then
   rm CMakeCache.txt
fi
#
# prefix
prefix=$(pwd)/prefix
#
# xad.git/build/cmake.out
cmake -D CMAKE_INSTALL_PREFIX="$prefix" -D CMAKE_BUILD_TYPE=debug \
   .. >& cmake.out
#
# xad.git/build/install.out
echo 'make install >& xad.git/build/install.out'
make install >& install.out
#
# library_list
library_list=$(find $prefix -name '*.a')
#
# xad.git/build/my_test.cpp
cat << EOF > my_test.cpp
# include <iostream>
# include <XAD/XAD.hpp>
//
# define M 1
# define N 100
//
// f
template <class T> T f(const T& x0)
{ return x0 * x0; }
//
// mode, tape_type, AD
typedef xad::adj<double>  mode;
typedef mode::tape_type   tape_type;
typedef mode::active_type AD;
//
// ax, tape
std::vector<AD> ax(N);
tape_type tape;
//
// test
bool test(void)
{  //
   // x0
   double x0 = 3.0;
   //
   // tape
   tape.clearAll();
   //
   // ax
   for(size_t i = 0; i < N; ++i)
      ax[i] = x0;
   //
   // tape, ax
   for(size_t i = 0; i < N; ++i)
      tape.registerInput(ax[i]);
   //
   // start recording derivatives
   tape.newRecording();
   //
   // ay
   AD ay = f(ax[M]);
   //
   // register and seed adjoint of output
   tape.registerOutput(ay);
   derivative(ay) = 1.0;
   //
   // compute all other adjoints
   tape.computeAdjoints();
   //
   // ok
   bool ok = derivative(ax[M]) == 2 * x0;
   //
   return ok;
}
int main(void)
{  bool ok = true;  
   ok &= test();
   ok &= test();
   if( ok )
      return 0;
   return 1;
}
EOF
#
# my_test
g++ -g -I $prefix/include -o my_test my_test.cpp  $library_list
if ./my_test ; then
   echo 'my_test.sh: OK'
   exit 0
fi
echo 'my_test.sh: Error'
exit 1

[auto-differentiation-dev]

The issue you are facing is that that variables in the vector ax keep their tape slot information after the tape is cleared. When you call registerInput for an active variable, it assigns a tape slot for it and stores it. This information is not cleared when you clear the tape, and re-assigning the value does not change the tape registration slot.

To fix your issue, you should clear your vector of inputs when you clear the tape and re-create the AD variables. Then it will work for any M. Note that clearing std::vector does not deallocate memory, so the performance overhead is minimal.