Merge lp:~simon-funke/libadjoint/online_revolve into lp:~libadjoint/libadjoint/libadjoint_python

[Simon Funke]

Second attempt for the merge request:

- Removed var_data linked list from the adjointer. Instead the uthash iteration feature is used to loop over variables.
- Instead of providing the filename to the read/write/delete cb, I now pass in the variable and let the user decide which naming convention to use. For that I also needed to introduce a
- New callback adj_vec_delete.

=== modified file 'doc/manual/annotation.aux'
--- doc/manual/annotation.aux	2011-08-09 10:52:22 +0000
+++ doc/manual/annotation.aux	2012-01-18 15:51:24 +0000
@@ -6,16 +6,18 @@
 \@writefile{lot}{\contentsline {xchapter}{Annotating forward models}{7}{chapter.2}}
 \@writefile{toc}{\contentsline {section}{\numberline {2.1}A simple example}{8}{section.2.1}}
 \newlabel{sec:examples}{{2.1}{8}{A simple example\relax }{section.2.1}{}}
-\@writefile{toc}{\contentsline {section}{\numberline {2.2}Existing model code}{8}{section.2.2}}
-\@writefile{toc}{\contentsline {section}{\numberline {2.3}Annotating the model}{8}{section.2.3}}
-\newlabel{api:adj_timestep_set_times}{{2.3.1}{8}{\texttt {adj_timestep_set_times}\label {api:adj_timestep_set_times}\relax }{subsection.2.3.1}{}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.3.1}\texttt  {adj_timestep_set_times}}{8}{subsection.2.3.1}}
-\newlabel{api:adj_timestep_set_functional_dependencies}{{2.3.2}{8}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{subsection.2.3.2}{}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.3.2}\texttt  {adj_timestep_set_functional_dependencies}}{8}{subsection.2.3.2}}
-\newlabel{eq:functional_as_sum}{{2.1}{8}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.3.1}{}}
-\newlabel{eq:ex_functional1}{{2.2}{9}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.3.2}{}}
-\newlabel{eq:ex_functional2}{{2.3}{9}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.3.3}{}}
-\newlabel{eq:ex_functional3}{{2.4}{9}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.3.4}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {2.2}A nonlinear example}{8}{section.2.2}}
+\newlabel{sec:examples}{{2.2}{8}{A nonlinear example\relax }{section.2.2}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {2.3}Existing model code}{8}{section.2.3}}
+\@writefile{toc}{\contentsline {section}{\numberline {2.4}Annotating the model}{8}{section.2.4}}
+\newlabel{api:adj_timestep_set_times}{{2.4.1}{8}{\texttt {adj_timestep_set_times}\label {api:adj_timestep_set_times}\relax }{subsection.2.4.1}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.4.1}\texttt  {adj_timestep_set_times}}{8}{subsection.2.4.1}}
+\newlabel{api:adj_timestep_set_functional_dependencies}{{2.4.2}{8}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{subsection.2.4.2}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.4.2}\texttt  {adj_timestep_set_functional_dependencies}}{8}{subsection.2.4.2}}
+\newlabel{eq:functional_as_sum}{{2.1}{9}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.4.1}{}}
+\newlabel{eq:ex_functional1}{{2.2}{9}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.4.2}{}}
+\newlabel{eq:ex_functional2}{{2.3}{9}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.4.3}{}}
+\newlabel{eq:ex_functional3}{{2.4}{9}{\texttt {adj_timestep_set_functional_dependencies}\label {api:adj_timestep_set_functional_dependencies}\relax }{equation.2.4.4}{}}
 \@setckpt{annotation}{
 \setcounter{page}{10}
 \setcounter{equation}{6}
@@ -27,7 +29,7 @@
 \setcounter{mpfootnote}{0}
 \setcounter{part}{0}
 \setcounter{chapter}{2}
-\setcounter{section}{3}
+\setcounter{section}{4}
 \setcounter{subsection}{2}
 \setcounter{subsubsection}{0}
 \setcounter{paragraph}{0}

=== modified file 'doc/manual/data_callbacks.aux'
--- doc/manual/data_callbacks.aux	2011-11-15 22:32:33 +0000
+++ doc/manual/data_callbacks.aux	2012-01-18 15:51:24 +0000
@@ -43,10 +43,12 @@
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {3.1.3.7}\texttt  {ADJ_VEC_SET_RANDOM_CB}}{17}{subsubsection.3.1.3.7}}
 \newlabel{api:ADJ_VEC_DOT_PRODUCT_CB}{{3.1.3.8}{17}{\texttt {ADJ_VEC_DOT_PRODUCT_CB}\label {api:ADJ_VEC_DOT_PRODUCT_CB}\relax }{subsubsection.3.1.3.8}{}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {3.1.3.8}\texttt  {ADJ_VEC_DOT_PRODUCT_CB}}{17}{subsubsection.3.1.3.8}}
-\newlabel{api:ADJ_VEC_TO_FILE_CB}{{3.1.3.9}{18}{\texttt {ADJ_VEC_TO_FILE_CB}\label {api:ADJ_VEC_TO_FILE_CB}\relax }{subsubsection.3.1.3.9}{}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.1.3.9}\texttt  {ADJ_VEC_TO_FILE_CB}}{18}{subsubsection.3.1.3.9}}
-\newlabel{api:ADJ_VEC_FROM_FILE_CB}{{3.1.3.10}{18}{\texttt {ADJ_VEC_FROM_FILE_CB}\label {api:ADJ_VEC_FROM_FILE_CB}\relax }{subsubsection.3.1.3.10}{}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.1.3.10}\texttt  {ADJ_VEC_FROM_FILE_CB}}{18}{subsubsection.3.1.3.10}}
+\newlabel{api:ADJ_VEC_WRITE_CB}{{3.1.3.9}{18}{\texttt {ADJ_VEC_WRITE_CB}\label {api:ADJ_VEC_WRITE_CB}\relax }{subsubsection.3.1.3.9}{}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.1.3.9}\texttt  {ADJ_VEC_WRITE_CB}}{18}{subsubsection.3.1.3.9}}
+\newlabel{api:ADJ_VEC_READ_CB}{{3.1.3.10}{18}{\texttt {ADJ_VEC_READ_CB}\label {api:ADJ_VEC_READ_CB}\relax }{subsubsection.3.1.3.10}{}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.1.3.10}\texttt  {ADJ_VEC_READ_CB}}{18}{subsubsection.3.1.3.10}}
+\newlabel{api:ADJ_VEC_DELETE_CB}{{3.1.3.11}{18}{\texttt {ADJ_VEC_DELETE_CB}\label {api:ADJ_VEC_DELETE_CB}\relax }{subsubsection.3.1.3.11}{}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.1.3.11}\texttt  {ADJ_VEC_DELETE_CB}}{18}{subsubsection.3.1.3.11}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.1.4}Matrix callbacks}{18}{subsection.3.1.4}}
 \newlabel{sec:matrix_callbacks}{{3.1.4}{18}{Matrix callbacks\relax }{subsection.3.1.4}{}}
 \newlabel{api:ADJ_MAT_DUPLICATE_CB}{{3.1.4.1}{18}{\texttt {ADJ_MAT_DUPLICATE_CB}\label {api:ADJ_MAT_DUPLICATE_CB}\relax }{subsubsection.3.1.4.1}{}}

=== modified file 'doc/manual/data_callbacks.tex'
--- doc/manual/data_callbacks.tex	2011-11-03 10:49:53 +0000
+++ doc/manual/data_callbacks.tex	2012-01-18 15:51:24 +0000
@@ -332,40 +332,56 @@
 activated on an \refapi{adj_block} with \refapi{adj_block_set_test_hermitian},
 or on an \refapi{adj_nonlinear_block} with \\\refapi{adj_nonlinear_block_set_test_hermitian}.
 
-\defapiss{ADJ_VEC_TO_FILE_CB}
-\begin{boxwithtitle}{\texttt{ADJ_VEC_TO_FILE_CB}}
+\defapiss{ADJ_VEC_WRITE_CB}
+\begin{boxwithtitle}{\texttt{ADJ_VEC_WRITE_CB}}
 \begin{minipage}{\columnwidth}
 \begin{ccode}
-  void (*vec_to_file)(adj_vector x, char* filename);
+  void (*vec_write)(adj_variable var, adj_vector x);
 \end{ccode}
 \begin{fortrancode}
-  subroutine adj_vec_to_file(x, filename) 
+  subroutine adj_vec_write(var, x) 
+    type(adj_variable), intent(in), value :: var
     type(adj_vector), intent(in), value :: x
-    character(kind=c_char), dimension(ADJ_NAME_LEN), intent(in) :: filename
-  end subroutine adj_vec_to_file
+  end subroutine adj_vec_write
 \end{fortrancode}
 \end{minipage}
 \end{boxwithtitle}
-This data callback saves the provided vector into a file named \texttt{filename} on disk.
+This data callback saves the provided vector containing variable \texttt{var} to disk. 
 
 When necessary: If a checkpointing scheme is used.
 
-
-\defapiss{ADJ_VEC_FROM_FILE_CB}
-\begin{boxwithtitle}{\texttt{ADJ_VEC_FROM_FILE_CB}}
+\defapiss{ADJ_VEC_READ_CB}
+\begin{boxwithtitle}{\texttt{ADJ_VEC_READ_CB}}
 \begin{minipage}{\columnwidth}
 \begin{ccode}
-  void (*vec_from_file)(adj_vector* x, char *filename);
+  void (*vec_read)(adj_variable var, adj_vector* x);
 \end{ccode}
 \begin{fortrancode}
-  subroutine adj_vec_from_file(x, filename) 
+  subroutine adj_vec_read(var, x) 
+    type(adj_variable), intent(in), value :: var
     type(adj_vector), intent(out) :: x
-    character(kind=c_char), dimension(ADJ_NAME_LEN), intent(in) :: filename
-  end subroutine adj_vec_from_file
-\end{fortrancode}
-\end{minipage}
-\end{boxwithtitle}
-This data callback loads the vector from file \texttt{filename} on disk.
+  end subroutine adj_vec_read
+\end{fortrancode}
+\end{minipage}
+\end{boxwithtitle}
+This data callback loads the vector containing variable \texttt{var} from disk.
+
+When necessary: If a checkpointing scheme is used.
+
+\defapiss{ADJ_VEC_DELETE_CB}
+\begin{boxwithtitle}{\texttt{ADJ_VEC_DELETE_CB}}
+\begin{minipage}{\columnwidth}
+\begin{ccode}
+  void (*vec_delete)(adj_variable var)
+\end{ccode}
+\begin{fortrancode}
+  subroutine adj_vec_delete(var) 
+    type(adj_variable), intent(in), value :: var
+  end subroutine adj_vec_delete
+\end{fortrancode}
+\end{minipage}
+\end{boxwithtitle}
+This data callback deletes the file that stores variable \texttt{var}. 
 
 When necessary: If a checkpointing scheme is used.
 

=== modified file 'include/libadjoint/adj_adjointer_routines.h'
--- include/libadjoint/adj_adjointer_routines.h	2012-01-16 15:47:58 +0000
+++ include/libadjoint/adj_adjointer_routines.h	2012-01-18 15:51:24 +0000
@@ -64,12 +64,12 @@
 int adj_has_variable_value_disk(adj_adjointer* adjointer, adj_variable var);
 int adj_is_variable_memory_checkpoint(adj_adjointer* adjointer, adj_variable var);
 int adj_is_variable_disk_checkpoint(adj_adjointer* adjointer, adj_variable var);
-int adj_forget_variable_value(adj_adjointer* adjointer, adj_variable_data* data);
+int adj_forget_variable_value(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data);
 int adj_forget_variable_value_from_memory(adj_adjointer* adjointer, adj_variable_data* data);
-int adj_forget_variable_value_from_disk(adj_adjointer* adjointer, adj_variable_data* data);
-int adj_destroy_variable_data(adj_adjointer* adjointer, adj_variable_data* data);
+int adj_forget_variable_value_from_disk(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data);
+int adj_destroy_variable_data(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data);
 int adj_add_new_hash_entry(adj_adjointer* adjointer, adj_variable* var, adj_variable_data** data);
-int adj_record_variable_core_disk(adj_adjointer* adjointer, adj_variable_data* data_ptr, adj_storage_data storage);
+int adj_record_variable_core_disk(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data_ptr, adj_storage_data storage);
 int adj_record_variable_core_memory(adj_adjointer* adjointer, adj_variable_data* data_ptr, adj_storage_data storage);
 int adj_record_variable_compare(adj_adjointer* adjointer, adj_variable_data* data_ptr, adj_variable var, adj_storage_data storage);
 

=== modified file 'include/libadjoint/adj_constants.h'
--- include/libadjoint/adj_constants.h	2011-11-10 20:59:12 +0000
+++ include/libadjoint/adj_constants.h	2012-01-18 15:51:24 +0000
@@ -69,8 +69,9 @@
 #define ADJ_VEC_GET_NORM_CB 16
 #define ADJ_VEC_DOT_PRODUCT_CB 17
 #define ADJ_VEC_SET_RANDOM_CB 18
-#define ADJ_VEC_TO_FILE_CB 19
-#define ADJ_VEC_FROM_FILE_CB 20
+#define ADJ_VEC_WRITE_CB 19
+#define ADJ_VEC_READ_CB 20
+#define ADJ_VEC_DELETE_CB 21
 
 #define ADJ_MAT_DUPLICATE_CB 30
 #define ADJ_MAT_AXPY_CB 31

=== modified file 'include/libadjoint/adj_data_structures.h'
--- include/libadjoint/adj_data_structures.h	2012-01-16 15:47:58 +0000
+++ include/libadjoint/adj_data_structures.h	2012-01-18 15:51:24 +0000
@@ -96,12 +96,11 @@
   /* for ADJ_STORAGE_MEMORY */
   int storage_memory_type; /* ADJ_STORAGE_MEMORY_COPY or ADJ_STORAGE_MEMORY_INCREF */
   int storage_memory_has_value;
-  int storage_memory_is_checkpoint; /* checkpoints are not deleted by adj_forget_forward_equation */
+  int storage_memory_is_checkpoint; /* memory checkpoints are not deleted by adj_forget_forward_equation */
 
   /* for ADJ_STORAGE_DISK */
   int storage_disk_has_value;
-  int storage_disk_is_checkpoint; /* checkpoints are not deleted by adj_forget_forward_equation */
-  char storage_disk_filename[ADJ_NAME_LEN];
+  int storage_disk_is_checkpoint; /* disk checkpoints are not deleted by adj_forget_forward_equation */
 
   /* POD, temporal interpolation, ... */
 } adj_storage_data;
@@ -132,12 +131,6 @@
 
 typedef struct
 {
-  adj_variable_data* firstnode;
-  adj_variable_data* lastnode;
-} adj_variable_data_list;
-
-typedef struct
-{
   void (*vec_duplicate)(adj_vector x, adj_vector *newx);
   void (*vec_axpy)(adj_vector *y, adj_scalar alpha, adj_vector x);
   void (*vec_destroy)(adj_vector *x);
@@ -147,8 +140,9 @@
   void (*vec_get_norm)(adj_vector x, adj_scalar* norm);
   void (*vec_dot_product)(adj_vector x, adj_vector y, adj_scalar* val);
   void (*vec_set_random)(adj_vector* x);
-  void (*vec_to_file)(adj_vector x, char* filename);
-  void (*vec_from_file)(adj_vector* x, char *filename);
+  void (*vec_write)(adj_variable var, adj_vector x);
+  void (*vec_read)(adj_variable var, adj_vector* x);
+  void (*vec_delete)(adj_variable var);
 
   void (*mat_duplicate)(adj_matrix matin, adj_matrix *matout);
   void (*mat_axpy)(adj_matrix *Y, adj_scalar alpha, adj_matrix X);
@@ -286,7 +280,6 @@
   adj_revolve_data revolve_data; /* A data struct for revolve related information */
 
   adj_variable_hash* varhash; /* The hash table for looking up information about variables */
-  adj_variable_data_list vardata; /* We also store a linked list so we can walk all our variable data */
 
   int options[ADJ_NO_OPTIONS]; /* Pretty obvious */
 

=== modified file 'include/libadjoint/adj_petsc_data_structures.h'
--- include/libadjoint/adj_petsc_data_structures.h	2011-08-30 19:15:58 +0000
+++ include/libadjoint/adj_petsc_data_structures.h	2012-01-18 15:51:24 +0000
@@ -2,6 +2,7 @@
 #define ADJ_PETSC_DATA_STRUCTURES_H
 
 #include <string.h>
+#include <stdio.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -24,8 +25,9 @@
 void petsc_vec_getnorm_proc(adj_vector vec, adj_scalar* norm);
 void petsc_vec_set_random_proc(adj_vector* x);
 void petsc_vec_dot_product_proc(adj_vector x, adj_vector y, adj_scalar* val);
-void petsc_vec_to_file_proc(adj_vector x, char* filename); 
-void petsc_vec_from_file_proc(adj_vector* x, char* filename);
+void petsc_vec_write_proc(adj_variable var, adj_vector x);
+void petsc_vec_read_proc(adj_variable var, adj_vector* x);
+void petsc_vec_delete_proc(adj_variable var);
 
 void petsc_mat_getvec_proc(adj_matrix mat, adj_vector *left);
 void petsc_mat_axpy_proc(adj_matrix *Y, adj_scalar alpha, adj_matrix X);

=== modified file 'python/libadjoint/libadjoint.py'
--- python/libadjoint/libadjoint.py	2012-01-16 15:47:58 +0000
+++ python/libadjoint/libadjoint.py	2012-01-18 15:51:24 +0000
@@ -294,10 +294,12 @@
 
 class DiskStorage(Storage):
   '''Wrapper class for Vectors that contains additional information for storing the vector values in memory.'''
-  def __init__(self, vec):
+  def __init__(self, vec, cs=False):
     self.storage_data = clib.adj_storage_data()
     self.c_object = self.storage_data
-    clib.adj_storage_disk_incref(vec.as_adj_vector(), self.storage_data)
+    clib.adj_storage_disk(vec.as_adj_vector(), self.storage_data)
+
+    self.set_checkpoint(cs)
 
     # Ensure that the storage object always holds a reference to the vec
     self.vec = vec
@@ -617,6 +619,9 @@
     self.vec_set_random_type = ctypes.CFUNCTYPE(None, ctypes.POINTER(clib.adj_vector))
     self.vec_set_values_type = ctypes.CFUNCTYPE(None, ctypes.POINTER(clib.adj_vector), ctypes.POINTER(adj_scalar))
     self.vec_get_size_type = ctypes.CFUNCTYPE(None, clib.adj_vector, ctypes.POINTER(ctypes.c_int))
+    self.vec_write_type = ctypes.CFUNCTYPE(None, clib.adj_variable, clib.adj_vector)
+    self.vec_read_type = ctypes.CFUNCTYPE(None, clib.adj_variable, ctypes.POINTER(clib.adj_vector))
+    self.vec_delete_type = ctypes.CFUNCTYPE(None, clib.adj_variable)
     self.mat_duplicate_type = ctypes.CFUNCTYPE(None, clib.adj_matrix, ctypes.POINTER(clib.adj_matrix))
     self.mat_destroy_type = ctypes.CFUNCTYPE(None, ctypes.POINTER(clib.adj_matrix))
     self.mat_axpy_type = ctypes.CFUNCTYPE(None, ctypes.POINTER(clib.adj_matrix), adj_scalar, clib.adj_matrix)
@@ -723,6 +728,25 @@
     finally:
       references_taken.append(storage.vec)
 
+    # At this point we should also reregister the read and the delete callbacks.
+    # Note that the initial callback implementation could not access
+    # the user implementation of the read() and delete() functions, and but here we can.
+    def __vec_read_callback__(adj_var, adj_vec_ptr):
+        var = Variable(var=adj_var)
+        y = storage.vec.__class__.read(var)
+        # Increase the reference counter of the new object to protect it from deallocation at the end of the callback
+        references_taken.append(y)
+        adj_vec_ptr[0].ptr = python_utils.c_ptr(y)
+        adj_vec_ptr[0].klass = 0
+        adj_vec_ptr[0].flags = 0
+
+    def __vec_delete_callback__(adj_var):
+        var = Variable(var=adj_var)
+        storage.vec.__class__.delete(var)
+
+    self.__register_data_callback__('ADJ_VEC_DELETE_CB', __vec_delete_callback__)
+    self.__register_data_callback__('ADJ_VEC_READ_CB', __vec_read_callback__)
+
   def evaluate_functional(self, functional, timestep):
     '''evaluate_functional(self, functional, timestep)
 
@@ -850,6 +874,9 @@
     self.__register_data_callback__('ADJ_VEC_SET_RANDOM_CB', self.__vec_set_random_callback__)
     self.__register_data_callback__('ADJ_VEC_SET_VALUES_CB', self.__vec_set_values_callback__)
     self.__register_data_callback__('ADJ_VEC_GET_SIZE_CB', self.__vec_get_size_callback__)
+    self.__register_data_callback__('ADJ_VEC_WRITE_CB', self.__vec_write_callback__)
+    self.__register_data_callback__('ADJ_VEC_READ_CB', self.__vec_read_callback__)
+    self.__register_data_callback__('ADJ_VEC_DELETE_CB', self.__vec_delete_callback__)
     self.__register_data_callback__('ADJ_MAT_DUPLICATE_CB', self.__mat_duplicate_callback__)
     self.__register_data_callback__('ADJ_MAT_DESTROY_CB', self.__mat_destroy_callback__)
     self.__register_data_callback__('ADJ_MAT_AXPY_CB', self.__mat_axpy_callback__)
@@ -892,6 +919,9 @@
                    'ADJ_VEC_SET_RANDOM_CB': self.vec_set_random_type,
                    'ADJ_VEC_SET_VALUES_CB': self.vec_set_values_type,
                    'ADJ_VEC_GET_SIZE_CB': self.vec_get_size_type,
+                   'ADJ_VEC_WRITE_CB': self.vec_write_type,
+                   'ADJ_VEC_READ_CB': self.vec_read_type,
+                   "ADJ_VEC_DELETE_CB": self.vec_delete_type,
                    "ADJ_MAT_DUPLICATE_CB": self.mat_duplicate_type,
                    "ADJ_MAT_DESTROY_CB": self.mat_destroy_type,
                    "ADJ_MAT_AXPY_CB": self.mat_axpy_type,
@@ -1099,6 +1129,34 @@
     sz[0] = y.size()
 
   @staticmethod
+  def __vec_write_callback__(adj_var, adj_vec):
+    var = Variable(var=adj_var)
+    vec = vector(adj_vec)
+    vec.write(var)
+
+  @staticmethod
+  def __vec_read_callback__(adj_var, adj_vec_ptr):
+    raise exceptions.LibadjointErrorInvalidInputs(
+        'Internal error: called vec_read callback before recording any variables.')
+
+  @staticmethod
+  def __vec_delete_callback__(adj_var):
+    raise exceptions.LibadjointErrorInvalidInputs(
+        'Internal error: called vec_delete callback before recording any variables.')
+
+    print "To be implemented"
+    assert(False)
+    vec = vector(adj_vec_ptr[0])
+
+    # Do the corresponding decref of the object, so that the Python GC can pick it up
+    try:
+      references_taken.remove(vec)
+    except:
+      print vec.data
+      print references_taken
+      raise
+
+  @staticmethod
   def __mat_duplicate_callback__(adj_mat, adj_mat_ptr):
     mat = matrix(adj_mat)
     new_mat = mat.duplicate()
@@ -1202,6 +1260,26 @@
     raise exceptions.LibadjointErrorNeedCallback(
       'Class '+self.__class__.__name__+' has no dot_product() method')        
 
+  @staticmethod
+  def read(var):
+    '''This method must return a vector containing the values of var from disk.'''
+
+    raise exceptions.LibadjointErrorNeedCallback(
+      'Class Vector has no read() method')        
+
+  @staticmethod
+  def delete(var):
+    '''This method must delete the vector containing the values of var from disk.''' 
+
+    raise exceptions.LibadjointErrorNeedCallback(
+      'Class Vector has no delete() method')        
+
+  def write(self, var):
+    '''This method must write this vector as values of var to disk.'''
+
+    raise exceptions.LibadjointErrorNeedCallback(
+      'Class '+self.__class__.__name__+' has no write() method')        
+
   def as_adj_vector(self):
     '''as_adj_vector(self)
 

=== modified file 'src/adj_adjointer_routines.c'
--- src/adj_adjointer_routines.c	2012-01-18 15:18:28 +0000
+++ src/adj_adjointer_routines.c	2012-01-18 15:51:24 +0000
@@ -12,8 +12,6 @@
   adjointer->timestep_data = NULL;
 
   adjointer->varhash = NULL;
-  adjointer->vardata.firstnode = NULL;
-  adjointer->vardata.lastnode = NULL;
 
   adjointer->callbacks.vec_duplicate = NULL;
   adjointer->callbacks.vec_axpy = NULL;
@@ -24,8 +22,9 @@
   adjointer->callbacks.vec_get_norm = NULL;
   adjointer->callbacks.vec_set_random = NULL;
   adjointer->callbacks.vec_dot_product = NULL;
-  adjointer->callbacks.vec_to_file = NULL;
-  adjointer->callbacks.vec_from_file = NULL;
+  adjointer->callbacks.vec_write = NULL;
+  adjointer->callbacks.vec_read = NULL;
+  adjointer->callbacks.vec_delete = NULL;
 
   adjointer->callbacks.mat_duplicate = NULL;
   adjointer->callbacks.mat_axpy = NULL;
@@ -72,6 +71,7 @@
 {
   int i;
   int ierr;
+  adj_variable_hash* varhash;
   adj_variable_data* data_ptr;
   adj_variable_data* data_ptr_tmp;
   adj_op_callback* cb_ptr;
@@ -106,10 +106,10 @@
     free(adjointer->timestep_data);
   }
 
-  data_ptr = adjointer->vardata.firstnode;
-  while (data_ptr != NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
-    ierr = adj_destroy_variable_data(adjointer, data_ptr);
+  	data_ptr=varhash->data;
+    ierr = adj_destroy_variable_data(adjointer, varhash->variable, data_ptr);
     if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
     data_ptr_tmp = data_ptr;
     data_ptr = data_ptr->next;
@@ -688,11 +688,6 @@
     return adj_chkierr_auto(ADJ_ERR_NEED_VALUE);
   }
 
-  /* Create the filename in case we need to store/load from disk */
-  char filename[ADJ_NAME_LEN];
-  adj_variable_str(var, filename, ADJ_NAME_LEN);
-  strncat(filename, ".dat", 4);
-
   /* Case 1: variable is on disk and we want to checkpoint it in disk */
   if ((cs == ADJ_CHECKPOINT_STORAGE_DISK) && (var_data->storage.storage_disk_has_value == ADJ_TRUE))
   {
@@ -721,12 +716,12 @@
   else if  (cs == ADJ_CHECKPOINT_STORAGE_MEMORY && (var_data->storage.storage_memory_has_value != ADJ_TRUE))
   {
     /* Check for the required callbacks */
-    if (adjointer->callbacks.vec_from_file == NULL)
+    if (adjointer->callbacks.vec_read == NULL)
     {
-      strncpy(adj_error_msg, "Need the vec_from_file data callback, but it hasn't been supplied.", ADJ_ERROR_MSG_BUF);
+      strncpy(adj_error_msg, "Need the ADJ_VEC_READ_CB data callback, but it hasn't been supplied.", ADJ_ERROR_MSG_BUF);
       return adj_chkierr_auto(ADJ_ERR_NEED_CALLBACK);
     }
-    adjointer->callbacks.vec_from_file(&(var_data->storage.value), filename);
+    adjointer->callbacks.vec_read(var, &(var_data->storage.value));
     var_data->storage.storage_memory_has_value=ADJ_TRUE;
 
     var_data->storage.storage_memory_is_checkpoint = ADJ_TRUE;
@@ -755,7 +750,7 @@
         (adjointer->revolve_data.current_action != CACTION_FIRSTRUN))
     {
       adj_variable_str(equation.variable, buf, ADJ_NAME_LEN);
-      snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "The adjointer and revolve are not consistent (in adj_register_equation of variable %s). This can happen when one tries to register an equation after solving the first adjoint equation.", buf);
+      snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "The adjointer and revolve are not consistent (in adj_register_equation of variable %s). Did you register an equation after solving the first adjoint equation?", buf);
       return adj_chkierr_auto(ADJ_ERR_REVOLVE_ERROR);
     }
   }
@@ -1002,15 +997,7 @@
   else if (storage.storage_memory_has_value && !data_ptr->storage.storage_memory_has_value)
     return adj_record_variable_core_memory(adjointer, data_ptr, storage);
   else if (storage.storage_disk_has_value && !data_ptr->storage.storage_disk_has_value)
-  {
-    /* Generate the filename */
-    char filename[ADJ_NAME_LEN];
-    adj_variable_str(var, filename, ADJ_NAME_LEN);
-    strncat(filename, ".dat", 4);
-    strncpy(storage.storage_disk_filename, filename, ADJ_NAME_LEN);
-
-    return adj_record_variable_core_disk(adjointer, data_ptr, storage);
-  }
+    return adj_record_variable_core_disk(adjointer, var, data_ptr, storage);
   else
   /* Sorry for the slight mess. The easiest way to understand this block is to build a 2x2 graph of
      compare and overwrite:
@@ -1044,7 +1031,7 @@
       {
         int record_ierr;
 
-        ierr = adj_forget_variable_value(adjointer, data_ptr);
+        ierr = adj_forget_variable_value(adjointer, var, data_ptr);
         if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
 
         record_ierr = adj_record_variable_core_memory(adjointer, data_ptr, storage); /* Overwrite the result anyway */
@@ -1064,7 +1051,7 @@
     {
       if (storage.overwrite)
       {
-        ierr = adj_forget_variable_value(adjointer, data_ptr);
+        ierr = adj_forget_variable_value(adjointer, var, data_ptr);
         if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
         return adj_record_variable_core_memory(adjointer, data_ptr, storage);
       }
@@ -1131,11 +1118,11 @@
 }
 
 /* The core routine to record a variable to disk */
-int adj_record_variable_core_disk(adj_adjointer* adjointer, adj_variable_data* data_ptr, adj_storage_data storage)
+int adj_record_variable_core_disk(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data_ptr, adj_storage_data storage)
 {
-  if (adjointer->callbacks.vec_to_file == NULL)
+  if (adjointer->callbacks.vec_write == NULL)
   {
-    snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "You have asked to record a value to disk, but no ADJ_VEC_TO_FILE_CB callback has been provided.");
+    snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "You have asked to record a value to disk, but no ADJ_VEC_WRITE_CB callback has been provided.");
     return adj_chkierr_auto(ADJ_ERR_NEED_CALLBACK);
   }
 
@@ -1153,8 +1140,7 @@
 
   data_ptr->storage.storage_disk_has_value = storage.storage_disk_has_value;
   data_ptr->storage.storage_disk_is_checkpoint = storage.storage_disk_is_checkpoint;
-  strncpy(data_ptr->storage.storage_disk_filename, storage.storage_disk_filename, ADJ_NAME_LEN);
-  adjointer->callbacks.vec_to_file(storage.value, data_ptr->storage.storage_disk_filename);
+  adjointer->callbacks.vec_write(var, storage.value);
 
   return ADJ_OK;
 }
@@ -1315,11 +1301,14 @@
     case ADJ_VEC_SET_RANDOM_CB:
       adjointer->callbacks.vec_set_random = (void(*)(adj_vector* x)) fn;
       break;
-    case ADJ_VEC_TO_FILE_CB:
-      adjointer->callbacks.vec_to_file = (void(*)(adj_vector x, char* filename)) fn;
-      break;
-    case ADJ_VEC_FROM_FILE_CB:
-      adjointer->callbacks.vec_from_file = (void(*)(adj_vector* x, char* filename)) fn;
+    case ADJ_VEC_WRITE_CB:
+      adjointer->callbacks.vec_write = (void(*)(adj_variable, adj_vector x)) fn;
+      break;
+    case ADJ_VEC_READ_CB:
+      adjointer->callbacks.vec_read = (void(*)(adj_variable var, adj_vector* x)) fn;
+      break;
+    case ADJ_VEC_DELETE_CB:
+      adjointer->callbacks.vec_delete = (void(*)(adj_variable var)) fn;
       break;
 
     case ADJ_MAT_DUPLICATE_CB:
@@ -1431,6 +1420,7 @@
 
 int adj_forget_adjoint_equation(adj_adjointer* adjointer, int equation)
 {
+  adj_variable_hash* varhash;
   adj_variable_data* data;
   int should_we_delete;
   int i;
@@ -1439,8 +1429,8 @@
 
   if (adjointer->options[ADJ_ACTIVITY] == ADJ_ACTIVITY_NOTHING) return ADJ_OK;
 
-  /* Dont delete any variables if we want to compare in the revolve replays */
-  if (adjointer->revolve_data.overwrite==ADJ_TRUE)
+  /* Do not delete any variables if we want to compare forward variables with the revolve replay */
+  if (adjointer->revolve_data.overwrite == ADJ_TRUE)
     return ADJ_OK;
 
   if (equation >= adjointer->nequations)
@@ -1449,9 +1439,9 @@
     return adj_chkierr_auto(ADJ_ERR_INVALID_INPUTS);
   }
 
-  data = adjointer->vardata.firstnode;
-  while (data != NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
+  	data = varhash->data;
     if (data->storage.storage_memory_has_value || data->storage.storage_disk_has_value)
     {
       should_we_delete = 1;
@@ -1485,7 +1475,7 @@
         /* Forget only non-checkpoint variables */
         if (data->storage.storage_disk_has_value && !data->storage.storage_disk_is_checkpoint)
         {
-          ierr = adj_forget_variable_value_from_disk(adjointer, data);
+          ierr = adj_forget_variable_value_from_disk(adjointer, varhash->variable, data);
           if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
         }
         if (data->storage.storage_memory_has_value && !data->storage.storage_memory_is_checkpoint)
@@ -1496,7 +1486,6 @@
       }
     }
 
-    data = data->next;
   }
 
   return ADJ_OK;
@@ -1521,6 +1510,7 @@
  */
 int adj_forget_forward_equation_until(adj_adjointer* adjointer, int equation, int last_equation)
 {
+  adj_variable_hash* varhash;
   adj_variable_data* data;
   int should_we_delete;
   int i;
@@ -1534,23 +1524,16 @@
     return adj_chkierr_auto(ADJ_ERR_INVALID_INPUTS);
   }
 
-  data = adjointer->vardata.firstnode;
-
-  while (data != NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
+  	data = varhash->data;
     /* Only forget forward variables */
     if (data->type != ADJ_FORWARD) /* Skip adjoint or TLM variables. */
-    {
-      data = data->next;
       continue;
-    }
 
     /* Only forget forward variables that are computed at equations <= equation */
     if (data->equation>equation)
-    {
-      data = data->next;
       continue;
-    }
 
     if (data->storage.storage_memory_has_value || data->storage.storage_disk_has_value)
     {
@@ -1593,7 +1576,7 @@
         /* Forget only non-checkpoint variables */
         if (data->storage.storage_disk_has_value && !data->storage.storage_disk_is_checkpoint)
         {
-          ierr = adj_forget_variable_value_from_disk(adjointer, data);
+          ierr = adj_forget_variable_value_from_disk(adjointer, varhash->variable, data);
           if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
         }
         if (data->storage.storage_memory_has_value && !data->storage.storage_memory_is_checkpoint)
@@ -1604,7 +1587,6 @@
       }
     }
 
-    data = data->next;
   }
 
   return ADJ_OK;
@@ -1612,6 +1594,7 @@
 
 int adj_forget_tlm_equation(adj_adjointer* adjointer, int equation)
 {
+  adj_variable_hash* varhash;
   adj_variable_data* data;
   int should_we_delete;
   int i;
@@ -1625,16 +1608,13 @@
     return adj_chkierr_auto(ADJ_ERR_INVALID_INPUTS);
   }
 
-  data = adjointer->vardata.firstnode;
-
-  while (data != NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
+	data = varhash->data;
+
     /* Only forget forward variables */
     if (data->type != ADJ_TLM) /* Skip anything other than TLM variables.. */
-    {
-      data = data->next;
       continue;
-    }
 
     if (data->storage.storage_memory_has_value || data->storage.storage_disk_has_value)
     {
@@ -1679,7 +1659,6 @@
       }
     }
 
-    data = data->next;
   }
 
   return ADJ_OK;
@@ -1803,12 +1782,14 @@
   /* Disk storage */
   else if(data_ptr->storage.storage_disk_has_value)
   {
-    if (adjointer->callbacks.vec_from_file == NULL)
+    if (adjointer->callbacks.vec_read == NULL)
     {
-      snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "You have asked to get a value from disk, but no ADJ_VEC_FROM_FILE_CB callback has been provided.");
+      snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "You have asked to get a value from disk, but no ADJ_VEC_READ_CB callback has been provided.");
       return adj_chkierr_auto(ADJ_ERR_NEED_CALLBACK);
     }
-    adjointer->callbacks.vec_from_file(value, data_ptr->storage.storage_disk_filename);
+    adjointer->callbacks.vec_read(var, value);
+    data_ptr->storage.storage_memory_has_value = ADJ_TRUE;
+    data_ptr->storage.value = *value;
   }
   return ADJ_OK;
 }
@@ -1895,13 +1876,13 @@
   return data_ptr->storage.storage_memory_is_checkpoint;
 }
 
-int adj_forget_variable_value(adj_adjointer* adjointer, adj_variable_data* data)
+int adj_forget_variable_value(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data)
 {
   int ierr;
 
   if (data->storage.storage_disk_has_value)
   {
-    ierr = adj_forget_variable_value_from_disk(adjointer, data);
+    ierr = adj_forget_variable_value_from_disk(adjointer, var, data);
     if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
   }
   if (data->storage.storage_memory_has_value)
@@ -1912,22 +1893,18 @@
   return ADJ_OK;
 }
 
-int adj_forget_variable_value_from_disk(adj_adjointer* adjointer, adj_variable_data* data)
+int adj_forget_variable_value_from_disk(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data)
 {
-  int ierr;
+  if (adjointer->callbacks.vec_delete == NULL)
+  {
+    strncpy(adj_error_msg, "Need ADJ_VEC_DELETE_CB data callback.", ADJ_ERROR_MSG_BUF);
+    return adj_chkierr_auto(ADJ_ERR_NEED_CALLBACK);
+  }
 
   assert(data->storage.storage_disk_has_value);
-  if (access(data->storage.storage_disk_filename, W_OK) == -1) { 
-    char buf[ADJ_NAME_LEN];
-    adj_variable_str(adjointer->equations[data->equation].variable, buf, ADJ_NAME_LEN);
-
-    ierr = ADJ_ERR_INVALID_INPUTS;
-    snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "Can not access variable %s in file '%s'.", buf, data->storage.storage_disk_filename);
-    return adj_chkierr_auto(ierr);
-  }
 
   data->storage.storage_disk_has_value = ADJ_FALSE;
-  remove(data->storage.storage_disk_filename);
+  adjointer->callbacks.vec_delete(var);
   return ADJ_OK;
 }
 
@@ -1935,7 +1912,7 @@
 {
   if (adjointer->callbacks.vec_destroy == NULL)
   {
-    strncpy(adj_error_msg, "Need vec_destroy data callback.", ADJ_ERROR_MSG_BUF);
+    strncpy(adj_error_msg, "Need ADJ_VEC_DESTROY_CB data callback.", ADJ_ERROR_MSG_BUF);
     return adj_chkierr_auto(ADJ_ERR_NEED_CALLBACK);
   }
 
@@ -1946,7 +1923,7 @@
   return ADJ_OK;
 }
 
-int adj_destroy_variable_data(adj_adjointer* adjointer, adj_variable_data* data)
+int adj_destroy_variable_data(adj_adjointer* adjointer, adj_variable var, adj_variable_data* data)
 {
 
   if (data->ntargeting_equations > 0)
@@ -1974,7 +1951,7 @@
   }
 
   if (data->storage.storage_memory_has_value || data->storage.storage_disk_has_value)
-    return adj_forget_variable_value(adjointer, data);
+    return adj_forget_variable_value(adjointer, var, data);
 
   return ADJ_OK;
 }
@@ -2156,18 +2133,6 @@
   ierr = adj_add_variable_data(&(adjointer->varhash), var, *data);
   if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
 
-  /* and add to the data list */
-  if (adjointer->vardata.firstnode == NULL)
-  {
-    adjointer->vardata.firstnode = *data;
-    adjointer->vardata.lastnode = *data;
-  }
-  else
-  {
-    adjointer->vardata.lastnode->next = *data;
-    adjointer->vardata.lastnode = *data;
-  }
-
   return ADJ_OK;
 }
 

=== modified file 'src/adj_core.c'
--- src/adj_core.c	2012-01-16 15:47:58 +0000
+++ src/adj_core.c	2012-01-18 15:51:24 +0000
@@ -455,6 +455,15 @@
         oldcapo = revolve_getoldcapo(adjointer->revolve_data.revolve);
         capo = revolve_getcapo(adjointer->revolve_data.revolve);
 
+        /* If revolve advances to a timestep larger than ntimeteps-1,
+         * then the user claimed in the revolve settings to solve for more timesteps then we actually did.
+         */
+        if (capo > adjointer->ntimesteps-1)
+        {
+          snprintf(adj_error_msg, ADJ_ERROR_MSG_BUF, "Revolve expected %i timesteps but only %i were annotated.", capo+1, adjointer->ntimesteps);
+          return adj_chkierr_auto(ADJ_ERR_INVALID_INPUTS);
+        }
+
         ierr = adj_timestep_start_equation(adjointer, oldcapo, &start_eqn);
         if (ierr != ADJ_OK) return adj_chkierr_auto(ierr);
         ierr = adj_timestep_end_equation(adjointer, capo-1, &end_eqn);

=== modified file 'src/adj_debug.c'
--- src/adj_debug.c	2011-11-10 22:18:55 +0000
+++ src/adj_debug.c	2012-01-18 15:51:24 +0000
@@ -136,6 +136,7 @@
 
   if (cp_num>0)
   {
+    adj_variable_hash* varhash;
     adj_variable_data* data;
 
     /* The first checkpoint equation must be zero, otherwise */
@@ -147,16 +148,12 @@
     }
 
     /* Check we have the required variables for the adjoint equations */
-    data = adjointer->vardata.firstnode;
-    /* Loop over every variable */
-    while (data != NULL)
+    for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
     {
+    	data = varhash->data;
       /* We are only interested in forward variables */
       if (data->equation < 0)
-      {
-        data = data->next;
         continue;
-      }
 
       /* Find out in which checkpoint slot the variable is computed */
       for (cp_iter=0; cp_iter < cp_num-1; cp_iter++)
@@ -187,7 +184,6 @@
         }
       }
 
-      data = data->next;
     }
   }
 

=== modified file 'src/adj_fortran.F90'
--- src/adj_fortran.F90	2012-01-16 15:47:58 +0000
+++ src/adj_fortran.F90	2012-01-18 15:51:24 +0000
@@ -71,8 +71,9 @@
     type(c_funptr) :: vec_get_norm
     type(c_funptr) :: vec_dot_product
     type(c_funptr) :: vec_set_random
-    type(c_funptr) :: vec_to_file
-    type(c_funptr) :: vec_from_file
+    type(c_funptr) :: vec_write
+    type(c_funptr) :: vec_read
+    type(c_funptr) :: vec_delete
 
     type(c_funptr) :: mat_duplicate
     type(c_funptr) :: mat_axpy
@@ -81,11 +82,6 @@
     type(c_funptr) :: solve
   end type adj_data_callbacks
 
-  type, bind(c) :: adj_variable_data_list
-    type(c_ptr) :: firstnode
-    type(c_ptr) :: lastnode
-  end type adj_variable_data_list
-
   type, bind(c) :: adj_op_callback_list
     type(c_ptr) :: firstnode
     type(c_ptr) :: lastnode
@@ -135,7 +131,6 @@
     type(adj_revolve_data) :: revolve_data
 
     type(c_ptr) :: varhash
-    type(adj_variable_data_list) :: vardata
 
     integer(kind=c_int), dimension(ADJ_NO_OPTIONS) :: options
 
@@ -176,7 +171,6 @@
 
     integer(kind=c_int) :: storage_disk_has_value
     integer(kind=c_int) :: storage_disk_is_checkpoint
-    character(kind=c_char), dimension(ADJ_NAME_LEN) :: storage_disk_filename
   end type adj_storage_data
 
   type, bind(c) :: adj_dictionary
@@ -245,17 +239,22 @@
       type(adj_vector), intent(inout) :: x
     end subroutine adj_vec_set_random
 
-    subroutine adj_vec_to_file(x, filename) bind(c)
+    subroutine adj_vec_write(var, x) bind(c)
       use libadjoint_data_structures
+      type(adj_variable), intent(in), value :: var
       type(adj_vector), intent(in), value :: x
-      character(kind=c_char), dimension(ADJ_NAME_LEN), intent(in) :: filename
-    end subroutine adj_vec_to_file
+    end subroutine adj_vec_write
 
-    subroutine adj_vec_from_file(x, filename) bind(c)
+    subroutine adj_vec_read(var, x) bind(c)
       use libadjoint_data_structures
+      type(adj_variable), intent(in), value :: var
       type(adj_vector), intent(out) :: x
-      character(kind=c_char), dimension(ADJ_NAME_LEN), intent(in) :: filename
-    end subroutine adj_vec_from_file
+    end subroutine adj_vec_read
+
+    subroutine adj_vec_delete(var) bind(c)
+      use libadjoint_data_structures
+      type(adj_variable), intent(in), value :: var
+    end subroutine adj_vec_delete
 
     subroutine adj_mat_duplicate_proc(matin, matout) bind(c)
       ! Allocate a new matrix, using a given matrix as the model

=== modified file 'src/adj_petsc_data_structures.c'
--- src/adj_petsc_data_structures.c	2011-11-10 21:04:41 +0000
+++ src/adj_petsc_data_structures.c	2012-01-18 15:51:24 +0000
@@ -21,9 +21,11 @@
   adj_chkierr(ierr);
   ierr = adj_register_data_callback(adjointer, ADJ_VEC_DOT_PRODUCT_CB,(void (*)(void)) petsc_vec_dot_product_proc);
   adj_chkierr(ierr);
-  ierr = adj_register_data_callback(adjointer, ADJ_VEC_TO_FILE_CB,(void (*)(void)) petsc_vec_to_file_proc);
-  adj_chkierr(ierr);
-  ierr = adj_register_data_callback(adjointer, ADJ_VEC_FROM_FILE_CB,(void (*)(void)) petsc_vec_from_file_proc);
+  ierr = adj_register_data_callback(adjointer, ADJ_VEC_WRITE_CB,(void (*)(void)) petsc_vec_write_proc);
+  adj_chkierr(ierr);
+  ierr = adj_register_data_callback(adjointer, ADJ_VEC_READ_CB,(void (*)(void)) petsc_vec_read_proc);
+  adj_chkierr(ierr);
+  ierr = adj_register_data_callback(adjointer, ADJ_VEC_DELETE_CB,(void (*)(void)) petsc_vec_delete_proc);
   adj_chkierr(ierr);
   ierr = adj_register_data_callback(adjointer, ADJ_MAT_AXPY_CB,(void (*)(void)) petsc_mat_axpy_proc);
   adj_chkierr(ierr);
@@ -75,6 +77,24 @@
 #endif
 }
 
+void petsc_vec_delete_proc(adj_variable var)
+{
+#ifdef HAVE_PETSC
+  /* Generate the filename */
+  char filename[ADJ_NAME_LEN];
+  adj_variable_str(var, filename, ADJ_NAME_LEN);
+  strncat(filename, ".dat", 4);
+
+	if (access(filename, W_OK) == -1) {
+		char buf[ADJ_NAME_LEN];
+		adj_variable_str(var, buf, ADJ_NAME_LEN);
+    fprintf(stderr, "Can remove variable %s in file '%s'. File does not exist.", buf, filename);
+  }
+
+  remove(filename);
+#endif
+}
+
 void petsc_vec_getnorm_proc(adj_vector x, adj_scalar* norm)
 {
 #ifdef HAVE_PETSC
@@ -100,9 +120,13 @@
 #endif
 }
 
-void petsc_vec_to_file_proc(adj_vector x, char* filename)
+void petsc_vec_write_proc(adj_variable var, adj_vector x)
 {
 #ifdef HAVE_PETSC
+  /* Generate the filename */
+  char filename[ADJ_NAME_LEN];
+  adj_variable_str(var, filename, ADJ_NAME_LEN);
+  strncat(filename, ".dat", 4);
 
   if (access(filename, W_OK) == 0) 
   {
@@ -110,8 +134,8 @@
   }
 
   PetscViewer viewer;
-  PetscViewerBinaryOpen(PETSC_COMM_WORLD,filename,FILE_MODE_WRITE,&viewer);
-  VecView(petsc_vec_from_adj_vector(x),viewer);
+  PetscViewerBinaryOpen(PETSC_COMM_WORLD, filename, FILE_MODE_WRITE, &viewer);
+  VecView(petsc_vec_from_adj_vector(x), viewer);
   PetscViewerDestroy(viewer);
 #else
     (void) x;
@@ -119,13 +143,25 @@
 #endif
 }
 
-void petsc_vec_from_file_proc(adj_vector *x, char* filename)
+void petsc_vec_read_proc(adj_variable var, adj_vector *x)
 {
 #ifdef HAVE_PETSC
+  /* Generate the filename */
+  char filename[ADJ_NAME_LEN];
+  adj_variable_str(var, filename, ADJ_NAME_LEN);
+  strncat(filename, ".dat", 4);
+
+	if (access(filename, W_OK) == -1) {
+		char buf[ADJ_NAME_LEN];
+		adj_variable_str(var, buf, ADJ_NAME_LEN);
+
+		fprintf(stderr, "Can not access variable %s in file '%s'.", buf, filename);
+  }
+
   Vec *vec=(Vec*) malloc(sizeof(Vec));
   PetscViewer viewer;
-  PetscViewerBinaryOpen(PETSC_COMM_WORLD,filename,FILE_MODE_READ,&viewer);
-  VecLoad(viewer,PETSC_NULL,vec);
+  PetscViewerBinaryOpen(PETSC_COMM_WORLD, filename, FILE_MODE_READ, &viewer);
+  VecLoad(viewer, PETSC_NULL, vec);
   PetscViewerDestroy(viewer);
   *x = petsc_vec_to_adj_vector(vec);
 #else

=== modified file 'src/tests/test_adj_forget_forward_equation.c'
--- src/tests/test_adj_forget_forward_equation.c	2011-11-28 10:38:19 +0000
+++ src/tests/test_adj_forget_forward_equation.c	2012-01-18 15:51:24 +0000
@@ -36,6 +36,7 @@
   adj_storage_data storage;
   char filename_fwd[ADJ_NAME_LEN];
   int checkpoint_strategy[steps];
+  adj_variable_hash *varhash;
   adj_variable_data *var_data;
 
   ierr = adj_create_adjointer(&adjointer);
@@ -144,13 +145,11 @@
   }
 
   /* Besides checkpoints, no variables should be stored anymore ... */
-  var_data=adjointer.vardata.firstnode;
-  while(var_data!=NULL)
+  for(varhash=adjointer.varhash; varhash != NULL; varhash=varhash->hh.next)
   {
+  	 var_data = varhash->data;
      adj_test_assert(var_data->storage.storage_memory_has_value==var_data->storage.storage_memory_is_checkpoint, "Should have worked");
      adj_test_assert(var_data->storage.storage_disk_has_value==var_data->storage.storage_disk_is_checkpoint, "Should have worked");
-
-     var_data=var_data->next;
   }
 
 }

=== modified file 'src/tests/test_checkpoint_revolve_multistage.c'
--- src/tests/test_checkpoint_revolve_multistage.c	2011-11-28 10:38:19 +0000
+++ src/tests/test_checkpoint_revolve_multistage.c	2012-01-18 15:51:24 +0000
@@ -552,6 +552,7 @@
   int ierr, i, nb_matched_variables, found_match;
   int duplicates=0; /* Number of variables that are recorded on both disk and memory */
   adj_variable var;
+  adj_variable_hash *varhash;
   adj_variable_data* data_ptr;
   char var_name[ADJ_NAME_LEN];
 
@@ -560,20 +561,15 @@
    * If the variable name matches with a variable name in the expectation list,
    * we check if the the storage and checkpoint type match.
    */
-  data_ptr=adjointer->vardata.firstnode;
-  while (data_ptr!=NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
+  	data_ptr=varhash->data;
     if (data_ptr->equation<0) /* Ignore adjoint variables */
-    {
-      data_ptr=data_ptr->next;
       continue;
-    }
+
     if ((data_ptr->storage.storage_memory_has_value!=ADJ_TRUE) &&
         (data_ptr->storage.storage_disk_has_value!=ADJ_TRUE)) /* Ignore variables that are not recorded */
-    {
-      data_ptr=data_ptr->next;
       continue;
-    }
 
     var = adjointer->equations[data_ptr->equation].variable;
     ierr = adj_variable_str(var, var_name, ADJ_NAME_LEN);
@@ -640,7 +636,6 @@
     	return ADJ_ERR_NEED_VALUE;
     }
 
-    data_ptr=data_ptr->next;
   }
 
   /* At this point we know that the recorded variables is a subset of
@@ -648,23 +643,19 @@
    * expected variables equal, from which we now that both sets are
    * equivalent.
    */
-  data_ptr=adjointer->vardata.firstnode;
   nb_matched_variables=0; /* Number of checkpoint variables in adjointer */
 
-  while (data_ptr!=NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
-    if (data_ptr->equation<0) /* Ignore adjoint variables */
-    {
-      data_ptr=data_ptr->next;
+  	data_ptr=varhash->data;
+  	if (data_ptr->equation<0) /* Ignore adjoint variables */
       continue;
-    }
 
     if (data_ptr->storage.storage_memory_has_value)
       nb_matched_variables++;
     if (data_ptr->storage.storage_disk_has_value)
       nb_matched_variables++;
 
-    data_ptr=data_ptr->next;
   }
 
   /* We expect the number of expected and recorded variables to be the same */

=== modified file 'src/tests/test_checkpoint_revolve_offline.c'
--- src/tests/test_checkpoint_revolve_offline.c	2011-11-28 10:38:19 +0000
+++ src/tests/test_checkpoint_revolve_offline.c	2012-01-18 15:51:24 +0000
@@ -489,6 +489,7 @@
   int ierr, i, nb_matched_variables, found_match;
   int duplicates=0; /* Number of variables that are recorded on both disk and memory */
   adj_variable var;
+  adj_variable_hash *varhash;
   adj_variable_data* data_ptr;
   char var_name[ADJ_NAME_LEN];
 
@@ -497,20 +498,15 @@
    * If the variable name matches with a variable name in the expectation list,
    * we check if the the storage and checkpoint type match.
    */
-  data_ptr=adjointer->vardata.firstnode;
-  while (data_ptr!=NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
+  	data_ptr=varhash->data;
     if (data_ptr->equation<0) /* Ignore adjoint variables */
-    {
-      data_ptr=data_ptr->next;
       continue;
-    }
+
     if ((data_ptr->storage.storage_memory_has_value!=ADJ_TRUE) &&
         (data_ptr->storage.storage_disk_has_value!=ADJ_TRUE)) /* Ignore variables that are not recorded */
-    {
-      data_ptr=data_ptr->next;
       continue;
-    }
 
     var = adjointer->equations[data_ptr->equation].variable;
     ierr = adj_variable_str(var, var_name, ADJ_NAME_LEN);
@@ -577,7 +573,6 @@
     	return ADJ_ERR_NEED_VALUE;
     }
 
-    data_ptr=data_ptr->next;
   }
 
   /* At this point we know that the recorded variables is a subset of
@@ -585,23 +580,19 @@
    * expected variables equal, from which we now that both sets are
    * equivalent.
    */
-  data_ptr=adjointer->vardata.firstnode;
   nb_matched_variables=0; /* Number of checkpoint variables in adjointer */
 
-  while (data_ptr!=NULL)
+  for(varhash=adjointer->varhash; varhash != NULL; varhash=varhash->hh.next)
   {
+  	data_ptr=varhash->data;
     if (data_ptr->equation<0) /* Ignore adjoint variables */
-    {
-      data_ptr=data_ptr->next;
       continue;
-    }
 
     if (data_ptr->storage.storage_memory_has_value)
       nb_matched_variables++;
     if (data_ptr->storage.storage_disk_has_value)
       nb_matched_variables++;
 
-    data_ptr=data_ptr->next;
   }
 
   /* We expect the number of expected and recorded variables to be the same */