Tapenade versions history

TAPENADE versions history

From 3.15 (tag 3.15-v2, 15 Apr 2020) to 3.16 (tag 3.16-v0-1-g8a3876252, 9 Oct 2020)

Algorithms and differentiation functionalities:
  • Tapenade Developer Documentation for future contributions to the development of Tapenade.
Interaction with the end-user:
  • Tapenade is now distributed under MIT license.
  • New Tapenade User Documentation web site.
A selection of fixed bugs and missing stuff added:
  • Fixed missing differentiated intializations and missing messages.
  • Fixed adjoint of complex procedures (dcmplx, conjg, ...).
  • Fixed NullPointerException and other Java exception.

From 3.14 (r7259, 18 Jan 2019) to 3.15 (tag 3.15-v2, 15 Apr 2020)

Algorithms and differentiation functionalities:
  • Introducing OpenMP directives.
  • Improved mixed language differentiation.
  • Improved efficiency of the adjoint code.
Interaction with the end-user: A selection of fixed bugs and missing stuff added:
  • Several bugs fixed.

From version 3.13 (r6666, 27 Nov 2017) to version 3.14 (alpha, r7148, 9 Nov 2018)

Algorithms and differentiation functionalities:
  • Tapenade now accepts and differentiates codes that mix C and Fortran source files, both in tangent mode and in adjoint (aka reverse) mode. Tapenade understands the main interoperability primitives of Fortran 2003.
  • Tapenade now "targets" C++, in addition to C and Fortran. Writing "targets", we mean that we started the developments in this direction, but we are not there yet! At present, we can parse some simple C++ codes into Tapenade's internal representation. Even spitting back non-differentiated C++ source from this representation is still under development. But we can say we've started!
Interaction with the end-user:
  • By default, Tapenade now produces the differentiated code into a file architecture that mimics that of the original code. In other words, a code provided e.g. as four files myfile.f, myfile.f90, myfile.c, and myotherfile.c, will create differentiated files myfile_d.f, myfile_d.f90, myfile_d.c, and myotherfile_d.c. This was necessary as, in C, translation units have a semantic meaning. The previous default mechanism (every subroutine in a separate file) is deprecated but available with command-line option -splitoutputfiles. Conversely, command-line option -output still tells Tapenade to place all code in one single file (per language), although this may cause name conflicts in C.
  • Tapenade may have changed the order of sub-units recursively nested in produced code units (i.e. procedures, modules, classes...) or in the produced top-level files. The new order is in principle just as valid as the previous order was (sometimes better). The new order mimics more closely the order from the original code.
  • II-LOOPS generate IVDEP
  • DO-NOT-DIFF generates TGT-OF, FWD-OF, and BWD-OF markers in the generated source
  • -optim statictape ... (good for vector code)
  • Big changes in the adBuffer/adStack mechanism (provided in the ADFirstAidKit). The previous "LOOK" primitives disappear and are replaced by a more general mechanism for repeated access to the stack. This same mechanism is used in the adjoint of Fixed-Point loops.
A selection of fixed bugs and missing stuff added:
  • Onera (fixed-point)

From version 3.12 (r6212, 12 Oct 2016) to version 3.13 (r6666, 27 Nov 2017)

Algorithms and differentiation functionalities:
  • Significant progress on AD of mixed-language source (Fortran plus C). Successful tangent differentiation on a large application example (Calculix).
  • Improved treatment of the C notion of "translation unit", where global variables remain private inside their original source file.
  • Simplified architecture of the ADMM library for Adjoint Dynamic Memory Management. Tapenade-generated adjoint is modified accordingly. The idea is to move a part of this management back into the differentiated source, so that the library has fewer primitives and does not rely on other Tapenade mechanisms (e.g. adStack.c).
  • (not strictly speaking a part of Tapenade) Added to AMPI the differentiated primitives for communicators and for several collective communications. Due to some side-effects, non-blocking AMPI_Isend and AMPI_Irecv
  • need to be differentiated even when dealing with MPI_INT's (but this does not cause additional communication).
  • Tapenade-generated code increasingly uses utilities written in C ( adStack, AMPI, ADMM,...). Consequently, Tapenade tries to use the Fortran 2003 standardized primitives for interoperability with C.
Interaction with the end-user:
  • The syntax of our internal language IL has changed slightly for: procedure calls, variable declarations, and primitive types. This might affect you only if you use our "lib" file mechanism to express properties of external or intrinsic or black-box procedures. Please note that the "lib" files provided with Tapenade have been updated according to this change and you need not change them. They might serve as examples if the explanations below are unclear.
    • Primitive types are now first-class operators in IL (and "real" becomes "float"), so in your "lib" files, you should replace
      ident real with float() (with these parentheses!),
      ident complex with complex()
      ident integer with integer()
      ident character with character()
      ident boolean with boolean()
      This also implies that at each place where you use the string "real" to mean the type "real", for instance as a "metatype", you should rather use string "float" now.
    • Procedure calls now have an extra first child, that will eventually hold the object or class in case of method calls. For the time being, just add a new child none() if there is an operator "call" in your lib file (this may happen in the "derivative" part or for "inline" procedures).
    • Similarly, there is an extra first child to operator "varDeclaration", which may occur in your lib files for "inline" procedures.
  • Default suffixes of differentiated modules and types changed to _diff. Default suffix used for non-differentiated copies of procedures (when they need a new name) changed to _nodiff. Command-line options to retrieve the old naming conventions are: -tgtmodulename "_d" -adjmodulename "_b" -copyname "_c"
Fixed bugs:
  • Several bugs fixed, probably including the one(s) you reported. If not, please remind us!
  • Bug fix on nested loops with the $AD II-LOOP directive.
  • Some AMPI_Wait's could be wrongly considered dead code.
  • Bug fixes on C modifiers such as const or restrict
  • A bug fixed about Fortran assigned-goto's: assigned-goto destination labels could be lost

From version 3.10 (r5363, 9 Sep 2014) to version 3.12 (r6212, 12 Oct 2016)

Algorithms and differentiation functionalities:
  • Tapenade now uses the "Adjoinable MPI" library (AMPI) for adjoint differentiation of MPI-parallel source. Tapenade accepts input files that use the AMPI wrapper around MPI. The AMPI wrapper subroutines slightly differ from pure MPI in order to provide additional information needed by differentiation. The differentiated code calls special differentiated AMPI primitives that orchestrate message-passing of the adjoint variables.
  • Tapenade now has the option of specialization with respect to activity: a procedure may have several differentiated subroutines, each specialized for a particular activity pattern and therefore potentially more efficient than a single differentiated code that deals with the union of all possible activity patterns.
  • Tapenade now addresses the issues of adjoint differentiation of dynamic memory management in C, by using a separate library called ADMM. ADMM dynamically keeps track of allocated memory to maintain consistency of addresses across the adjoint code's pushpointer and poppointer primitives.
  • Tapenade can now differentiate a mixed-language source that combines C and Fortran source files. This an ongoing development, still at an experimental stage.
  • Diff-liveness analysis, which was available only for the adjoint mode, is now available in tangent mode too. The effect of Diff-liveness analysis is to remove from the differentiated code the instructions of the original code that are not necessary to compute the derivatives. For the moment, one has to explicitly use option -optim diffliveness to trigger diff-liveness in tangent mode.
Interaction with the end-user:
  • When differentiating C source, Tapenade now emits messages such as
    (AD15) Not sure how to initialize the derivative *Vd of type:REAL with instruction *Vd=0.0
    to designate places where it cannot detect whether a pointer actually stands for a full array. These messages request the end-user to check the differentiated code, and to patch it if necessary.
  • The -context option, introduced in version 3.6, is now better integrated with the debug modes -debugTGT and -debugADJ: in -debugXXX modes, the -context option automatically inserts the driver code needed for debugging.
  • The default size of pointers (important for PUSH/POP's) is now 8 instead of 4. Use option -p4 to remain with 4-bytes pointers.
  • New option -nbdirsmax N to generate differentiated code (in the vector mode) that uses size N as the size of the extra dimension of derivative variables. With this option, variable nbdirsmax is not used and need not be defined in DIFFSIZES.
Fixed bugs:
  • Several bugs fixed, probably including the one(s) you reported. If not, please remind us!
  • Some bugs fixed related to C cpp #include directives
  • Some bugs related to Fortran interface's

From version 3.8 (r4996, 25 Oct 2013) to version 3.10 (r5363, 9 Sep 2014)

Algorithms and differentiation functionalities:
  • Development and implementation of a specialized adjoint for fixed-point loops, from the seminal work of Bruce Christianson (Reverse accumulation and implicit functions, Optimization Methods and Software , vol 9 , no. 4 , pp. 307-322, 1998). See the FAQ for implementation and usage details.
Interaction with the end-user:
  • Definition and documentation of the API of the basic layer of Tapenade, containing source parsing, type-checking, internal representation, static data-flow analysis, and unparsing. This API is independent of AD. It has the form of a Java package.
Fixed bugs:
  • Several bugs fixed.

From version 3.7 (r4782, 21 Feb 2013) to version 3.8 (r4996, 25 Oct 2013)

Algorithms and differentiation functionalities:
  • if-expressions are now accepted for differentiation in adjoint mode too.
Interaction with the end-user:
  • New directives $AD DO-NOT-DIFF and $AD END-DO-NOT-DIFF to designate parts of the source where no differentiation must be performed, presumably because the end-user will insert specific code there.
  • New option -dumpcallgraph to dump a compact listing of the call graph into the dump file.
Fixed bugs:
  • Several bugs fixed.

From version 3.6 (r4159, 22 Sept 2011) to version 3.7 (r4782, 21 Feb 2013)

Algorithms and differentiation functionalities:
  • Tapenade now provides the so-called "vector" mode in adjoint mode too. Analogous to "vector tangent", this mode computes in one run the gradients for many different weightings of the output variables. This is triggered by option -multi
  • Tapenade now lets you deactivate almost all of its analyses and strategies meant to improve the differentiated code. The goal is to produce simpler and more robust differentiated code, then re-activate the strategies when they prove useful. This is triggered by option -nooptim optimizationName. Details will follow in the FAQ.
Interaction with the end-user:
  • New option -context continues analysis outside of the differentiated subtree, and produces a calling context around the differentiated code that tries to declare, allocate, and initialize the necessary differentiated data structures. Temporarily, the previous behavior is still accessible with option -oldContext.
  • Option -copyname "" to replace copied routine names FOO_CD or FOO_CB with simply FOO, thus forcing compile-time conflict with the original FOO.
  • New option -noisize replaces ISIZEnOFvarname variables with calls to Fortran90 SIZE() primitive.
  • New option -distinctNewVars to force Tapenade to give a unique name to each of the new variables it creates (e.g. variables introduced by splitting)
Fixed bugs:
  • Added many signatures of MPI procedures for C.
  • Switch cases with a default case that is not in the last position
  • Tried to behave better when a program declared as Fortran77 uses Fortran95 constructs.
  • Extensively tested the debug option -nooptim spareinit that turns off the postponing of diff reinitialization.
  • Debugs of the debug modes -debugTGT and -debugADJ
  • A nasty bug fixed in the adjoint of loops with extra exits: goto labels were poorly placed and sometimes wrong.

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

Algorithms and differentiation functionalities:
  • 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
Interaction with the end-user:
  • 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
Fixed bugs:
  • 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)

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • New user directives for an improved control of checkpointing: $AD BINOMIAL-CKP, $AD CHECKPOINT-START, and $AD CHECKPOINT-END.
A selection of fixed bugs and missing stuff added:
  • 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)

Algorithms and differentiation functionalities:
  • 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
Interaction with the end-user:
  • Clarified (hopefully) the meaning of "independent" and "dependent" variables. The banner added to differentiated subroutines gives details about the read-write status of derivatives.
A selection of fixed bugs and missing stuff added:
  • 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)

Interaction with the end-user:
  • 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.
A selection of fixed bugs and missing stuff added:
  • 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)

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • 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.
A selection of fixed bugs and missing stuff added:
  • 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)

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • Declarations of differentiated C global variables are put in a separate file GlobalDeclarations_?.c.
  • Slightly changed (improved?) the indentation/style of C regenerated code.
A selection of fixed bugs and missing stuff added:
  • 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)

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • 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.
A selection of fixed bugs and missing stuff added:
  • 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)

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • 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.
A selection of fixed bugs and missing stuff added:
  • 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)

Complete paper documentation available for version 2.1:
INRIA Technical Report #0300.

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • 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.
A selection of fixed bugs and missing stuff added:
  • 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)

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • 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...
A selection of fixed bugs and missing stuff added:
  • 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)

Algorithms and differentiation functionalities:
  • 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...
Interaction with the end-user:
  • 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 HTML 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

Algorithms and differentiation functionalities:
  • 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
Interaction with the end-user:
  • The X-windows graphical interface is abandoned.

O∂yssée 1.6

Algorithms and differentiation functionalities:
  • 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.
Interaction with the end-user:
  • 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.