Analysis of Transaction Management Performance
 ==============================================

 Dan Duchamp, 1989

 Overview: The paper describes the Camelot transaction system, focusing
           on the optimizations that made the system faster.

 Brief description:

   - Runs atop Mach OS

   - Somebody who wants to make available a database, sets up a data server.

   - Four processes run on each machine: Disk manager, communication manager,
     transaction manager and recovery manager.

   - Disk manager implements write-ahead logging. There is one log.

   - The recover manager comes into play only if there is a failure. It
     reads the log and instructs servers to do undo/redo of interrupted
     transactions.

   - An application initiates a transaction by getting the transaction ID
     from the transaction manager.

   - Whenever it wants some interaction with some data server (local or
     remote) to be part of this transaction, it includes the TID as a
     parameter. [Data servers are allowed to invoke other data servers]

   - A data server, upon receiving a request from an application,
     informs the transaction manager, who keeps track of all data servers
     that participate in every transaction on that node.

   - All messages to remote machines are routed through the communication
     manager who snoops on all messages. When a response message leaves
     a site, the communication manager at that site intercepts the message
     and before forwarding it, adds to it the list of sites used to generate
     the response. This list is removed from the message by the communication
     manager at the destination site and merged with the lists sent
     in previous messages

   - Any site can decide to abort the transaction. The originating application
     can decide to commit.
     Transactions then run a 2-phase commit protocol.

 Optimizations:

   - Presumed Abort protocol [required one less log write]

   - Three phase commit [Non-blocking]
     This improves upon the 2-phase commit protocol which is blocking
     if the central server dies.

   - Multithreading allows one thread to make progress while another
     is blocked, say while doing a log write.

   - Group commit (log batching) improves throughput at the cost of
     longer latency per transaction.

 Question: What is the difference between Camelot and Quicksilver?