checkpointing.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 ADOL-C -- Automatic Differentiation by Overloading in C++
 File:     checkpointing.h
 Revision: $Id$
 Contents: Provides all checkointing interfaces.
 
 Copyright (c) Andreas Kowarz
 
 This file is part of ADOL-C. This software is provided as open source.
 Any use, reproduction, or distribution of the software constitutes
 recipient's acceptance of the terms of the accompanying license file.
 
----------------------------------------------------------------------------*/
 
#ifndef ADOLC_CHECKPOINTING_H
#define ADOLC_CHECKPOINTING_H
 
#include <adolc/adolcexport.h>
#include <adolc/internal/common.h>
#include <array>
#include <stack>
 
class adouble;
 
namespace ADOLC::CP {
 
using TimeStepFunction = int(size_t dimX, adouble *state);
 
using TimeStepFunctionDouble = int(size_t dimX, double *state);
 
using SaveFunction = void *(void);
 
using RestoreFunction = void(void *);
 
namespace detail {
 
using StackElement = std::array<double *, 2>;
 
struct Infos {
  ~Infos() { clearStack(); }
  // id of the outer tape, used to get checkpoint in the cp_fos_forward... and
  // reverse methods later
  short tapeId{0};
  TimeStepFunction *function{nullptr};
  TimeStepFunctionDouble *function_double{nullptr};
  SaveFunction *saveNonAdoubles{nullptr};
  RestoreFunction *restoreNonAdoubles{nullptr};
  int steps{0};
  int checkpoints{0};
 
  // Id of the tape that stores the checkpointing steps. This id
  // should not be confused with the id of the tape that calls
  // the checkpointing process later
  short cpTapeId{0};
  bool retaping{0}; /* != 0 forces retaping before every reverse step */
 
  int dim{0};              /* number of variables in input and output (n=m) */
  adouble *adp_x{nullptr}; /* input of the first step */
  adouble *adp_y{nullptr}; /* output of the last step; will be set by ADOLC */
 
  int check{0};
  int capo{0};
  int fine{0};
  int info{0};
  int currentCP{0};
  double *dp_internal_for{nullptr};
  size_t index{0};
  // unsued but required to be stored in our custom buffer type
  char *allmem{nullptr};
  std::stack<StackElement> cpStack;
 
  void takeSnapshot();
 
  void restore();
 
  void release();
 
  void clearStack();
 
  void tapeStep(int keep) const;
 
  void revolveForward(int keep);
 
  void revolveError();
};
} // namespace detail
class ADOLC_API Context {
public:
  Context() = delete;
 
  Context(short tapeId, short tapeIdCheck, TimeStepFunction timeStepFunction) {
    registerTimeStepFunction(tapeId, tapeIdCheck, timeStepFunction);
  }
 
  ~Context() = default;
 
  void setDoubleFct(TimeStepFunctionDouble timeStepFunction) {
    cpInfos->function_double = timeStepFunction;
  }
 
  void setSaveFct(SaveFunction saveState) {
    cpInfos->saveNonAdoubles = saveState;
  }
 
  void setRestoreFct(RestoreFunction restoreState) {
    cpInfos->restoreNonAdoubles = restoreState;
  }
 
  void setNumberOfSteps(int number) { cpInfos->steps = number; }
 
  void setNumberOfCheckpoints(int number) { cpInfos->checkpoints = number; }
 
  void setDimensionXY(int dim) { cpInfos->dim = dim; }
 
  void setInput(adouble *x) { cpInfos->adp_x = x; }
 
  void setOutput(adouble *y) { cpInfos->adp_y = y; }
 
  void setAlwaysRetaping(bool state) { cpInfos->retaping = state; }
 
  int checkpointing(short tapeId);
 
private:
  void registerTimeStepFunction(short tapeId, short tapeIdCheck,
                                TimeStepFunction timeStepFunction);
  detail::Infos *cpInfos;
};
 
} // namespace ADOLC::CP
 
using ADOLC_TimeStepFuncion = ADOLC::CP::TimeStepFunction;
using ADOLC_TimeStepFuncion_double = ADOLC::CP::TimeStepFunctionDouble;
using ADOLC_saveFct = ADOLC::CP::SaveFunction;
using ADOLC_restoreFct = ADOLC::CP::RestoreFunction;
using CpInfos = ADOLC::CP::detail::Infos;
using CP_Context = ADOLC::CP::Context;
 
/****************************************************************************/
#endif /* ADOLC_CHECKPOINTING_H */