Patent Application
20240103859
The present application relates to computer processing systems, and more specifically, to a system and method for divide-and-conquer checkpointing, such as binomial checkpointing which eliminates the need for user annotation.
Algorithm Differentiation (AD) is an established enterprise that seeks to take the derivatives of functions specified as computer programs through symbolic manipulation rather than finite differencing. Reverse-mode AD can be thought of as taking a data-flow graph f that maps an n-dimensional input vector to an m-dimensional output vector, and augments it to also map an m-dimensional vector (a co-tangent of the output vector) to an n-dimensional vector (the consequent co-tangent of the input vector). If we say z=f(x), then reverse-mode AD maps z* to x*=transpose(J) z*, where J is the Jacobian matrix (the matrix of partial derivatives) of f at x. This is done by constructing an adjoint computation, which has the same data flow graph as f but with the directions of flow reversed (a “reverse sweep”). Propagating values through that data flow graph requires knowing the values that were propagated during the original computation f. Storing these can impose very high memory burden, making this process infeasible when computing f calculates many intermediate values, or equivalently, when computing f takes substantial time. Essentially, the storage burden of reverse-mode AD of f is proportional to the run-time of f.
Checkpoint reverse-mode AD is a method which splits a computation flow graph (say, one computing the function f) into two pieces (so f=h∘g) where the computational burdens of h and g are roughly equal. We can then calculate the reverse-mode AD of f using the reverse-mode AD of h and the reverse-mode AD of g, in turn. Say z=f(x), then the reverse-mode AD of f maps a co-tangent of z, say z*, to a co-tangent of x, say x*. This can be done in two phases if we let y=g(x) and z=h(y), then we can first perform the reverse AD of h to map z* to y*, then perform the reverse AD of g to map y* to x*. Doing this reduces the storage burden by roughly a factor of two, since only half of the intermediate values of the decomposed f need be stored at a time. On the other hand, it requires calculating g(x) twice, first to find y, and again later to store the intermediate values of computing g(x) needed for the reverse-mode AD of g. Doing this in a recursive fashion (where the computation of g(x) and h(y) might each in turn be split into two halves) reduces the storage burden at the expense of extra computation. The term is sometimes generalized to when the computation of f may be divided into more than two pieces; we discuss division into two pieces for the sake of clarity.
Prior art methods have only been able to apply checkpoint reverse-mode AD when the computation of f is done by a loop each iteration of which requires a bounded amount of computation. For example, when the program is in the form of such a loop, breaking the computation z=f(x) into two phases. y=g(x) and z=h(y), can be done as follows: the loop can be run half-way for g, and the remaining half for h. However, this limits the application and prevents use in more complex control architectures. Therefore, improvements are needed in the field.
According to one aspect, the present disclosure provides a system and method which allows the basic checkpoint-reverse-mode AD strategy (of recursively decomposing the computation to reduce storage requirements of reverse-mode AD) to be applied to arbitrary programs: not just programs consisting of loops, but programs with arbitrarily complex control flow. The method comprises (a) transforming the program into a formalism that allows convenient manipulation by formal tools, and (b) introducing a set of operators to allow computations to be decomposed by running them for a given period of time then pausing them, while treating the paused program as a value subject to manipulation.
In the following description and drawings, identical reference numerals have been used, where possible, to designate identical features that are common to the drawings.
The attached drawings are for purposes of illustration and are not necessarily to scale.
In the following description, some aspects will be described in terms that would ordinarily be implemented as software programs. Those skilled in the art will readily recognize that the equivalent of such software can also be constructed in hardware, firmware, or micro-code. Because data-manipulation algorithms and systems are well known, the present description will be directed in particular to algorithms and systems forming part of, or cooperating more directly with, systems and methods described herein. Other aspects of such algorithms and systems, and hardware or software for producing and otherwise processing the signals involved therewith, not specifically shown or described herein, are selected from such systems, algorithms, components, and elements known in the art. Given the systems and methods as described herein, software not specifically shown, suggested, or described herein that is useful for implementation of any aspect is conventional and within the ordinary skill in such arts.
The following terminology shall be interpreted herein as follows: An execution point is a point in time during the execution of a program. A program point is a location in the program code. Since program fragments might be invoked zero or more times during the execution of a program, each execution point corresponds to exactly one program point but each program point may correspond to zero or more execution points. An execution interval is a time interval spanning two execution points. A program interval is a fragment of code spanning two program points. Program intervals are usually constrained so that they nest, i.e., they do not cross one boundary of a syntactic program construct without crossing the other. Each program interval may correspond to zero or more execution intervals, those execution intervals whose endpoints result from the same invocation of the program interval. Each execution interval corresponds to at most one program interval. An execution interval might not correspond to a program interval because the endpoints might not result from the same invocation of any program interval.
A checkpoint can be introduced into a portion of the forward sweep that has been delayed, as shown in
Execution intervals for checkpoints can be specified in a variety of ways: “program interval,” wherein execution intervals of specified program intervals constitute checkpoints, “subroutine call site.” wherein execution intervals of specified subroutine call sites constitute checkpoints, and “subroutine body,” wherein execution intervals of specified subroutine bodies constitute checkpoints. Nominally, these have the same power; with any one, one could achieve the effect of the other two. Specifying a subroutine body may be accomplished by specifying all call sites to that subroutine. Specifying some call sites but not others may be accomplished by having two variants of the subroutine, one whose body is specified and one whose is not, and calling the appropriate one at each call site. Specifying a program interval may be accomplished by extracting that interval as a subroutine.
Certain programming engines, such as TAPENADE, allow the user to specify program intervals for checkpoints with the c$ad checkpoint-start and c$ad checkpoint-end pragmas. Tapenade, by default, checkpoints all subroutine calls. This default can be overridden for named subroutines with the -nocheckpoint command-line option and for both named subroutines and specific call sites with the c$ad nocheckpoint pragma.
Recursive application of checkpointing in a divide-and-conquer fashion, i.e., “treeverse,” can divide the forward and reverse sweep into stages run sequentially. The key idea is that only one stage is live at a time, thus requiring a shorter tape. However, the state of the primal computation at various intermediate execution points needs to be saved as snapshots, in order to (re)run the requisite portion of the primal to allow the forward and reverse sweeps for each stage to run in turn. This process is illustrated in
whose nodes are labeled with execution intervals, the intervals of the children of a node are adjacent, the interval of node is the disjoint union of the intervals of its children, and left children are checkpointed.
One can construct a left-branching binary checkpoint tree over the same root execution interval [u, v) with the split points p0, p1, and p2:
This can also be viewed as constructing an n-ary checkpoint tree:
Where all children but the rightmost are checkpointed. This leads to nested checkpoints for the execution intervals [u, p0), [u, p1), and [u, p2) as shown in
Alternatively, one can construct a right-branching binary checkpoint tree over the same root execution interval [u, v) with the same split points p0, p1, and p2:
This also divides the forward (red) and reverse (blue 1004) sweeps into four stages. With this, the requisite tape length (the maximal length of the red 1002 and blue 1004 segments) can be reduced arbitrarily while running the primal (green line 1000) just once, by saving more snapshots (gold line 1010 and pink line 1012), as shown in
Thus it is shown that divide-and-conquer checkpointing can make the requisite tape arbitrarily small with either left- or right-branching binary checkpoint trees. This involves a space-time tradeoff. The left-branching binary checkpoint trees require a single snapshot but O(t) increase in time for (re)computation of the primal (green 1000). The right-branching binary checkpoint trees require O(t) increase in space for storage of the live snapshots (gold line 1010 and pink line 1012) but (re)run the primal only once.
One can also construct a complete binary checkpoint tree over the same root execution interval [u, v) with the same split points p0, p1, and p2:
This constitutes application of the approach from
Any given divide-and-conquer decomposition of the same root execution interval with the same split points can be viewed as either a binary checkpoint tree or an n-ary checkpoint tree. Thus
Similarly,
Thus, two algorithms to perform divide-and-conquer checkpointing may be distinguished as follows: “binary,” wherein the system constructs a binary checkpoint tree. and “treeverse.” wherein the system constructs an n-ary checkpoint tree.
There is, however, a simple correspondence between associated binary and n-ary check-point trees. The n-ary checkpoint tree is derived from the binary checkpoint tree by coalescing cach maximal sequence of left branches into a single node. Thus as described hereinbelow, that these two algorithms exhibit the same properties.
Note that (divide-and-conquer) checkpointing does not incur any space or time over-head in the forward or reverse sweeps themselves (i.e., the number of violet lines 1008 and the total length of red 1002 and blue 1004 lines). Any space overhead results from the snapshots (gold 1010 and pink 1012 lines) and any time overhead results from (re)computation of the primal (green line 1000).
Several design choices arise in the application of divide-and-conquer checkpointing in addition to the choice of binary vs. n-ary checkpoint trees. For example, what root execution interval(s) should be subject to divide-and-conquer checkpointing? Further, which execution points are candidate split points? The divide-and-conquer process of constructing the checkpoint tree will select actual split points from these candidates. Moreover, what is the shape or depth of the checkpoint tree, i.e., what is the termination criterion for the divide-and-conquer process?
Since the leaf nodes of the checkpoint tree correspond to stages, the termination criterion and the number of evaluation steps in the stage at each leaf node (the length of a pair of red 1002 and blue 1004 lines) are mutually constrained. The number of live snapshots at a leaf (how many gold 1010 and pink 1012 lines are crossed by a horizontal line drawn leftward from that stage, the pair of red 1002 and blue 1004 lines, to the root) depends on the depth of the leaf and its position in the checkpoint tree. Different checkpoint trees, with different shapes resulting from different termination criteria and split points, can lead to a different maximal number of live snapshots, resulting in different storage requirements. The amount of (re)computation of the primal (the total length of the green lines 1000) can also depend on the shape of the checkpoint tree, thus different checkpoint trees, with different shapes resulting from different termination criteria and split points, can lead to different compute-time requirements. Thus different strategies for specifying the termination criterion and the split points can influence the space-time tradeoff.
Note the distinctions between several different approaches to selecting root execution intervals subject to divide-and-conquer checkpointing:
Note further distinctions between several different approaches to selecting candidate split points:
Note a further distinction between several different approaches to specifying the termination criterion and deciding which candidate split points to select as actual split points:
The strategies for selecting actual split points from candidate split points and the associated termination criteria are discussed further hereinbelow.
Divide-and-conquer checkpointing has only been provided in prior art AD systems in special cases. For example, Tapenade allows the user to select invocations of a specified DO loop as the root execution interval for divide-and-conquer checkpointing with the “c$ad binomial-ckp” pragma, taking iteration boundaries of that loop as candidate split points. Tapenade employs binomial selection of split points and a fixed space overhead termination criterion. Note, however, that Tapenade only guarantees this fixed space overhead property for DO loop bodies that take constant time. Similarly adol-c contains a nested taping mechanism for time-integration processes that also performs divide-and-conquer checkpointing. This only applies to code formulated as a time-integration process.
According to one embodiment, the present disclosure provides a system and method for applying divide-and-conquer checkpointing to arbitrary code with no special annotation or refactoring required. An entire specified derivative calculation is taken as the root execution interval, rather than invocations of a specified DO loop. Arbitrary execution points are taken as candidate split points, rather than iteration boundaries. As discussed below, both binary and n-ary (treeverse) checkpoint trees are supported. Furthermore, as discussed below, both bisection and binomial checkpointing are supported. Additionally, all of the above termination criteria are supported: fixed space overhead, fixed time overhead. and logarithmic space and time overhead. Any combination of the above checkpoint-tree generation algorithms, split-point selection methods, and termination criteria are supported. In order to apply this framework, the system must be able to interrupt the primal computation at appropriate execution points, save the interrupted execution state as a capsule, and restart the computation from the capsules, sometimes repeatedly. This is accomplished by building divide-and-conquer checkpointing on top of a general-purpose mechanism for interrupting and resuming computation. This mechanism is orthogonal to AD. The present disclosure provides several example implementations of a framework referred to as “checkpointVLAD.”
Note that one cannot generally achieve the space and time guarantees of divide-and-conquer checkpointing with program-interval, subroutine-call-site, or subroutine-body checkpointing unless the call tree has the same shape as the requisite checkpoint tree. Furthermore, one cannot generally achieve the space and time guarantees of divide-and-conquer checkpointing for DO loops by specifying the loop body as a program-interval checkpoint because such would lead to a right-branching checkpoint tree and behavior analogous to
Some form of divide-and-conquer checkpointing is necessary. One may wish to take the gradient of a long-running computation, even if it has low asymptotic time complexity. The length of the tape required by reverse mode without divide-and-conquer checkpointing increases with increasing run time. Modern computers can execute several billion floating point operations per second, even without GPUs and multiple cores, which only exacerbate the problem. If each such operation required storage of a single eight-byte double precision number, modern terabyte RAM sizes would fill up after a few seconds of computation. Thus without some form of divide-and-conquer checkpointing, it would not be possible to efficiently take the gradient of a computation that takes more than a few seconds.
There are limitations to the divide-and-conquer checkpointing with split points at fixed syntactic program points like loop iteration boundaries. Consider the example in Table 1 below. This example, y=f(x), while contrived, is a simple caricature of a situation that arises commonly in practice, e.g., in adaptive grid methods. Here, the duration of the inner loop varies wildly as some function l(x, i) of the input and the outer loop index, perhaps 2 lg(n)−lg(1+(1007 3 i mod n)), that is small on most iterations of the outer loop but O(n) on a few iterations. If the split points were limited to iteration boundaries of the outer loop, as would be common in existing implementations, the increase in space or time requirements would grow larger than sublinearly. The issue is that for the desired sublinear growth properties to hold, it must be possible to select arbitrary execution points as split points. In other words, the granularity of the divide-and-conquer decomposition must be primitive atomic computations, not loop iterations. The distribution of run time across the program is not modularly reflected in the static syntactic structure of the source code, in this case the loop structure. Often, the user is unaware of or even unconcerned with the micro-level structure of atomic computations and does not wish to break the modularity of the source code to expose such. Yet the user may still wish to reap the sublinear space or time overhead benefits of divide-and-conquer checkpointing. Moreover, the relative duration of different paths through a program may vary from loop iteration to loop iteration in a fashion that is data dependent, as shown by the above example, and not even statically determinable.
ad binomial − ckp n+1
f
indicates data missing or illegible when filed
The present disclosure provides a system and method for divide-and-conquer checkpointing that does not constrain split points to loop iteration boundaries or other syntactic program constructs and does not constrain checkpoints to program intervals or other syntactic program constructs. In certain embodiments, the system implements a computer instruction language, referred to as checkpointVLAD.
The instruction language checkpointVLAD adds builtin AD operators to a functional pre-AD core language. The following constructs are provided:
where e denotes expressions, c denotes constants, x denotes variables, e1 e2 denotes function application, ⋄ denotes builtin unary operators, and ● denotes builtin binary operators. For expository simplicity, the discussion of the core language here omits many vagaries such as support for recursion and functions of multiple arguments; the actual implementation supports these using standard mechanisms that are well known within the programming-language community (e.g., tupling or Currying).
Direct-Style Evaluator for the Core Language: In one embodiment, the system provides a simple evaluator for this core language (see
With any evaluator, one distinguishes between two language evaluation strata: the target, the language being implemented and the process of evaluating programs in that language, and the host, the language in which the evaluator is written and the process of evaluating the evaluator itself. In our case, the target is checkpointVLAD, while the host varies among our three implementations; for the first two it is SCHEME while for the third it is the underlying hardware, achieved by compilation to machine code via C. In the evaluator in e, p
denotes a closure, a lambda expression e together with an environment ρ containing values for the free variables in e. Clause (5) says that one evaluates a lambda expression by returning a closure with the environment in the context that the lambda expression was evaluated in. Clause (6) says that one evaluates an application by evaluating the callee expression to obtain a closure, evaluating the argument expression to obtain a value, and then applying the closure to the value with A. A, as described in (2), evaluates the body of the lambda expression in the callee closure in the environment of that closure augmented with the formal parameter of that lambda expression bound to the argument value. The remaining clauses are all analogous to clause (9), which says that one evaluates an expression e1●e2 in the target by evaluating e1 and e2 to obtain values and then applying ● in the host to these values.
Adding AD Operators to the Core Language: Unlike many AD systems implemented as libraries, the presently disclosed system provides support for AD by augmenting the core language to include builtin AD operators for both forward and reverse mode. This allows seamless integration of AD into the language in a completely general fashion with no unimplemented or erroneous corner cases. In particular, it allows nesting. In checkpointVLAD, we adopt slight variants of the
and
operators previously incorporated into VLAD. (Nothing turns on this. The variants adopted here are simpler, better suit our expository purposes, and allow us to focus on the issue at hand.) In checkpointVLAD, these operators have the following signatures:
We use the notation x′ and x‘ to denote tangent or cotangent values associated with the primal value x respectively, and the notation (x, y) to denote a pair of values. Since in checkpointVLAD, functions can take multiple arguments but only return a single result, which can be an aggregate like a pair, the AD operators take the primal and the associated (co)tangent as distinct arguments but return the primal and the associated (co)tangent as a pair of values.
The operator providesthe portal to forward mode and calls a function f on a primal x with a tangent x′ to yield a primal y and a tangent y′. The
operator provides the portal to reverse mode and calls a function f on a primal x with a cotangent y‘ to yield a primal y and a cotangent x‘. Unlike the original VLAD, here, we restrict ourselves to the case where (co)tangents are ground data values, i.e., reals and (arbitrary) data structures containing reals and other scalar values, but not functions (i.e., closures). Nothing turns on this; it allows us to focus on the issue at hand.
The implementations of VLad and checkpointVLAD are disjoint and use completely different technology. The STALIN ∇ implementation of VLAD is based on source-code transformation, conceptually applied reflectively at run time but migrated to compile time through partial evaluation. The implementation of checkpointVLAD uses something more akin to operator overloading. Again, nothing turns on this; this simplification is for expository purposes and allows us to focus on the issue at hand. In checkpointVLAD, AD is performed by overloading the arithmetic operations in the host, in a fashion similar to FADBAD++. The actual method used is that employed by R6RS-AD and DiffSharp. The key difference is that FADBAD++ uses C++ templates to encode a hierarchy of distinct forward-mode types (e.g., F<double>, F<F<double>>, . . . ), distinct reverse-mode types (e.g., B<double>, B<B<double>>, . . . ), and mixtures thereof (e.g.,, F<B<double>>, B<F<double>>, . . . ) while here, the system uses a dynamic, run-time approach where numeric values are tagged with the nesting level. Template instantiation at compile-time specializes code to different nesting levels. The dynamic approach allows a single interpreter (host), formulated around unspecialized code, to interpret different target programs with different nesting levels.
Augmenting the Direct-Style Evaluator to Support the AD Operators: We add AD into the target language as new constructs:
We implement this functionality by augmenting the direct-style evaluator with new clauses for ε ( and clause (14) for
. These clauses are all analogous to clause (9), formulated around
and
operators in the host. These are defined in (11) and (12). The
and
operators in the host behave like A except that they level shift to perform AD. Just like (A f x) applies a target function f (closure) to a target valuc x,
f x x′) performs forward mode by applying a target function f (closure) to a target primal value x and a target tangent value x′, while
f x y′) performs reverse mode by applying a target function f (closure) to a target primal value x and a target cotangent value y‘.
As described in (11), operates by recursively walking v2, a data structure containing primals, in tandem with v′3, a data structure containing tangents, to yield a single data structure where each numeric leaf value is a dual number, a numeric primal value associated with a numeric tangent value. This recursive walk is denoted as v2
v′3. A is then used to apply the function (closure) v1 to the data structure produced by v2
v′3. Since the input argument is level shifted and contains dual numbers instead of ordinary reals, the underlying arithmetic operators invoked during the application perform forward mode by dispatching on the tags at run time. The call to A yields a result data structure where each numeric leaf value is a dual number. This is then recursively walked to separate out two data structures, one, v4, containing the numeric primal result values, and the other, v′5, containing the numeric tangent result values, which are returned as a pair (v4, v′5) This recursive walk is denoted as let (v4
v′5)=. . . in . . . .
As described in (12), operates by recursively walking v2, a data structure containing primals, to replace each numeric value with a tape node. A is then used to apply the function (closure) v1 to this modified v2. Since the input argument is level shifted and contains tape nodes instead of ordinary reals, the underlying arithmetic operators invoked during the application perform the forward sweep of reverse mode by dispatching on the tags at run time. The call to A yields a result data structure where each numeric leaf value is a tape node. A recursive walk is performed on this result data structure, in tandem with a data structure v‘3 of associated cotangent values, to initiate the reverse sweep of reverse mode. This combined operation is denoted as ((A v1 v2)
v‘3). The result of the forward sweep is then recursively walked to replace each tape node with its numeric primal value and the input value is recursively walked to replace each tape node with the cotangent computed by the reverse sweep. These are returned as a pair (v4, v‘5). This combined operation is denoted as let (v4
v‘5)=. . . in . . . .
An Operator to Perform Divide-and-Conquer Checkpointing in Reverse-Mode AD: The system includes a new AD operator to perform divide-and-conquer checkpointing. The crucial aspect of the design is that the signature (and sematntics) of
is identical to
; they are completely interchangeable, differing only in the space/time complexity tradeoffs. This means that code need not be modified to switch back and forth between ordinary reverse mode and various forms of divide-and-conquer checkpointing, save interchanging calls to →J and
.
Conceptually, the behavior of is shown in
to h and g in steps 3 and 4. This divide-and-conquer behavior is terminated in a base case, when the function f is small, at which point the cotangent is computed with
, in step (0). If step (1) splits a function f into two functions g and h that take the same number of evaluation steps, and we terminated the recursion when f takes a bounded number of steps, the recursive divide-and-conquer process yields logarithmic asymptotic space/time overhead complexity.
The central difficulty in implementing the above is performing step (1), namely splitting a function f into two functions g and h, such that f=h∘g. ideally where we can specify the split point, the number of evaluation steps through f where g transitions into h. A sophisticated user can manually rewrite a subprogram f into two subprograms g and h. A sufficiently powerful compiler or source transformation tool might also be able to do so, with access to nonlocal program text. But an overloading system, with access only to local information, would not be able to.
General-Purpose Interruption and Resumption Mechanism: The presently disclosed system solves this problem by providing an interface to a general-purpose interruption and resumption mechanism that is orthogonal to AD (
Irrespective of how one implements the general-purpose interruption and resumption interface, one can use it to implement the binary bisection variant in the host, as shown in
Continuation-Passing-Style Evaluator: One way of implementing the general-purpose interruption and resumption interface is to convert the evaluator from direct style to what is known in the programming- language art as continuation-passing style (CPS), where functions (in this case ε, A, ,
in the host) take an additional continuation input k and instead of yielding outputs via function-call return, do so by calling the continuation with said output as arguments (
for one-, two-, or three-argument constructs. This evaluates the first argument e1 and calls the continuation (λn l v1 . . . ) with its value v1. This continuation then evaluates the second argument e2 and calls the continuation (λn l v2 . . . ) with its value v2. This continuation computes something, denoted by . . . , and calls the continuation k with the resulting value.
The CPS evaluator threads a step count n and a step limit l through the evaluation process. Each clause of E increments the step count exactly once to provide a coherent fine-grained measurement of the execution time. Clause (16) of E implements interruption. When the step count reaches the step limit, a capsule containing the saved state of the evaluator, denoted [[k, f]], is returned. Here, f is a closure (λ.e), ρ
containing the environment ρ and the expression e at the time of interruption. This closure takes an argument that is not used. The step count n must equal the step limit l at the time of interruption. As will be discussed below, neither the step count nor the step limit need to be saved in the capsule, as the computation is always resumed with different step count and limit values.
Several things about this CPS evaluator are of note. First, all builtin unary and binary operators are assumed to take unit time. This follows from the fact that all clauses for ε, as typified by (28), increment the step count by one. Second, the builtin unary and binary operators in the host are implemented in direct style and are not passed a continuation. This means that clauses (22) and (23), as typified by (28), must call the continuation k on the result of the unary and binary operators. Third, like all builtin operators, invocations of the and
operators, including the application of v1, are assumed to take unit time. This follows from the fact that clauses (26) and (27), again as typified by (28), increment the step count by one. Fourth, like all builtin operators,
and
in the host, in (24) and (25), are implemented in direct style and are not passed a continuation. This means that clauses (26) and (27), as typified by (28), must call the continuation k on the result of
and
. Finally, since
and
receive target functions (closures) for v1, they must apply these to their arguments with A. Since A is written in CPS in the CPS evaluator, these calls to A in (24) and (25) must be provided with a continuation k, a step count n, and a step limit l as arguments. The continuation argument simply returns the result. The step count, however, is restarted at zero, and the step limit is set to ∞. This means that invocations of
and
are atomic and cannot be interrupted internally.
Implementing the General-Purpose Interruption and Resumption Interface with the CPS Evaluator: With this CPS evaluator, it is possible to implement the general-purpose interruption and resumption interface ((λ_e), ρ
]] is returned. The implementation of RESUME (31) calls the evaluator with arguments from the saved capsule. Since the closure in the capsule does not use its argument, an arbitrary value ⊥ is passed as that argument.
Note that calls to A in (24),
(25), PRIMOPS (29), INTERRUPT (30), and RESUME (31) are the only portals into the CPS cvaluator. The only additional call to A is in the evaluator itself, clause (20) of ε. All of the portals restart the step count at zero. Except for the call in INTERRUPT (30), none of the portals call the evaluator with a step limit. In particular, RESUME (31) does not provide a step limit; other mechanisms detailed below provide for interrupting a resumed capsule.
This implementation of the general-purpose interruption and resumption
interface cannot be used to fully implement in the host as depicted in
in the base case, step (0), and INTERRUPT in step (2), must take a target function (closure) for f, because such is what is invoked by the calls to A in
(25) and INTERRUPT (30). As written in
, namely steps (3) and (4), pass (λz.resume z) and (λx.interrupt f x [l/2]) for f. There are two problems with this. First, these are host closures produced by host lambda expressions. not target closures. Second, these call the host functions resume and interrupt that are not available in the target. Thus it is not possible to formulate these as target closures without additional machinery.
Examination of . PRIMOPS is invoked in step (1), INTERRUPT is invoked in steps (2) and (4), and RESUME is invoked in step (3). Of these, PRIMOPS is invoked only in the host, RESUME is invoked only in the target, and INTERRUPT is invoked in both the host and the target. Thus we need to expose interrupt and resume to the target. We do not need to expose PRIMOPS to the target; the implementation in
We expose INTERRUPT and RESUME to the target by adding them to the target language as new constructs:
We implement this functionality by augmenting the CPS evaluator with new clauses for ε (
With appropriate implementations of interrupt and resume expressions in the target language, one can create target closures for the expressions (λz.resume z) and (λx.interrupt f x [l/2]), and use these to formulate a proper implementation of in the host. We formulate a target closure to correspond to (λz.resume z) and denote this as R. The definition is given in (34) in
With (I f l) and R, it is now possible to reformulate the definition of in the host from
in the host is given in
In this proper implementation of in the host, the interrupt and resume operations need to be able to nest, even without nesting of calls to
in the target. The recursive calls to
in the inductive case of
Consider all the ways that evaluations of interrupt and resume expressions can nest. User code will never contain interrupt and resume expressions; they are created only by invocations of I and R. R is only invoked by step (3) of in
in
in
is invoked with some user code for f, i.e., code that does not contain interrupt and resume expressions. The inductive cases for
create a binary checkpoint tree of invocations. The leaf nodes of this binary checkpoint tree correspond to the base case in step (0) where the host
is invoked. At internal nodes, the host INTERRUPT is invoked in step (2). The target closure values that can be passed to the host
and INTERRUPT are constructed from f, I, and R in steps (3) and (4). What is the space of all possible constructed target closures? The constructed target closures invoked along the left spine of the binary checkpoint tree look like the following:
((
. . . (
(
f l0)l1) . . . li−1)li) (37)
with zero or more nested calls to I. In this case li<li−1< . . . <l1<l0, because the recursive calls to in step (4) of
((
. . . (
(
l0)li . . . li−1)li) (38)
with zero or more nested calls to I. In this case, again, li<li−1< . . . <l1<l0, for the same reason. These are the possible target closures f passed to in step (0) or INTERRUPT in step (2) of
in
A string of calls to I as in (37) will result in a nested closure structure whose invocation will lead to nested invocations of interrupt expressions:
(λx,(interrupt f x l)),
(λx,(interrupt f x l)),
. . .
(λx,(interrupt f x l)),
f]
l0]
]
li]. . .
]
li−1]
]
li])
A string of calls to I as in (38) will lalso result in a nested closure structure whose invocation will lead to nested invocations of interrupt expressions.
(λx,(interrupt f x l)),
(λx,(interrupt f x l)),
. . .
(λx,(interrupt f x l)),
(λz,(resume z)), ρ0
]
l0]
]
li]. . .
]
li−1]
]
li]
In both of these, li<li−1<<l1<l0, so the outermost interrupt expression will interrupt first. Since the CPS evaluator only maintains a single step limit, li will be that step limit during the execution of the innermost content of these nested closures, namely f in (39) and (λz.(resume z)), ρ0
in (40). None of the other intervening interrupt expressions will enforce their step limits during this execution. Thus we need to arrange for the capsule created when the step limit li is reached during the execution of f or
(λz.(resume z)), ρ0
to itself interrupt with the remaining step limits li−1, . . . , l1, l0. This is done by rewrapping the closure in a capsule with interrupt expressions. The interruption of f or
(λz.(resume z)), ρ0
will produce a capsule that looks like the following:
k,f
(41)
where the closure f contains only user code, i.e., no interrupt or resume expressions. The f in (41) is wrapped with calls to I to reintroduce the step limits li−1, . . . , l1, l0
k,( . . . (
(
f l0)l1) . . . li−1)
(42)
Which will yield a capsule that looks like the following:
k,
(λx,(interrupt f x l)),
. . .
(λx,(interrupt f x l)),
f]
l0]
]
l1]. . .
]
li−l]
which will interrupt upon resumption. Each such interruption will peel off one interrupt expression. Note that since the closure f in a capsule (41) contains only user code, it will not contain a resume expression. Further, since the wrapping process (43) only introduces interrupt expressions via calls to I (42), and never introduces resume expressions, the closures in capsules, whether wrapped or not, will never contain resume expressions.
When there is no contextual step limit, i.e., when l=∞, the interrupt expression must introduce v3, the step limit specified as the argument to the interrupt expression, as the step limit. This is handled by the then branch of clause (35) in
Capsule resumption happens in one place, the call to A in clause (36) in
As a result of this, all interrupt expressions will appear in one of two places. The first is a preamble (39) or (40) wrapped around either a user function f by (37) or a resume expression in R by (38), respectively. Such will always be invoked either by in the base case, step (0), or by interrupt in step (2), of
in step (0) and interrupt in step (2) won't interrupt before completion of the preamble.
There is one further requirement to allow the CPS evaluator to support
divide-and-conquer checkpointing. The base case use of in step (0) of
(λx.e), ρ
which contains an environment with saved state. This state is visible to
. But the continuation k is a host continuation, which is opaque. Any evaluator variables that it closes over are not visible to
. Thus the implementation of host continuations in the CPS evaluator must employ a mechanism to expose such. When we replace the CPS evaluator with a direct-style evaluator applied to CPS-converted target code, described hereinbelow, this will no longer be necessary since continuations will be represented as target closures which are visible to
.
Augmenting the CPS Evaluator to Support Divide-and-Conquer Checkpointing: The system is further configured to add the operator to the target language as a new construct:
e=
e1 e2 e3 (44)
This functionality is implemented by augmenting the CPS evaluateor with a new clause (45) for ε (shown in instead of
. Note that it is not possible to add the
operator to the direct-style evaluator because the implementation of binary bisection checkpointing is built on the general-purpose interruption and resumption interface which is, in turn, built on the CPS evaluator. Further descriptions below remove this limitations. Also note that since the implementation of binary bisection checkpointing is built on the general-purpose interruption and resumption interface which is, in turn, built on an elevator, it is only available for programs that are evaluated, i.e., for programs in the target, but not for programs in the hose. This limitation is also removed below.
The process in , over step (3), until step (4). Note that recursive calls to
in step (4) extend the life of a snapshot. These are denoted as the black tick marks 1016 on the left of the gold 1010 and pink 1012 lines. In the treeverse algorithm, the lifetime of one snapshot ends at a tick mark by a call to retrieve in one recursive call to treeverse in the while loop of the parent and the lifetime of a new snapshot begins by a call to snapshot in the next recursive call to treeverse in the while loop of the parent. But since the state retrieved and then immediately saved again as a new snapshot is the same, these adjacent snapshot execution intervals can conceptually be merged.
Also note that recursive calls to in in step (3) pass R and a capsule z as the f and x of the recursive call. Thus capsules from one level of the recursion become snapshots at the next level, for all but the base case step (0). Pink lines 1012 in
It is now easy to see that the recursive call tree of the algorithm in
The above depicts just one level of the recursion. If one unrolls the above call tree to a depth of three one obtains the binary checkpoint tree depicted in Appendix A).
CPS Conversion: So far, we have formulated divide-and-conquer checkpointing via a CPS evaluator. This can be—and has been—used to construct an interpreter. A compiler can be—and has been—constructed by generating target code in CPS that is instrumented with step counting, step limits, and limit checks that lead to interrupts. Code in direct style can be automatically converted to CPS using a program transformation known in the programming language community as CPS conversion. Many existing compilers, such as sml/nj for sml, perform CPS conversion as part of the compilation process.
We illustrate CPS conversion for the untyped lambda calculus (
The notation e|k
, denotes the transformation of the expression e to CPS so that it calls the continuation k with the result. There is a clause for
e|k
in
This technique can be extended to thread a step count n and a step limit l through the computation along with the continuation k, and to arrange for the step count to be incremented appropriately. Further, this technique can be applied to the entire target language (
Augmenting the Direct-Style Evaluator to Support CPS-Converted Code and Divide-and-Conquer Checkpointing: The direct-style evaluator must be modified in several ways to support CPS-converted code and divide-and-conquer checkpointing (
Second, we need to modify ε to support these new constructs. We replace clause (2) with clauses (63) and (64) to update A and clauses (5) and (6) with clauses (65)-(68) to update ε. Third, we need to add support for interrupt and resume expressions, as is done with clauses (69) and (70). These are direct-style variants of clauses (35) and (36) from the CPS evaluator and are needed to add support for the general-purpose interruption and resumption interface to the direct-style evaluator when evaluating CPS code. Note that the calls to A from (35) and (36) are modified to use the converted form A4 of A (64) in (69) and (70). Similarly, the calls to continuations from (35) and (36) are modified to use the continuation form A3 of A (63) in (69) and (70). Fourth, the calls to A4 must be modified in the host implementations of the AD operators and
, as is done with (71) and (2). Note that unlike the corresponding (11) and (12), the calls to A4 here take target closures instead of host closures. Fifth, the general-purpose interruption and resumption interface, (29), (30), (33), and (34), must be migrated from the CPS evaluator to the direct-style evaluator as (73)-(76). In doing so, the calls to A4 in primops and interrupt are changed to use (64), the host continuations are modified to be target continuations in (73) and (74), and the lambda expressions in (75) and (76) are CPS converted.
Compiling Direct-Style Code to C: One can compile target checkpointVLAD code, after CPS conversion, to C (
Implementations: Three complete implementations of checkpointVLAD were created. All three accept exactly the same source language in its entirety and are able to run both examples discussed in Section 6 (Appendix A). The first implementation is an interpreter based on the CPS evaluator (
Processor 186 can implement processes of various aspects described herein. Processor 186 can be or include one or more device(s) for automatically operating on data, e.g., a central processing unit (CPU), microcontroller (MCU), desktop computer, laptop computer, mainframe computer, personal digital assistant, digital camera, cellular phone, smartphone, or any other device for processing data, managing data, or handling data, whether implemented with electrical, magnetic, optical, biological components, or otherwise. Processor 186 can include Harvard-architecture components, modified-Harvard-architecture components, or Von-Neumann-architecture components.
The phrase “communicatively connected” includes any type of connection, wired or wireless, for communicating data between devices or processors. These devices or processors can be located in physical proximity or not. For example, subsystems such as peripheral system 120, user interface system 130, and data storage system 140 are shown separately from the data processing system 186 but can be stored completely or partially within the data processing system 186.
The peripheral system 120 can include one or more devices configured to provide information to the processor 186. The processor 186, upon receipt of information from a device in the peripheral system 120, can store such information in the data storage system 140.
The user interface system 130 can include a mouse, a keyboard, another computer (connected, e.g., via a network or a null-modem cable), or any device or combination of devices from which data is input to the processor 186. The user interface system 130 also can include a display device, a processor-accessible memory, or any device or combination of devices to which data is output by the processor 186. The user interface system 130 and the data storage system 140 can share a processor-accessible memory.
In various aspects, processor 186 includes or is connected to communication interface 115 that is coupled via network link 116 (shown in phantom) to network 150. For example, communication interface 115 can include an integrated services digital network (ISDN) terminal adapter or a modem to communicate data via a telephone line; a network interface to communicate data via a local-area network (LAN), e.g., an Ethernet LAN, or wide-area network (WAN); or a radio to communicate data via a wireless link, e.g., WiFi or GSM. Communication interface 115 sends and receives electrical, electromagnetic or optical signals that carry digital or analog data streams representing various types of information across network link 116 to network 150. Network link 116 can be connected to network 150 via a switch, gateway, hub, router, or other networking device.
Processor 186 can send messages and receive data, including program code, through network 150, network link 116 and communication interface 115. For example, a server can store requested code for an application program (e.g., a JAVA applet) on a tangible non-volatile computer-readable storage medium to which it is connected. The server can retrieve the code from the medium and transmit it through network 150 to communication interface 115. The received code can be executed by processor 186 as it is received, or stored in data storage system 140 for later execution.
Data storage system 140 can include or be communicatively connected with one or more processor-accessible memories configured to store information. The memories can be, e.g., within a chassis or as parts of a distributed system. The phrase “processor-accessible memory” is intended to include any data storage device to or from which processor 186 can transfer data (using appropriate components of peripheral system 120), whether volatile or nonvolatile; removable or fixed; electronic, magnetic. optical, chemical, mechanical, or otherwise. Exemplary processor-accessible memories include but are not limited to: registers, floppy disks, hard disks, tapes, bar codes, Compact Discs, DVDs, read-only memories (ROM), erasable programmable read-only memories (EPROM, EEPROM, or Flash), and random-access memories (RAMs). One of the processor-accessible memories in the data storage system 140 can be a tangible non-transitory computer-readable storage medium, i.e., a non-transitory device or article of manufacture that participates in storing instructions that can be provided to processor 186 for execution.
In an example, data storage system 140 includes code memory 141, e.g., a RAM, and disk 143, e.g., a tangible computer-readable rotational storage device such as a hard drive. Computer program instructions are read into code memory 141 from disk 143. Processor 186 then executes one or more sequences of the computer program instructions loaded into code memory 141, as a result performing process steps described herein. In this way, processor 186 carries out a computer implemented process. For example, steps of methods described herein, blocks of the flowchart illustrations or block diagrams herein, and combinations of those, can be implemented by computer program instructions. Code memory 141 can also store data, or can store only code.
Additional disclosure is found in Appendix A, filed herewith, the entirety of which is incorporated herein by reference into the present disclosure.
Various aspects described herein may be embodied as systems or methods. Accordingly, various aspects herein may take the form of an entirely hardware aspect, an entirely software aspect (including firmware, resident software, micro-code, etc.), or an aspect combining software and hardware aspects These aspects can all generally be referred to herein as a “service,” “circuit,” “circuitry,” “module,” or “system.”
Furthermore, various aspects herein may be embodied as computer program products including computer readable program code stored on a tangible non-transitory computer readable medium. Such a medium can be manufactured as is conventional for such articles, e.g., by pressing a CD-ROM. The program code includes computer program instructions that can be loaded into processor 186 (and possibly also other processors), to cause functions, acts, or operational steps of various aspects herein to be performed by the processor 186 (or other processor). Computer program code for carrying out operations for various aspects described herein may be written in any combination of one or more programming language(s), and can be loaded from disk 143 into code memory 141 for execution. The program code may execute, e.g., entirely on processor 186, partly on processor 186 and partly on a remote computer connected to network 150, or entirely on the remote computer.
The invention is inclusive of combinations of the aspects described herein. References to “a particular aspect” and the like refer to features that are present in at least one aspect of the invention. Separate references to “an aspect” (or “embodiment”) or “particular aspects” or the like do not necessarily refer to the same aspect or aspects; however, such aspects are not mutually exclusive, unless so indicated or as are readily apparent to one of skill in the art. The use of singular or plural in referring to “method” or “methods” and the like is not limiting. The word “or” is used in this disclosure in a non-exclusive sense, unless otherwise explicitly noted.
The invention has been described in detail with particular reference to certain preferred aspects thereof, but it will be understood that variations, combinations, and modifications can be effected by a person of ordinary skill in the art within the spirit and scope of the invention.
The present application claims the benefit of U.S. provisional application Ser. No. 62/393,894, filed Sep. 13, 2016, the contents of which are hereby incorporated by reference in its entirety.
This invention was made with government support under 1522954-IIS awarded by the National Science Foundation. The government has certain rights in the invention.
| Number | Date | Country | |
|---|---|---|---|
| 62393894 | Sep 2016 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 17818396 | Aug 2022 | US |
| Child | 18494357 | US | |
| Parent | 16336094 | Mar 2019 | US |
| Child | 17818396 | US |
