TAPENADE versions history Last modified: Thu Jan 5 14:07:07 CET 2012 by the developers of Tapenade

Ongoing developments added into the present downloadable version (-r4159) :

From version 3.5 (r3618, 22 Dec 2010) to version 3.6 (r4159, 22 Sept 2011)

• Prototype native treatment of MPI communication calls. MPI calls are detected and are correctly understood by data-flow analyses, such as activity analysis. Differentiation works only on relatively simple cases, and only in tangent mode so far. Ongoing developement: bug reports expected !
• Fortran95 ALLOCATE and DEALLOCATE are now represented internally in the same way as C malloc and free. They are differentiated accordingly that is, in a way that still needs improvements especially in the adjoint mode.
• Copied, non-differentiated procedures (with a name often ending in _CD or _CB) that (de)allocate memory for variables that will be differentiated, now also (de)allocate memory for the differentiated variable, even when the procedure is not called by the differentiated part, i.e. is outside the call tree of the differentiation root procedures. The interest is to let the end-user call the copied procedure to prepare the context before calling the differentiated root procedures, and clean up afterwards. cf FAQ
• New In-Out analysis, slightly more accurate

• Introduced a new, hopefully simpler, mechanism to validate/debug tangent and adjoint code generated by Tapenade. Requires fewer manipulations to create the validation testbed, and tests the complete adjoint code in a single pass. The previous validation mechanism is now obsolete and will disappear soon. The new mechanism (see some documentation here) is triggered by command-line options "-traceTGT" and "-traceADJ".
• Added command-line option "-linelength nn" to allow the Fortran90 parser to parse lines that are longer than the 132 chars limit from the standard.
• Added command-line option "-nooptim difftypes" to tell Tapenade not to strip passive components out of differentiated structured data types.
• Added command-line option "-msginfile" to tell Tapenade to place warning and error messages at the corresponding place directly inside the generated programs.
• Refined the "-diffvarname", "-difffuncname", and "-copyname" command-line options to let you specify the new name as an extension before, or after the source name (or both). Examples: "-diffvarname g_%" or "-difffuncname HEAD%TL", where the "%" sign represents the original name.
• Simplification of the *Lib files. Now you can move every AD-specific information into your GeneralLib and forget about your ADLib.
• The syntax of the *Lib files has changed in the In-Out part: entries R, NR, W, NW are deprecated and replaced with NotReadNotWritten, ReadNotWritten, NotReadThenWritten, ReadThenWritten with a modified meaning. See the related FAQ section.
• When possible, unknown sizes such as "ISIZE1OFtmp" have been renamed into something more useful, such as "ISIZE1OFvar_component"
• In the html display of the differentiation results, the call graph contains more information.
• The banner of differentiated head procedures now mentions used differentiated pointers.
• Detection of variables used before initialized has been improved, and warning messages refined

• Improved accuracy in matching modified types such as REAL*8, REAL_dp, or REAL(kind=dp)
• Fixed several bugs in the matching of a call to an interface and a specific subroutine in the interface.
• Reverse differentiation was mostly wrong in the case of C arrays. It's getting better now. In particular push...array() and pop...array() are used when appropriate.
• Fixed several bugs related to structured types, especially for the Fortran90 global assignment between two structured variables. Caution: multi-dir tangent mode may still produce bad code in this case. Also fixed some spurious reinitializations of derivatives around procedure calls, again for structured variables and pointed values.
• Differentiation of ALLOCATE in multi-directional mode.
• Removed unmotivated type-check error messages about array sections.
• Fixed wrong differentiated code around IO calls that raised Tapenade internal error "wrong flow graph structure after block ..."
• Removed some faulty "INTENT" declarations in reverse AD of Fortran90 source. On the other hand, "OPTIONAL" declarations are better propagated to the derivative variables.
• Added a forgotten construct of Fortran90: pointer initialization with NULL() upon declaration.
• Very long lines or comments or identifiers were not cut correctly and comments on long lines were not placed well.
• Removed spurious # signs that appeared in the differentiated code.
• Fixed a few infinite looping in Tapenade on pointer and activity analysis of recursive programs or types.
• Fixed a Java null-pointer exception occurring when making USE of a module with several renamings.

From version 3.4 (r3375, 10 Feb 2010) to version 3.5 (r3618, 22 Dec 2010)

• Optimal binomial checkpointing (Griewank-Walther algorithm) available, triggered by directive $AD BINOMIAL-CKP. Details here
• It is now possible to force checkpointing of a fragment of a procedure, using directives $AD CHECKPOINT-START and $AD CHECKPOINT-END. Details here
• Modified the PUSH/POP mechanism so that controls are stored only as a small number of bits (typically only 1)
• Static data-flow analysis and tangent differentiation extended for message-passing-parallel programs. Still experimental.
• Fortran90 WHERE statements with the same test are now merged whenever possible.
• In more cases, Tapenade is able to regenerate an #include statement rather than inlining its contents.

• New user directives for an improved control of checkpointing: $AD BINOMIAL-CKP, $AD CHECKPOINT-START, and $AD CHECKPOINT-END.

• Indices in C arrays start at 0 instead of 1
• Better reverse differentiation of i++ or j--
• Several bugs fixed for differentiation of Fortran90 array notation involving SUM and MASK, especially in reverse AD.
• Better differentiation of those C for loops that really are Fortran DO loops.
• Added an initialization of derivative arrays in tangent mode. Surprisingly, this bug has been fixed in reverse mode long ago!
• Removed some wrong reinitializations of derivatives before calls. This happened for parameters allocated or accessed through a pointer.

From version 3.3 (alpha, r3163, 25 Sep 2009) to version 3.4 (r3375, 10 Feb 2010)

• New mechanism to replace some PUSH/POP's by cheap recomputation. Can be disabled with option: -nooptim recomputeintermediates
• New adBuffer.c for reverse mode in C, plus adBuffer.h and adStack.h

• Clarified (hopefully) the meaning of "independent" and "dependent" variables. The banner added to differentiated subroutines gives details about the read-write status of derivatives.

• In multi-directional mode, the "directions" dimension is pushed towards the leaves of structured types.
• Several bugs fixed, related to pointers and allocation in tangent mode.
• Removed some useless PUSH/POP's around II-LOOPs
• Fixed syntax of double immediates (from 1D0 to 1.D0)
• Fixed differentiation of USE ... ONLY with type names
• A serious bug fixed in the regenerated nested if-then-else's in C.

From version 3.2 (alpha, r3024, 18 Jun 2009) to version 3.3 (alpha, r3163, 25 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 Fortran90 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 Fortran90-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.