1. 1 Recovery System 1. Failure classification 2. Storage structure 3. Data access 4.Recovery & atomicity 5. Log-based recovery 6. Shadow paging 7. Recovery with Concurrent transactions 8. Buffer management 9. Failure with loss of nonvolatile storage

2. 2 1. Failure classification A. System crash: caused by power failure, hardware or software failure The non-volatile storage content is not corrupted B. Disk failure: head crash, surface scratch The disk storage is destroyed completely or in part C. Transaction failure: 1. Logical errors: transaction cannot complete due to some internal error condition 2. System errors: DBMS must terminate an active transaction due to an error condition (e.g. deadlock)

3. 3 2. Storage structure A. Volatile storage: main memory, cache memory does not survive system crashes B. Nonvolatile memory:disks, tapes survives system crashes C. Stable storage:survives all failures! does not exist usually, it is aproximated by maintaining multiples copies on distinct nonvolatile media

4. 4 Techiques to implement a stable-storage: Replicate data: to maintain multiple copies of each block on separate disks copies can be at remote sides to protect against disasters (fire, flooding,..) failure during data transfer can result in inconsistent copies ==>

5. 5 Protecting storage media from failure during data transfer: (let us suppose two copies of each block): 1. Write the information onto the first physical block 2. When the first write successfully completes, write the same information on the second physical block 3. The output is completed only after the second write successfully completes

6. 6 Copies of a block may differ due to failure during output operation To recover from failure: 1. Find inconsistent blocks A. Compare the two copies of every disk block (expensive!) B. Record in-progress disk writes on non-volatile storage. Use this information during recovery to find blocks that may be inconsistent, and only compare copies of these 2. Recover: A. if either copy of an incosistent block is detected to have an error (bad checksum), overwrite it by the other copy B. if both have no error, but are different, overwrite the second block by the first block

7. 7 3. Data access Physical block = a block residing on the disk Buffer block = a block temporarily residing in main memory Block movement between disk & main memory : input(B):transfer the physical block B to main memory output(B):transfer the buffer block B to the disk and replace the appropiate physical block there disk memory input(B) output(B)

8. 8 Each transaction T i has its private work-area used to keep local copies of all data items X accessed and updated by it: T i ‘s local copy of a data item X is called x i Assumption: Each data item fits in and is stored inside a single block Transaction transfers data items between system buffer blocks and its private work area using the following operations: read(X): assigns the value of data item X to the local variable x i write(X): assigns the value of local variable x i to data item X in the buffer block

9. 9 Transactions perform read(X) while accessing X for the first time All subsequent accesses are to the local copy. After last access, transaction executes write(X). output(B X ) need not immediately follow write(X): System can perform the output operation when it deems fit. If the block B X in which X resides is not already in memory:==> the transaction must issue an input(B X ) instruction before the assignment

10. 10 A B disk memory Global buffer AB Local buffer T 1 Local buffer T 2 A B A Input(A) Output(B) Read(A) Write(B)

11. 11 4. Recovery and atomicity Example: let us consider transaction T that transfer £100 from account A to account B The goal is either to perform all database modifications made by T or none at all Several output operations may be required for T (to output A and B). A failure may occur after one of these modifications have been made but before all of them are made To ensure atomicity despite failures, we first output information describing the modifications to stable storage, without modifying the database itself. ==> many approaches We assume (initially) that transactions run serially, that is one after the other.

12. 12 5. Log-based recovery Log =a sequence of log records, is kept on stable memory maintains a record of update activities on the database 1. When transaction T i starts, it registers itself by writing a log record 2. Before T i executes write(X), a log record is written, where V 1 is the value of X before the write and V 2 is the value to be written to X 3. When transaction T i finishes its last statement, the log record is written We assume for now that log records are written directly to stable storage (that is, they are not buffered).

13. 13 This scheme ensures atomicity despite failures by recording all modifications to log, but deferring all the writes to after partial commit. Deffered database modification Assume that transactions execute serially. 1.Transaction T i starts by writing a log record to log 2. A write(X) results in a log record being written, where V is the new value for X. The write is not performed on X at this time, but is deferred. 3. When transaction T i partially commits, is written to the log 4. Finally, log records are used to actually execute the previuosly deferred writes.

14. 14 During a recovery after a crash, a transaction needs to be redone iff both and are there in the log. To redo a transaction = to set the value of all data items updates by the transaction to the new values Crashes can occur while the transaction is executing the original updates, or while recovery action is being taken read(A) A:=A-100 write(A) read(B) B:=B + 100 write(B) T0T0 read(C) C:=C-100 write(C) T1T1 Example transaction T 0 executes before T 1

15. 15 Below we show the log as it appears at three instances of time: a b c

16. 16 If log on stable storage at time of crash is as in case a.==> no redo actions need to be taken b. ==> redo(T 0 ) must be performed, since is present c. ==> redo(T 0 ) must be performed followed by redo(T 1 ), since and are present

17. 17 Immediate database modification Allows database updates of an uncommitted transaction to be made as the writes are issued. Since undoing may be needed, update logs must have both old and new values Update log records must be written before database item is written Output of updated blocks can take place at any time before or after transaction commit Orders in which blocks are output can be different from the order in which they are written

18. 18 LogWrite Output A=900 B=2100 C=400 B B, B C BABA B X denotes block containing X

19. 19 Recovery procedure has two oprations (instead of one): undo(T i ) restores the value of all data items updated by T i to their old values, going backwards from the last log record for T i redo(T i )sets the value of all data items updated by T i to the new values, going forward from the first log record for T i

20. 20 When recovering after failure: 1. Transaction T i needs to be undone if the log contains the record but does not contain the record 2. Transaction T i needs to be redone if the log contains both the record and the record 3. Undo operations are performed first, then redo operations

21. 21 Example: we show the log as it appears at three instances of time: a b c Which are the recovery actions in each case?

22. 22 Recovery actions in each case above are: a:undo(T 0 ): B is restored to 2000 and A is restored to 1000 b:undo(T 1 ) and redo(T 0 ): C is restored to 500 and A and B are set to 900 and 2100, respectively c:redo(T 0 ) and redo(T 1 ): A and B are set to 900 and 2100, respectively. Then C is set to 400

23. 23 Checkpoints The recovery procedure we discussed above raise some problems: 1. Searching the entire log is time-consuming 2. We might unnecessarily redo transactions which have already output their updates to the database We can streamline recovery procedure by periodically performing checkpointing: 1. Output all log records currently residing in main memory onto stable storage 2. Output all modified buffer blocks to the disk 3. Write a log record onto stable memory

24. 24 During recovery we need to consider only the most recent transaction T i that started before the checkpoint and transactions that started after T i 1. Scan backwards from end of log to find the most recent record 2. Continue scanning backwards till a record is found 3. Need only consider the part of log following the above start record. Earlier part of log can be ignored during recovery and can be erased whenever desired. 4. For all transactions (starting from T i or later) with no, execute undo(T i ). (Done only in case of immediate modification) 5. Scanning forward in the log, for all transactions starting from T i or later with a, execute redo (T i ).

25. 25 Example of checkpoints: time TcTc TfTf T1T1 T2T2 T3T3 T4T4 checkpoint failure T 1 can be ignored ( updates already output to disk due to checkpoint) T 2 and T 3 redone T 4 undone

26. 26 6. Shadow paging It is an alternative to log-based recovery Idea: Maintain 2 page tables during the lifetime of a transaction: the current page table, and the shadow page table Store the shadow page table in nonvolatile storage, such that the state of the database prior to transaction execution may be recovered. Shadow page table is never modified during execution. To start with, both the page tables are identical. Only current page table is used for data item accesses during execution of the transaction Whenever any page is about to be written for the first time, a copy of this page is made onto an unused page. The current page table is then made to point to the copy, and the update is performed on the copy.

27. 27 Example of shadow paging: after write to page 4 Pages on disk 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 Shadow page table Current page table

28. 28 To commit a transaction: 1. Flush all modified pages in main memory to disk 2. Output current page table to disk 3. Make the current page table the new shadow page table: a. keep a pointer to the shadow page table at a fixed (known) location on disk b. update the pointer to point to current page table on disk 4. Once pointer to shadow page table has been written, transaction is commited No recovery is needed after a crash: new transactions can start right away, using the shadow page table Pages not pointed to from current/shadow page table should be freed (garbage collected)

29. 29 Shadow-paging vs. log-based schemes: Advantages: no overhead of writing log records recoverey is trivial Disadvantages: commit overhead is high (many pages need to be flushed) data gets fragmented (related pages get separated) after every transaction completion, the database pages containing old versions of modified data need to be garbage collected and put into the list of unused pages hard to exted algorithm to allow transactions to run concurrently

30. 30 7. Recovery with concurrent transactions We modify the log-based recovery schemes to allow multiple transactions to execute concurrently: all transactions share a single disk buffer and a single log - log records of different transactions may be interspersed - a buffer block can have data items updated by one or more transactions We assume concurrency control using strict two-phase locking (the updates of uncommitted transactions should not be visible to other transactions) The checkpointing technique and actions taken on recovery have to be changed, since several transactions may be active when a checkpoint is performed.

31. 31 Checkpoints are performed as before, except that the checkpoint log record is now of the form, where L is the list of transactions active at the time of the checkpoint. When a system recovers from a crash: 1. Initialize undo-list and redo-list to empty 2. Scan the log backwards from the end, stopping when the first record is found. 3. For each record found during the scan: a. if the record is, add T i to redo-list b. if the record is, then if T i is not in redo-list, add T i to undo-list 4. For every T i in L, if T i is not in redo-list, add T i to undo-list

32. 32 At this point: undo-list consists of incomplete transactions which must be undone redo-list consists of finished transactions that must be redone 5. Scan log backwards from most recent record, stopping when records have been encountered for every T i in undo-list During the scan, perform undo for each log record that belongs to a transaction in undo-list 6. Locate the most recent record 7. Scan log forwards from the record till the end of the log During the scan, perform redo for each log record that belongs to a transaction on redo-list.

33. 33 Example of recovery using the following log: /* scan in step 5 stops here */

34. 34 8. Buffer management Log-record buffering: log records are buffered in main memory, instead of being output directly to stable storage log records are output to stable storage when a block of log records in the buffer is full, or a log force operation is executed Several log records can thus be output using a single output operation, reducing the I/O cost.

35. 35 Rules to be followed if log records are buffered: 1. Log records are output to stable storage in the order in which they are created 2. Transction T i enters the commit state after the log record has been output to stable storage 3. Before a block of data in main memory is output to the database, all log records pertaining to data in that block must have been output to stable memory. (WAL=Write-Ahead Logging rule) As a result of the WAL rule, if a block with uncommitted updates is output to disk, log records with undo information for the updates are output to the log on stable storage first.

36. 36 Log force is performed to commit a transaction by forcing all its log records (including the commit record) to stable storage. The previous checkpoint algorithm requires that no updates should be in progress on a block when it is output to disk. This can be ensurd as follows: 1. Before writing a data item, transaction aquires exclusive lock on block containing the data item 2. Lock can be released once the write is completed. (In literature, such locks held for short duration are called latches). 3. Before a block is output to disk, the system aquires an exclusive lock on the block

37. 37 Implementation of a database buffer: in an area of real main - memory reserved for database in virtual memory In main-memory: memory is partitioned before-hand between database buffer and applications, limiting flexibility needs may change, and although operating system knows best how memory shoul be divided up at any time, it cannot change the partitioning of memory

38. 38 In virtual memory: when operating system needs to evict a page that has been modified, the page is written to swap space on disk when database decides to write buffer page to disk, buffer page may be in swap space, and may have to be read from disk and written to another location to disk, resulting in extra I/O (known as dual paging problem) ideally when swapping out a database buffer page, operating system should pass control to database, which in turn outputs the page to database instead of to swap space (making sure to output log records first) dual paging can thus be avoid, but common operating systems do not support such functionality

39. 39 9. Failure with loss of nonvolatile storage 1. Periodically dump the entire content of the DB to stable storage 2. No transaction may be active during the dump procedure but a procedure similar to checkpointing must take place: a. output all log records currently residing in main memory onto stable memory b. output all buffer blocks onto the disk c. copy the contents of the database to stable storage d. output a record to log on stable storage 3. To recover from disk failure, restore DB from most recent dump. Then log is consulted and all transactions that committed since the dump are redone.