بازیافت شفاف در سیستمهای توزیع شده Transparent Recovery in Distributed Systems

We are investigating transparent optimistic solutions to problems in distributed systems such as recovery [6], replication [3], parallelization [2], and concurrent competing alternatives [4]. By a transparent solution to such a problem we mean that a program is transformed automatically, and that the behavior of the program is equivalent to a possible behavior of the untransformed program; in addition, the programmer and the end-user need not be aware of the transformation. Transparent solutions to such problems are relatively straightforward if synchronization is relied upon, but performance of such methods is generally poor or the implementation is too expensive, and they do not scale. Our approach is to use optimistic methods in which we guess that synchronization is unnecessary, and verify this asynchronously while the program continues execution. We track inter-process dependencies and log non-deterministic events so that we can roll back a computation that depends upon an incorrect guess. Where virtual memory virtualizes the space of a process, we virtualize time, “paging in” a previous process state when a “time fault” (or incorrect guess) occurs. 2 Optimistic Recovery Our approach to recovery is based upon optimistic recovery [6] enhanced by optimizations to reduce the amount of logging [5, 1] and extensions which incorporate the filesystem and other external components into the recovery process [7, 8]. In optimistic recovery, we guess that processors do not fail; specifically, for every non-deterministic event (usually a message), we guess that there will not be a failure before that message has been asynchronously logged. Each of these guesses is assigned a number, and each process records the highest-numbered guess of every other process upon which it depends. In the event of a failure, the failed process is restarted and then synchronized with its neighbors by rolling back to a mutually consistent state. Thus recovery is more expensive than in a conservative mechanism, but failurefree performance is substantially improved because checkpointing, logging, and much of committing can be done asynchronously and concurrently with the normal execution of the program.