Transactions Scribe

Owned by Stephen M. Rumble
Last updated: Apr 02, 2010Version comment
2 min read

Keith Adams: can transactions apply across tables?

Mike Franklin: Is the temporary merged _tx_ object permanent?

  • Diego folds them down

Bob English: what if client crashes between mask of original objects and the
super object is written? (1. and 2. slide 9)

  • Tombstones

John: Masks are leased?

  • Nope.

Marcos Aguilera: Periodically write heartbeats to t.

Finkelstein: how many messages are involved in doing all of these client side
steps?

Marcos Aguilera: atomic writes, but not serializability

  • no isolation (question)

Finkelstein: yes, you do have isolation

  • well, only on writes

John: concerned with counts of RPC RTTs for client & 2pc methods

Marcos Aguilera: wondering whether we actually need transactions: do we expect
multiple servers to contend?

will applications commonly be doing write sharing? read sharing
should be common, but writes?

Mike Franklin: Will there be write-write conflicts?

Keith Adams: Would like the feature to handle write-write conflicts.

Confusion of masks being on write side of transactions only.

  • they're on both read and write sides, says Diego

Marcos Aguilera: Arguing for transactions - e.g. facebook wall concurrent accesses.

John: Question - NoSQL systems not doing transactions across multiple objects.
So, do we need this feature?

  • Armbrust: All NoSQL guys have transaction libs built on top.
  • Keith Adams: RAMCloud needs a transaction story, even if it's just
    a client lib.

John: Question - Alternative transaction methods (i.e. not mini-transactions)?

  • Franklin: Use snapshot approaches - readers don't interfere with
    writers.
  • Armbrust: Need get by version or get by time operations.
  • John: Get by time not safe - clock synch needed.
  • Finkelstein:
  • "Entity groups"
  • Some operations are commutative - so eventual consistency
    is possible
  • should consider having these operations in ramcloud

John: Question - What's least functionality in servers so users can get what
they want with best possible performance?

  • Marcos Aguilera: May want optimistic/pessimistic switch - adaptive
    method based on contention.
  • Finkelstein: Should define reasonable application models.
  • Keith Adams: Transactions relatively rare and people use them very
    carefully.

Keith Adams: Some people really hate specific instances of eventual consistency
(e.g. "message read/unread" bit not taking effect in email app)

Bob English: On relaxed consistency: Transition between 0 and 1 the big deal.
People don't care about 4 vs. 5 (e.g. do I have any new emails vs
do I have 4 or 5 new emails?)