TAPENADE versions history Last modified: Wed Sep 30 15:22:52 CEST 2009 by the developers of Tapenade

From version 3.2 (alpha, r3024, 18 Jun 2009) to version 3.3 (alpha, r3173, 29 Sep 2009)

• Multiple include paths are now possible: one can put several "-I" options in the command line.
• New warning message AD08 added, when the reverse differentiated code needs to access a hidden variable.

• All comments added by Tapenade into C now use the ANSI syntax /* ... */
• Fixed bug of inverted arguments in statement-function calls.
• Cleaned up management of F90 use declarations with only and renamings.
• Fixed bug about reverse differentiation of C code with multiple return statements.
• Correct differentiation of /= and &= operators of C.

From version 3.1 (alpha, r2754, 9 Jan 2009) to version 3.2 (alpha, r3024, 18 Jun 2009)

• Reverse mode deals with C local declarations in local scopes.
• Better Reverse differentiation of C "for" loops, Those that behave like a FORTRAN "do" give better code.
• Extra dimensions coming from the vector mode are better placed in C.

• There are more (nearly-)copies of the original subroutines in the differentiated code. They appear in general with a new name obtained by appending "_c". This happens e.g. in FORTRAN90 when a non-differentiated subroutine USE's a differentiated MODULE.

• For C, TAPENADE understands identification of boolean with int.
• C arrays, which are indeed pointers, are correctly differentiated.
• Type-Checking has fewer unnecessary warnings in the case of C.
• FORTRAN90 "INTERFACE" declarations are better differentiated.
• Fixed a bug in the expansion of -= C operator
• C IO subroutines, from stdio.h do not call for PUSH/POP of their internal state variables
• SWITCH CASEs with no break statement are handled correctly in most cases, even in reverse mode, except in a special case that causes a warning message.

From version 3.0 (alpha, r2551, 23 Jul 2008) to version 3.1 (alpha, r2754, 9 Jan 2009)

• A correct reverse differentiation of Call-by-Value arguments.
• Reverse-mode Tapenade can now PUSH and POP elements of records separately. Tapenade also deals separately with pointer destinations and pointer addresses, using the new PUSHPOINTER and POPPOINTER.

• Declarations of differentiated C global variables are put in a separate file GlobalDeclarations_?.c.
• Slightly changed (improved?) the indentation/style of C regenerated code.

• RETURN statements are handled uniformly, regardless of Fortran or C. Same thing for SWITCH/CASE constructs. Problem remains for reverse AD of CASE's with no break statement.
• Bugs fixed for the differentiation of named/reordered arguments (e.g. in Fortran90).
• Bugs fixed for the differentiation of the "ONLY" and renaming clauses in Fortran90 USE's.

From version 2.2 (r1121, 22 May 2006) to version 3.0 (alpha, r2551, 23 Jul 2008)

• Tapenade now handles C source programs in addition to Fortran.
• Specific differentiation strategy for call-by-value arguments.
• The new pragma C$AD II-LOOP allows the end-user to designate loops with Independent Iterations, for which Tapenade uses a sophisticated strategy in reverse mode. Details here
• All internal analyses and transformations now consider each field of a record independently from the others, for fewer PUSH and POP.
• An embryo of an array index analysis allows Tapenade to perform better analyses on loops with regular array accesses.
• The forward sweep of the reverse mode can now contain "differentiated" statements, dealing with pointer manipulation.

• Command-line arguments -head "foo(y2 y3)/(x3) bar(y1)/x1 x4)" allows the end-user to designate several differentiation heads together.
• New command-line option available to ask Tapenade to create a separate piece of code that saves and restores the complete state needed to run a subroutine. This can be useful, for instance for validation of the differentiated code.
• A set of options help profile the performances of reverse differentiated programs.

• The declarations of the differentiated program now look more like the declarations of the original program, preserving style and comments.
• In many cases, Tapenade is now able to reinstall the "include" directives back into the differentiated programs.
• Several Fortran95 constructs are better differentiated such as: selective USE with ONLY and renamings, interface declarations, optional call arguments, memory allocation and pointer assignments in reverse mode, cycling data structures, masks in array statements...
• Improved an inefficient algorithm that made differentiation very slow (quadratic complexity!) on very long basic blocks.

From version 2.1 (r250, 25 Jan 2005) to version 2.2 (r1121, 22 May 2006)

• For procedure calls in the reverse mode of AD, Tapenade now gives the choice between the "joint" mode that existed previously, and the "split" mode that does no checkpointing for a particular call. Deactivation of checkpointing may yield huge performance improvements of the differentiated code.
• Static analysis of pointer destinations, plus differentiation in tangent mode of programs that use pointers. This part is relatively new, still in intensive debug phase.
• Fundamental improvements for the differentiation of complex statements that use array notation, combined with SUM and MASK intrinsics.
• New extension to the tangent mode (-dV) that evaluates the interval of differentiability around the current input state.
• In-Out data-flow analysis now detects variables used before initialized.
• Snapshots for checkpointing in the reverse mode are now made smaller.

• New C$AD NOCHECKPOINT directive to deactivate checkpointing on selected procedure call sites.
• Improved support for the process of validating differentiated programs. Support for the divided-differences test and for the dot-product test, with fewer manipulations required from the end-user and more manipulations automated by Tapenade. See the FAQ on validation.
• Tapenade command line now allows mixing filenames and options.
• Added a message to tell when a dependent or independent variable given by the user was removed because it is actually found not active by activity analysis.

• Procedures with a variable number of arguments and procedure calls with named arguments are now handled.
• When comments or declaration statements are too long, they are split in several comments or declarations, because some compilers couldn't handle them.
• Built-in derivatives for TANH fixed.
• Differentiation of an Fortran95 elemental intrinsic function must produce a subroutine

From version 2.0 (Oct 2002) to version 2.1 (r250, 25 Jan 2005)

• Differentiation Fortran95, including modules, interfaces, user-defined types, vector notation, overloaded arithmetic operations,... Sorry, pointers and memory allocation are for next version !
• In the reverse mode, large expressions are automatically split to reduce repeated computation of the same sub-expression.
• In the reverse mode, all statements that were useful for the original program, but are not necessary to compute the derivatives (known as "dead adjoint code") are automatically removed, and the associated tape is reduced consequently.
• Reverse differentiation left manu empty control structures (if's and do's). These empty control structures are now removed.
• New internal implementation of the PUSH/POP mechanism , which is faster because Fortran calls C far less frequently.
• The snapshots are smaller. A snapshot stores the value of all variables needed to restore the context before calling a subroutine twice. Snapshots are essential to checkpointing. They are now smaller because only variables that are used by the subroutine and modified in the enclosing subroutine need be stored.
• For the strange cases where INTEGER's are used to store REAL's, there is a special mechanism to "differentiate" these INTEGER's.
• All internal analyses now work correctly on recursive programs.
• Speed improvement on the internal data-flow analyses makes differentiation time even shorter.

• TAPENADE can now be installed under Windows.
• When called from the command line without any arguments, TAPENADE starts with a graphical user interface.
• The set of options is extended to describe the target architecture and to control some of TAPENADE's code optimizations.
• Additional messages from TAPENADE's static data-flow analyses. Messages have been rewritten and renumbered according to the TAPENADE user's guide
• Better messages when parsing erroneous *GeneralLib and *ADLib specification files for black-box routines.
• End-user can specify types of external or library procedures, specifying that some type may be arbitrary, or else must be equal to another arbitrary type. e.g. one can tell that F(x,y) can accept any type for x and y, provided it is the same type.

• Declarations of strings and arrays of strings used a wrong syntax.
• Some missing initializations added for the reverse mode for natural loops (loops with goto's). Several other bugs fixed about insufficient initialization of derivative variables.
• Aliasing inside instructions in reverse mode: instructions such as
  a(i) = 2*a(j)
  are split, introducing a temporary variable, because reverse differentiation must absolutely tell whether the two references to a are the same address or not.
• Expressions such as EXP(t)/t were differentiated wrong!
• Better differentiation, though still imperfect, in the case of a function passed as an argument.

From version 1.0 (alpha, Jan 2002) to version 2.0 (Oct 2002)

• For all modes of A.D., The previous version did not take into account the list of output variables whose derivatives are requested. All output variables were systematically differentiated. This bug is now fixed: fewer variables are now differentiated and generated files are smaller.
• Completely redefined mechanism for (re-)initialization to zero of derivative variables.
• New multi-directional forward mode for A.D.: The differentiated program computes derivatives for many directions in the input space. Differentiated instructions become loops. These loops are automatically gathered whenever possible, thanks to data-dependency analysis. This vastly reduces the cost of loop overhead. This is analogous to ADIFOR's vector mode.
• In the reverse mode, generate better code for subroutines with alternate exits, return's and stop's, loops with alternate entries/exits, multiple labels, poorly nested if's...
• I-O statements are now differentiated more correctly: derivatives of overwritten variables are reset to zero. A message warns the user when a potentially active variable may loose its derivative across an I-O instruction.
• Arithmetic simplifications of differentiated expressions. Better differentiation of "square root". Some simplifications made on generated structured statements, but some remain to be done.

• Improved differentiation of programs that use externally defined routines (libraries...): user can now specify the behavior of these external routines in a special configuration file. A.D. uses this file to create a better, more efficient differentiated program.
• Added links between the error and warning messages and the code: anchors go in both directions between an error marker in the displayed source and the message text.
• Graphical display of the program's call graph, and of each routine's flow graph. This is just a toy, available only in the dowloaded version.
• Improved the indentation choices for generated files
• The user now can specify the suffixes appended to derivative variables and routines. Following a suggestion from Andreas Griewank, the default suffixes are now:
  in forward mode,"d" for variables and "_D" for routines ("d" stands for "dot" or "direct"), and
  in reverse mode, "b" for variables and "_B" for routines ("b" stands for "bar" or "backwards").
• New mechanism requesting help from the user, when necessary: to provide the size of a dynamic derivative array, or to provide the needed derivatives of external routines.
• Fewer unjustified warning messages.
• Additional warning mesages about aliasing, variables not initialized, useless code...

• Added definition of some missing PUSH/POP subroutines for the reverse mode.
• Additional features of languages are now supported: switch/case construct, vectorial notation, record or derived data structures, complex constants.
• Many bugs fixed, for example: handling dead code, handling files with incorrect or duplicate declarations, handling F90-style declarations, bugs on hollerith and long strings, type-checking of characters and strings, type-checking of data, declarations of external functions, misplaced declarations of constants

From O∂yssée 1.7 to Tapenade 1.0 (alpha, Jan 2002)

• All of FORTRAN77 standard accepted, plus some extensions.
• Internal representation of programs is more powerful, with call-graphs, flow-graphs, basic blocks, and data-dependence graphs.
• Preliminary analysis of programs include syntax checkings, type checking, in-out analysis
• Dependency analysis for differentiation detects not only variables that depend on independent inputs, but also variables that influence dependent outputs. Only the intersection of those two sets need be differentiated.
• Complexity of dependency analysis is dramatically reduced (3 hours down to 3 minutes!), thanks to a new internal representation of variables.
• No more restriction on COMMON and EQUIVALENCE. They are correctly read, analyzed and differentiated, even when arrays and variables are equivalenced or when commons do not have the same declarations in different subroutines.
• The inversion of the control, in the reverse mode, is done on the Flow Graph. This gives a better, more readable transformed source, that the compiler can compile better. The generated code is not "flattened" as by O∂yssée 1.7. It is now user-readable, and keeps a structure similar to the original code (nested loops and tests), even when the original code contains jumps (GOTO's) or other unstructured statements.
• Derivative instructions in reverse mode are gathered whenever possible, thanks to data-dependency analysis.
• The reverse mode uses the TBR analysis (validated on O∂yssée 1.7). It finds variables which, although they are overwritten during the forward sweep, need not be saved because they will not be used during the reverse sweep.
• New storage strategy for the reverse mode, named the global trajectory. This stores intermediate values on an external stack rather than on static arrays that thad to be dimensioned by hand by the user of O∂yssée
• Snapshots in the reverse mode are smaller, because they use In-Out analysis to find out variables that are really necessary for duplicate execution of the checkpointed piece of code.
• This new reverse mode is still slightly experimental in version 1.0 alpha, and encounters problems on some of our test codes...

• Error and warning messages issued by the preliminary analyses of programs, about syntax, declarations, types, subroutine calls, globals and COMMON's, usage of variables...
• Available as a web server, with a XHTML user interface. No need to install! Colors highlights in the source and differentiated files. Anchor mechanism for correspondence between source and differentiated files. Basic display of the call-graph.
• Command-line version, installable locally: available for Linux and SunOS.

From O∂yssée 1.6 to O∂yssée 1.7

• A new reverse mode tactic, that accepts reverse differentiation of files with jumps and GOTO's. This flattens the reverse sweep as a very long list of basic blocks, with an special control loop around. Resulting code is not very readable.
• In reverse mode, experimental implementation of Andreas Griewank's checkpointing scheme "treeverse", for loops with a fixed number of iterations.
• Support for programs calling external routines: the end-user can provide the differentiable dependences between the inputs and the outputs. This is used for a better differentiation
• The experimental Jacobian mode is not maintained any more

• The X-windows graphical interface is abandoned.

O∂yssée 1.6

• Accepts most of the Fortran 77 standard.
• Automatic Differentiation in forward (tangent) mode.
• Automatic Differentiation in reverse (adjoint) mode.
• Reverse mode checkpointing provided automatically at the level of subroutine calls.
• Experimental Differentiation in Jacobian mode.

• Interactive use, with a special-purpose command language.
• Command-line invocation, with a batch file
• X-windows graphical interface, showing the Call Graph and the generated files.