D. The rate of vibration failures is 1/30 failures/day, the rate of
surge failures is 1/60 failures/day. The total failure rate is 1/30 +
1/60 = 1/20 failures/day. So the MTTF is 20 days.
A and C. B is wrong because System R would have to re-do winners
regardless of when it does checkpoints; any transaction that commits
after the checkpoint has to be re-done. D is incorrect; System R does
not limit the duration of a transaction.
B. In order for the 10 millisecond seek to take only 10% of
the total segment write time, the segment must take 90 milliseconds
to write. 0.090 seconds * 20 megabytes/second = 1.8 megabytes.
C. A is wrong because Coda compares the storeid in the log with the
storeid on the server. B is wrong because Coda doesn't know about the
internal structure of non-directory files. D is wrong because Coda
checks only write/write conflicts.
A and B. The lecture argued that the high rate of change of
technology makes system design harder, not easier, so C is excluded;
Brooks's lecture (not his book) said the opposite of what answer D
claims.
A, B, and D. C is wrong because X's final value would increment
only by 1, not 2, which is not a result achievable by any one-at-a-time
execution.
D. The change suggested by C doesn't work; suppose T1 writes X,
then T2 reads X, then T1 aborts; now T2 has read a value that is not
equal to that written by the last committed transaction.
A; Write has to abort if a higher-numbered transaction has written
the variable, since if it wrote the variable, the next transaction to
read the variable wouldn't get the value written by the
highest-numbered transaction. C is wrong because T' may already have
committed, and we can't un-do it because some later transaction may
have already read the new value and acted on it.
D. Suppose X starts with the value 7. Then T1 writes 8 to X, then
T2 writes 9 to X. Then T1 aborts, then T2 aborts. The correct final
value of X has to be 7. But the abort of T2 will write 8 to X, since
that was the old value of X that T2 saw. If T2 aborts before T1, T1
will correctly restore the old value of X, so answer C does not
demonstrate the incorrect result.
A and C. Since line E ensures tid >= WriteID(x), answer C is
equivalent to answer A.
B and D. Answers A and C both contradict the order of
interleaving proposed by the figure.
A and D. The BEGIN operation ensures that A is true, and the
WRITE operation aborts any transaction that would violate D. But
commits and aborts of independent transactions can occur in any order.
A. Suppose a transaction sets X to 10, then commits, then the
system fails before it writes X to cell storage. Recover() will not
un-do this transaction, because the log has a commit record in it.
Recover() doesn't have enough information to re-do since Write()
logs only the old value.
