Transcript Document 7626080

Rollback by
Reverse Computation
Kevin Hamlen
CS717: Fault-Tolerant Computing
Research on
Reversible Computation
• Quantum Computing
– Quantum Computation (Nielsen & Chuang)
• Nanocomputers
– Ralph Merkle @ Zyvex (http://www.merkle.com)
• Low-power processor design
– http://www.ai.mit.edu/~cvieri/reversible.html
• Computational Complexity Theory
– Time and Space Bounds for Reversible Simulation (Buhrman, Tromp, and
Vitányi)
• Parallel Programs & Fault Tolerance
– Carothers (RPI), Perumalla (Georgia Tech), and Fujimoto (Georgia Tech)
Georgia Tech Time Warp (GTW)
“General purpose parallel discrete event simulation executive”
• General purpose simulator
– telecommunication network simulations
– commercial air traffic simulations
• Parallel
– Shared memory
– Message passing
• Event-based
– Each computation and each event associated with a
stimulus event
• Executes programs written in C/C++ w/API calls
Optimistic Synchronization
• Incorrect computations permitted
– Roll back when error detected
• Direct cancellation
State-Saving
• Copy state-saving – copy of entire state
saved before every event
• Periodic state-saving – copy of entire state
saved before every pth event
• Incremental state-saving – copy of only
modified state saved before every event
• Reversible Computing – copy of only
destroyed state data saved before every
event
Advantages of Reversible
Computing
• Lower space overhead for saved state
• Lower time overhead in non-rollback case
• Cost of state-saving amortized over duration
of computation
• Advantages most pronounced in finegrained settings (i.e. many events each
associated with small computations)
Reversing C Programs
Original
Reversible
Reverse
int x=0, y=1;
int x=0, y=1;
bit b;
int x=0, y=1;
bit b;
f’()
{
b = (x>y);
if (b)
y += x;
else
x += y;
}
rf’()
{
if (b)
y -= x;
else
x -= y;
}
f()
{
if (x>y)
y += x;
else
x += y;
}
Note: If S is the state, then we need rf’(f’(S))==S. However
we don’t care about the result of f’(rf’(S)).
RCC: Reverse C Compiler
•
•
•
•
Transforms arbitrary C programs
Each function made reversible
A reverse of each function is generated
GTW Executive modified to call function
reverses during rollback
Saving Destroyed State Data:
The Tape Driver Abstraction
SAVE_BYTES(var) – push var onto the tape and increment
the tape pointer by sizeof(var)*8
RESTORE_BYTES(var) – pop var from the tape and
decrement the tape pointer by sizeof(var)*8
SAVE_BITS(var, n) – push the n low-order bits of var onto the
tape; increment the tape pointer by n
RESTORE_BITS(var, n) – pop n bits from the tape and store
them in the n low-order bits of var; decrement the tape pointer
by n
RCC’s Transformation
Original
Reversible
Reverse
int x=0, y=1;
int x=0, y=1;
f()
{
if (x>y)
y += x;
else
x += y;
}
f’()
{
char c=!!(x>y);
if (c)
y += x;
else
x += y;
SAVE_BITS(c,1);
}
rf’()
{
char c;
RESTORE_BITS(c,1);
if (c)
y -= x;
else
x -= y;
}
RCC Compilation Procedure
Original
C Program
Normalize
Transform
Optimize
Reversible
C Program
w/reverses
Normalization Post-conditions
• Only one assignment per expression. No
other side-effects in such an expression
except possibly a single function call.
• for() loops replaced by equivalent while()’s.
• Conditional expressions are side-effect free.
• Only one return statement per function. It
has the form “return;” or “return var;”
• break’s and continue’s replaced by goto’s.
Two Unusual Normalizations
• All floating point datatypes promoted to
strictly higher precision types
– Software emulation of a new highest-precision
datatype may be necessary.
• Abnormal exit (via goto) from a block
requires saving all variables which are
about to go out of scope.
– Analogous to how C++ handles implicit
destructor calls
Transformation Phase:
Block Scopes
Original
Reversible
Reverse
{
{
{
int x, y;
s1
s2
s3
int x, y;
s1
s2
s3
SAVE(x);
SAVE(y);
}
}
int x, y;
RESTORE(y);
RESTORE(x);
rs3
rs2
rs1
}
Interesting Transformations
• Function pointer calls – maintain a hash
table of the reverses of functions
• Labeled join points – introduce a variable to
record the source of the jump
• Loops – introduce a counter variable to
record the number of iterations
Optimization Phase
• Irreversible operations ignored (e.g. output,
network message sends)
• Kernel-reversible operations are special
cases (e.g. message cancellation)
• Dataflow analysis on reverses (esp.
initializer expressions)
• Invariant detection (esp. conditionals)
• Tape compression (esp. loops)
References
C. Carothers, K. S. Perumalla, R. M. Fujimoto.
“Efficient Optimistic Parallel Simulations using
Reverse Computation.” In Proceedings of 13th
Workshop on Parallel and Distributed Simulation,
May 1999.
K.S. Perumalla and R. M. Fujimoto. “Source code
transformations for efficient reversibility.”
Technical Report, GIT-CC-99-21, College of
Computing, Georgia Institute of Technology.