Transactions Explained

[torgeadelin]

Hi!
I'm trying to understand more how transactions work and I implemented an older version of transactions from the java sodium in scala. I'm not too sure I understand what's happening behind the scenes.

import java.lang.Comparable
import collection.mutable.PriorityQueue
import scala.collection.mutable.ArrayBuffer
import java.util.concurrent.atomic.AtomicLong

trait Handler[T] {
  def run(a: T)
}

class Entry(var rank: Node, var action: Handler[Transaction])
    extends Comparable[Entry] {
  override def compareTo(other: Entry): Int = {
    rank.compareTo(other.rank)
  }
}

class Transaction() {

  private val pq = new PriorityQueue[Entry]()
  private var last: List[Runnable] = List()

  def prioritized(rank: Node, action: Handler[Transaction]) {
    pq += new Entry(rank, action)
  }

  def last(action: Runnable) {
    last = last ++ List(action)
  }

  // Close the transaction
  def close() {
    while (!pq.isEmpty)
      pq.dequeue().action.run(this);

    last.foreach(_.run())
    last = List()
  }
}

object Transaction {
  def evaluate[A](code: Transaction => A): A = {
    val trans: Transaction = new Transaction()
    try {
      code(trans)
    } finally {
      trans.close()
    }
  }

  def run(code: Handler[Transaction]) {
    val trans: Transaction = new Transaction()
    try {
      code.run(trans)
    } finally {
      trans.close()
    }
  }
}

Everything seems to work, (I also have the rest of the components Streams and Cells and everything).
Does anybody have a bit of time to explain what all methods are responsible for and what they do in the context of the library? I would appreciate a simple explanation.

I apologise if this sounds silly but I'm trying to understand this better.

Thanks a bunch!

[cubuspl42]

Are you familiar with how transactions work from library user's perspective, and asking specifically about the implementation details?

[torgeadelin]

Hi!
I have a rough idea on how transactions work from the user's perspective. I know they work similar to transactions in other context like writing to a database type of transaction. But I think would be worth explaining it from the user's perspective as well.

But I'm interested in the implementation details as well.
Thanks

[cubuspl42]

Have you read the book?

[torgeadelin]

Yes, but I feel like it covers the concept super briefly. (or maybe is it just me that I found it vague).
I know executing a transaction has two steps: 1. process all stream event simultaneously and 2. update all cell values atomically. I also know that a transaction represents a "moment" in the application. I know other frp libraries used monads for this(another topic which I find hard to understand).

The thing is that I'm not coming from a background of functional programming nor reactive programming. I'm currently working on my final year project for my BSc degree in university and that's the reason why I'm trying to understand this better. My project is about FRP.

I hope this gives a bit more perspective.

[cubuspl42]

What you said is basically everything. I'm quite sure that the book covers transactions from user's perspective fully. You can download the PDF (I believe it's free for every copy of the book) and search for the word "transaction".

You are right that the book doesn't really cover the implementation part of Sodium, which is a pity. Actually, Stephen wrote some post that might interest you in another thread. He explains how the priority queue algorithm works and also quotes a paper that describes it in detail.

You can also do a simple exercise:

Take your favourite language (from the ones supported by Sodium). After ensuring that you understand how operators work semantically, try to reimplement the API using the simplest approach that comes to your mind. Instead of analyzing the Sodium implementation, which is non-trivial, because it's kinda optimized and handles memory management.

[torgeadelin]

Thanks for your response!
The exercise seems a great idea! I'll definitely follow your advice!

[cubuspl42]

Feel free to ask more questions when you encounter issues during the implementation!

[torgeadelin]

Hi! @cubuspl42, I have a quick question regarding the Transactions.
If we look at the cell implementation in Scala:

we create a new transaction called trans2, where we push a function to the last method. I know that in a transaction there are two collections, prioritised which is the priority queue and there's also a list called last. From what I understood, prioritised holds all outstanding jobs while updating the value of a cell. What is the last list used for though? I noticed the actions stored in this list are ran last (where i think the names comes from). I find it hard why we need it in the context of the code form the image.

[clinuxrulz]

last simply makes sure the current value of the Cell is updated AFTER the current transaction, and BEFORE any transaction after it. Its so that all streams during the same transaction can snapshot the same value of any one cell. (consistency among snapshots.)

[torgeadelin]

Thank you @clinuxrulz. Totally makes sense now!