Crash Recovery CSC 375 Fall 2012 R&G - Chapter 18

Transcription

1 Crash Recovery CSC 375 Fall 2012 R&G - Chater 18 If you are going to be in the logging business, one of the things that you have to o is to learn about heavy equiment. Robert VanNatta, Logging History of Columbia County

2 Review: The ACID roerties Atomicity: All actions in the Xact haen, or none haen. Consistency: If each Xact is consistent, an the DB starts consistent, it ens u consistent. Isolation: Execution of one Xact is isolate from that of other Xacts. Durability: If a Xact commits, its effects ersist. Question: which ones oes the Recovery Manager hel with? Atomicity & Durability (an also use for Consistency-relate rollbacks)

3 Motivation Atomicity: Transactions may abort ( Rollback ). Durability: What if DBMS stos running? (Causes?) Desire state after system restarts: T1 & T3 shoul be urable. T2, T4 & T5 shoul be aborte (effects not seen). T1 T2 T3 T4 T5 Commit Abort Commit crash!

4 Big Ieas Write Ahea Logging (WAL) an how it interacts with the buffer manager ARIES Recovery algorithm Reeats History in orer to simlify the logic of recovery. Must hanle arbitrary failures Even uring recovery!

5 Assumtions Concurrency control is in effect. Strict 2PL, in articular. ates are haening in lace. i.e. ata is overwritten on (elete from) the actual age coies (not rivate coies). Can you think of a simle scheme (requiring no logging) to guarantee Atomicity & Durability? What haens uring normal execution (what is the minimum lock granularity)? What haens when a transaction commits? What haens when a transaction aborts?

6 Buffer Management Plays a Key Role One ossible aroach Force/No Steal: Force make sure that every uate age is written to isk before commit. Provies urability without REDO logging. But, can cause oor erformance. No Steal on t allow buffer-ool frames with uncommite uates to overwrite committe ata on isk. seful for ensuring atomicity without NDO logging. But can cause oor erformance.

7 Preferre Policy: Steal/No-Force This combination is most comlicate but allows for highest flexibility/erformance. NO FORCE (comlicates enforcing Durability) What if system crashes before a moifie age written by a committe transaction makes it to isk? Write as little as ossible, in a convenient lace, at commit time, to suort REDOing moifications. STEAL (comlicates enforcing Atomicity) What if the Xact that erforme uates aborts? What if system crashes before Xact is finishe? Must remember the ol value of P (to suort NDOing the write to age P).

8 Buffer Management summary No Steal Steal No Steal Steal No Force Fastest No Force No NDO REDO NDO REDO Force Slowest Force No NDO NDO No REDO No REDO Performance Imlications Logging/Recovery Imlications

9 Basic Iea: Logging Recor REDO an NDO information, for every uate, in a log. Sequential writes to log (ut it on a searate isk). Minimal info (iff) written to log, so multile uates fit in a single log age. Log: An orere list of REDO/NDO actions Log recor contains: <XID, ageid, offset, length, ol ata, new ata> an aitional control info (which we ll see soon).

10 Write-Ahea Logging (WAL) The Write-Ahea Logging Protocol: 1) Must force the log recor for an uate before the corresoning ata age gets to isk. 2) Must force all log recors for a Xact before commit. (transaction is not committe until all of its log recors incluing its commit recor are on the stable log.) #1 (with NDO info) hels guarantee Atomicity. #2 (with REDO info) hels guarantee Durability. This allows us to imlement Steal/No-Force We ll look at the ARIES algorithms from IBM.

11 WAL & the Log DB RAM LSNs agelsns flushelsn Each log recor has a unique Log Sequence Number (LSN). LSNs always increasing. Each ata age contains a agelsn. The LSN of the most recent log recor for an uate to that age. System kees track of flushelsn. max LSN flushe to stable log so far. WAL (rule 1): For a age i to be written must flush log at least to the oint where: agelsn i flushelsn agelsn i Log recors flushe to isk flushelsn Page i Log tail in RAM

12 Log Recors LogRecor fiels: for uate recors only LSN revlsn XID tye ageid length offset before-image after-image revlsn is the LSN of the revious log recor written by this transaction (i.e., the recors of an Xact form a linke list backwars in time) Possible log recor tyes: ate, Commit, Abort Checkoint (for log maintainence) Comensation Log Recors (CLRs) for NDO actions En (en of commit or abort)

13 Other Log-Relate State (in memory) Two in-memory tables: Transaction Table One entry er currently active transaction. entry remove when Xact commits or aborts Contains: XID (i.e., transactioni), status (running/committing/aborting), lastlsn (most recent LSN written by Xact) Dirty Page Table One entry er irty age currently in buffer ool. Contains reclsn -- the LSN of the log recor that first cause the age to be irty.

14 Normal Execution of an Xact Assume: Strict 2PL concurrency control STEAL, NO-FORCE buffer management, with WAL. Disk writes are atomic (i.e., all-or-nothing) Transaction is a series of reas & writes, followe by commit or abort. ate TransTable on transaction start/en For each uate oeration: create log recor with LSN l = ++MaxLSN an revlsn = TransTable[XID].lastLSN; uate TransTable[XID].lastLSN = l if moifie age NOT in DirtyPageTable, then a it with reclsn = l When buffer manager relaces a irty age, remove its entry from the DPT

15 Transaction Commit Write commit recor into log. Flush all log recors u to Xact s commit recor to log isk. WAL Rule #2: Ensure flushelsn ³ lastlsn. Force log out u to lastlsn if necessary Note that log flushes are sequential, synchronous writes to isk an many log recors er log age. so, cheaer than forcing out the uate ata an inex ages. Commit() returns. Write en recor to log.

16 Simle Transaction Abort For now, consier an exlicit abort of a Xact. No crash involve. We want to lay back the log in reverse orer, NDOing uates. Write an Abort log recor before starting to rollback oerations. Get lastlsn of Xact from Transaction table. Can follow chain of log recors backwar via the revlsn fiel. For each uate encountere: Write a CLR (comensation log recor) for each unone oeration. no the oeration (using before image from log recor).

17 Abort, cont. To erform NDO, must have a lock on ata! No roblem (we re oing Strict 2PL)! Before restoring ol value of a age, write a CLR: You continue logging while you NDO!! CLR has one extra fiel: unonextlsn Points to the next LSN to uno (i.e. the revlsn of the recor we re currently unoing). CLRs are never none (but they might be Reone when reeating history: guarantees Atomicity!) At en of NDO, write an en log recor.

18 Abort Examle (no crash) A b t C lr 5 13 C o m 14 C lr 2 15 E n C h k unonextlsn revlsn

19 Checkointing Concetually, kee log aroun for all time. Obviously this has erformance/imlemenation roblems Perioically, the DBMS creates a checkoint, in orer to minimize the time taken to recover in the event of a system crash. Write to log: begin_checkoint recor: Inicates when chkt began. en_checkoint recor: Contains current Xact table an irty age table. This is a `fuzzy checkoint : Other Xacts continue to run; so these tables accurate only as of the time of the begin_checkoint recor. No attemt to force irty ages to isk; effectiveness of checkoint limite by olest unwritten change to a irty age. Store LSN of most recent chkt recor in a safe lace (maste recor).

20 The Big Picture: What s Store Where LOG LogRecors revlsn XID tye ageid length offset before-image after-image DB Data ages each with a agelsn master recor LSN of most recent checkoint RAM Xact Table lastlsn status Dirty Page Table reclsn flushelsn

21 Crash Recovery: Big Picture Olest log rec. of Xact active at crash Smallest reclsn in irty age table after Analysis Last chkt CRASH A R Start from a checkoint (foun via master recor). Three hases. Nee to: 1. Analysis - uate structures: Trans Table: which Xacts were active at time of crash. Dirty Page Table: which ages might have been irty in the buffer ool at time of crash. 2. REDO all actions. (reeat history) 3. NDO effects of faile Xacts.

22 Recovery: The Analysis Phase Re-establish knowlege of state at checkoint. via transaction table an irty age table store in the checkoint Scan log forwar from checkoint. En recor: Remove Xact from Xact table. All Other recors: A Xact to Xact table, set lastlsn=lsn, change Xact status on commit. also, for ate recors: If age P not in Dirty Page Table, A P to DPT, set its reclsn=lsn. At en of Analysis transaction table says which xacts were active at time of crash. DPT says which irty ages might not have mae it to isk

23 Phase 2: The REDO Phase We reeat History to reconstruct state at crash: Realy all uates (even of aborte Xacts!), reo CLRs. Scan forwar from log rec containing smallest reclsn in DPT. Q: why start here? For each uate log recor or CLR with a given LSN, REDO the action unless: Affecte age is not in the Dirty Page Table, or Affecte age is in D.P.T., but has reclsn > LSN, or agelsn (in DB) ³ LSN. (this last case requires I/O) To REDO an action: Realy logge action. Set agelsn to LSN. No aitional logging, no forcing!

24 Phase 3: The NDO Phase Tono={lastLSNs of all Xacts in the Trans Table} Reeat: Choose (an remove) largest LSN among Tono. If this LSN is a CLR an unonextlsn==nll Write an En recor for this Xact. If this LSN is a CLR, an unonextlsn!= NLL A unonextlsn to Tono Else this LSN is an uate. no the uate, write a CLR, a revlsn to Tono. ntil Tono is emty.

25 Abort Examle (after crash) A b t C lr 5 13 C o m 14 C lr 2 15 E n C h k unonextlsn revlsn

26 Examle of Recovery (u to crash) RAM Xact Table lastlsn status Dirty Page Table reclsn flushelsn Tono LSN LOG begin_checkoint en_checkoint uate: T1 writes P5 uate T2 writes P3 T1 abort CLR: no T1 LSN 10, nonxt=null T1 En uate: T3 writes P1 uate: T2 writes P5 CRASH, RESTART

27 Examle (cont.):analysis & Reo Xact Table Trans lastlsn Stat T1 T a r T2 T r Dirty Page Table PageI reclsn P5 10 LSN 00 LOG begin_checkoint 05 en_checkoint 10 uate: T1 writes P5 20 uate T2 writes P3 30 T1 abort 40 CLR: no T1 LSN 10, nonxt=null 45 T1 En 50 uate: T3 writes P1 60 uate: T2 writes P5 CRASH, RESTART P3 20 P1 50 Reo starts at LSN 10; in this case, reas P5, P3, an P1 from isk, reoes os if agelsn < LSN

28 Ex (cont.): no & Crash During Restart! After Analysis/Reo: Tono: 50 & 60 Tono: 50 & 20 Tono: 20 After Analysis/Reo: Tono: 70 Tono: 20 Tono: Finishe! begin_checkoint, en_checkoint uate: T1 writes P5;Prvl=null uate T2 writes P3; Prvl = null T1 abort CLR: no T1 LSN 10 T1 En uate: T3 writes P1; PrvL=null uate: T2 writes P5; PrvL=20 CRASH, RESTART CLR: no T2 LSN 60; nonxtlsn=20 CLR: no T3 LSN 50;noNxtLSN=null T3 en CRASH, RESTART CLR: no T2 LSN 20;noNxtLSN=null T2 en

29 Ex (cont.): no & Crash During Restart! After Analysis/Reo: Tono: 50 & 60 Tono: 50 & 20 Tono: 20 After Analysis/Reo: Tono: 70 Tono: 20 Tono: Finishe! begin_checkoint, en_checkoint uate: T1 writes P5;Prvl=null uate T2 writes P3; Prvl = null T1 abort CLR: no T1 LSN 10 T1 En uate: T3 writes P1; PrvL=null uate: T2 writes P5; PrvL=20 CRASH, RESTART CLR: no T2 LSN 60; nonxtlsn=20 CLR: no T3 LSN 50;noNxtLSN=null T3 en CRASH, RESTART CLR: no T2 LSN 20;noNxtLSN=null T2 en

30 Aitional Crash Issues What haens if system crashes uring Analysis? During REDO? How to reuce the amount of work in Analysis? Take frequent checkoints. How o you limit the amount of work in REDO? Frequent checkoints lus Flush ata ages to isk asynchronously in the backgroun (uring normal oeration an recovery). Buffer manager can o this to uninne, irty ages. How o you limit the amount of work in NDO? Avoi long-running Xacts.

31 Summary of Logging/Recovery Transactions suort the ACID roerties. Recovery Manager guarantees Atomicity & Durability. se Write Ahea Longing (WAL) to allow STEAL/NO-FORCE buffer manager without sacrificing correctness. LSNs ientify log recors; linke into backwars chains er transaction (via revlsn). agelsn allows comarison of ata age an log recors.

32 Summary, Cont. Checkointing: A quick way to limit the amount of log to scan on recovery. Aries recovery works in 3 hases: Analysis: Forwar from checkoint. Rebuil transaction an irty age tables. Reo: Forwar from olest reclsn, reeating history for all transactions. no: Backwar from en to first LSN of olest Xact alive at crash. Rollback all transactions not comlete as of the time of the crash. Reo reeats history : Simlifies the logic! on no, write CLRs. Nesting structure of CLRS avois having to uno uno oerations.