spinoza 0.1 → 0.2

data/lib/spinoza/system/store.rb

@@ -1,44 +1,45 @@
 require 'sequel'
+require 'set'
 require 'spinoza/system/operation'
 
 # Represents the storage at one node. In our model, this consists of an
-# in-memory sqlite database with some very simple tables.
+# in-memory sqlite database with some very simple tables. The state of the
+# store is exactly the sqlite database.
 class Spinoza::Store
-  def initialize *table_specs
+  attr_reader :tables
+
+  def initialize *tables
     @db = Sequel.sqlite
-    @table_specs = table_specs
 
-    table_specs.each do |table_spec|
-      @db.create_table table_spec.name do
-        table_spec.column_specs.each do |col|
+    tables.each do |table|
+      @db.create_table table.name do
+        table.columns.each do |col|
           case col.type
           when "integer", "string", "float"
             column col.name, col.type, primary_key: col.primary
           else
             raise ArgumentError,
-              "Bad col.type: #{col.type} in table #{table_spec.name}"
+              "Bad col.type: #{col.type} in table #{table.name}"
           end
         end
       end
     end
-  end
-  
-  def tables
-    @db.tables
+
+    @tables = Set[*@db.tables]
   end
   
   def inspect
-    "<#{self.class.name}: #{tables.join(', ')}>"
+    "<#{self.class.name}: #{tables.to_a.join(', ')}>"
   end
   
   # Execute the operations on this store, skipping any that do not refer to
-  # a table in this store.
+  # a table in this store. Returns array of all read results.
   def execute *operations
     results = operations.map do |op|
       if tables.include? op.table
         op.execute @db[op.table]
       end
     end
-    results.grep(ReadResult)
+    results.grep(Spinoza::ReadResult)
   end
 end

data/lib/spinoza/system/{table-spec.rb → table.rb}

@@ -1,11 +1,11 @@
 require 'spinoza/common'
 
-# Defines the schema for one table in all replicas.
-class Spinoza::TableSpec
+# Defines the schema for one table in all replicas. No state.
+class Spinoza::Table
   attr_reader :name
-  attr_reader :column_specs
+  attr_reader :columns
   
-  class ColumnSpec
+  class Column
     attr_reader :name
     attr_reader :type
     attr_reader :primary
@@ -23,9 +23,13 @@ class Spinoza::TableSpec
   #
   def initialize name, **specs
     @name = name
-    @column_specs = []
+    @columns = []
     specs.each_with_index do |(col_name, col_type), i|
-      @column_specs << ColumnSpec.new(col_name, col_type, (i==0))
+      @columns << Column.new(col_name, col_type, (i==0))
     end
   end
+  
+  class << self
+    alias [] new
+  end
 end

data/lib/spinoza/system/timeline.rb

@@ -0,0 +1,81 @@
+require 'rbtree'
+require 'spinoza/common'
+
+# Events are the way we model the passage of time in a concurrent system. An
+# event action initiates some action at some time. The action happens
+# instantaneously on the timeline, except by scheduling later events.
+class Spinoza::Event
+  attr_reader :time, :actor, :action, :data
+
+  class << self; alias [] new; end
+
+  def initialize time: raise, actor: raise, action: raise, **data
+    @time, @actor, @action, @data = time, actor, action, data
+  end
+  
+  def dispatch
+    if data.empty?
+      actor.send action
+    else
+      actor.send action, **data
+    end
+  end
+end
+
+# A timeline of events, future and past, and a current time.
+class Spinoza::Timeline
+  class Error < StandardError; end
+  
+  attr_reader :now, :future, :history
+  
+  def initialize
+    @history = MultiRBTree.new
+    @future = MultiRBTree.new
+    @now = 0.0
+  end
+  
+  def schedule event
+    @future[event.time] = event
+  end
+  alias << schedule
+  
+  # Dispatches the next event. If several events are scheduled at the same time,
+  # dispatches the one that was scheduled first. Returns nil if nothing is
+  # scheduled, otherwise returns current time, which is when the event was
+  # dispatched. Dispatched events are stored in a history timeline. Does not
+  # advance time if there is no event scheduled.
+  def step
+    time, event = @future.shift
+    return nil unless time
+    dispatch_event event
+    return now
+  end
+  
+  # Dispatches all events in sequence for the next +dt+ units of time, in other
+  # words, all events scheduled in the interval `now..now+dt`. If several events
+  # are scheduled at the same time, dispatches the one that was scheduled first.
+  # Dispatched events are stored in a history timeline. Returns the time at the
+  # end of the interval, which may be later than the time of any dispatched
+  # event. Advances time even if no events exist in the interval.
+  def evolve dt
+    t_end = now + dt
+    loop do
+      time, event = @future.first
+      break if not time or time > t_end
+      @future.shift
+      dispatch_event event
+      yield event if block_given?
+    end
+    @now = t_end
+  end
+
+  private def dispatch_event event
+    if event.time < now
+      raise Error, "Event scheduled in the past: #{event}"
+    end
+
+    @now = event.time
+    @history[event.time] = event
+    event.dispatch
+  end
+end

data/lib/spinoza/transaction.rb

@@ -1,56 +1,187 @@
 require 'spinoza/system/operation'
+require 'set'
 
-class Spinoza::Transaction
-  attr_reader :ops
+# A transaction is just a list of operations, each on a specific table and key.
+#
+# The ACID guarantees are not provided by this class. Rather, this
+# class is just common representation of a (very simple) kind of transaction
+# that can be used by Calvin and other transaction engines built on top of
+# the system model.
+#
+# Transactions submitted to Calvin are not as general as this class indicates.
+# They should be split up into transactions each of which consists of reads
+# followed by writes, and the row IDs of the writes should be independent of the
+# read results. This is necessary for the Scheduler and the Readcaster
+# protocols. (See the discussion of OLLP in the Calvin papers.)
+#
+# Like the operations they are composed of, transactions are stateless and do
+# not reference any particular store. Hence they can be re-used in different
+# replicas.
+#
+module Spinoza
+  def transaction(&b)
+    Transaction.new(&b)
+  end
+
+  class Transaction
+    class RowLocation
+      def initialize txn, table, key
+        @txn, @table, @key = txn, table, key
+      end
+
+      def insert row
+        if @key and not @key.empty?
+          raise ArgumentError, "Do not specify key in `at(...).insert(...)`."
+        end
+        @txn << InsertOperation.new(@txn, table: @table, row: row)
+      end
+
+      def update row
+        @txn << UpdateOperation.new(@txn, table: @table, row: row, key: @key)
+      end
+
+      def delete
+        @txn << DeleteOperation.new(@txn, table: @table, key: @key)
+      end
 
-  class RowLocation
-    def initialize txn, table, key
-      @txn, @table, @key = txn, table, key
+      def read
+        @txn << ReadOperation.new(@txn, table: @table, key: @key)
+      end
     end
-    
-    def insert row
-      @txn.ops << InsertOperation.new(@txn, table: @table, row: row)
+
+    # Build a transaction using a DSL. Example:
+    #
+    # txn = transaction do
+    #   at(:persons, name: "Fred").update(age: 41, phrase: "yabba dabba doo")
+    #   at(:persons, name: "Wilma").delete
+    #   at(:persons, name: "Barney").read
+    #   at(:persons).insert(name: "Betty", age: 65)
+    # end
+    #
+    # node.store.execute txn # ==> [ReadResult(...)]
+    #
+    # If the block takes an argument, then the Transaction instance is passed,
+    # and the block is not instance_eval-ed.
+    #
+    # If you create a transaction without using the block interface, you
+    # must call #closed! before using the transaction.
+    #
+    def initialize &block
+      @ops = []
+      @closed = false
+      @read_set = {}
+      @write_set = {}
+
+      if block
+        if block.arity == 0
+          instance_eval &block
+        else
+          yield self
+        end
+        closed!
+      end
     end
 
-    def update row
-      @txn.ops << UpdateOperation.new(@txn, table: @table, row: row, key: @key)
+    class StateError < StandardError; end
+
+    def closed?
+      @closed
     end
 
-    def delete
-      @txn.ops << DeleteOperation.new(@txn, table: @table, key: @key)
+    def closed!
+      assert_open!
+      @closed = true
     end
 
-    def read
-      @txn.ops << ReadOperation.new(@txn, table: @table, key: @key)
+    def assert_closed!
+      unless closed?
+        raise StateError, "transaction must be closed to call that method."
+      end
     end
-  end
 
-  # A txn is just a list of operations, each on a specific table and key.
-  # The ACID guarantees are not provided by this class.
-  #
-  # Example:
-  #
-  # txn = transaction do
-  #   at(:persons, name: "Fred").update(age: 41, phrase: "yabba dabba doo")
-  #   at(:persons, name: "Wilma").delete
-  #   at(:persons, name: "Barney").read
-  #   at(:persons).insert(name: "Betty", age: 65)
-  # end
-  #
-  # node.store.execute txn # ==> [ReadResult(...)]
-  #
-  def initialize &block
-    @ops = []
-    if block
-      if block.arity == 0
-        instance_eval &block
+    def assert_open!
+      if closed?
+        raise StateError, "transaction must be open to call that method."
+      end
+    end
+
+    def at table, **key
+      RowLocation.new(self, table, key)
+    end
+
+    INSERT_KEY = :insert
+
+    def << op
+      assert_open!
+
+      case op
+      when ReadOperation
+        if reads_a_write?(op)
+          warn "reading your writes in a transaction may not be supported #{op}"
+        end
+        (@read_set[op.table] ||= Set[]) << op.key
+      when InsertOperation
+        (@write_set[op.table] ||= Set[]) << INSERT_KEY
       else
-        yield self
+        (@write_set[op.table] ||= Set[]) << op.key
       end
+      @ops << op
+    end
+
+    def reads_a_write? op
+      s = @write_set[op.table]
+      s && s.include?(op.key)
+    end
+
+    # {table => Set[key, ...]}
+    def read_set
+      assert_closed!
+      @read_set
+    end
+
+    # Set[table, table, ...]
+    def read_tables
+      @read_tables ||= Set[*read_set.keys]
+    end
+
+    # {table => Set[key|INSERT_KEY, ...]}
+    # where existence of INSERT_KEY means presence of inserts in txn
+    def write_set
+      assert_closed!
+      @write_set
+    end
+
+    # Set[table, table, ...]
+    def write_tables
+      @write_tables ||= Set[*write_set.keys]
+    end
+
+    def all_read_ops
+      assert_closed!
+      @all_read_ops ||= @ops.grep(ReadOperation)
+    end
+
+    def all_write_ops
+      assert_closed!
+      @all_write_ops ||= @ops - all_read_ops
+    end
+
+    def ops
+      assert_closed!
+      @ops
+    end
+
+    # returns true iff node_or_store contains elements of write set
+    def active? node_or_store
+      write_tables.intersect? node_or_store.tables
+    end
+
+    def all_reads_are_local? node_or_store
+      read_tables.subset? node_or_store.tables
+    end
+
+    def remote_read_tables node_or_store
+      read_tables - node_or_store.tables
     end
-  end
-  
-  def at table, **key
-    RowLocation.new(self, table, key)
   end
 end

data/lib/spinoza/version.rb

@@ -1,3 +1,3 @@
 module Spinoza
-  VERSION = "0.1"
+  VERSION = "0.2"
 end

data/test/test-executor.rb

@@ -0,0 +1,110 @@
+require 'minitest/autorun'
+require 'spinoza/calvin/executor'
+require 'spinoza/system/store'
+require 'spinoza/system/table'
+require 'spinoza/transaction'
+
+class TestExecutor < Minitest::Test
+  include Spinoza
+  
+  class MockReadcaster
+    def initialize store
+      @store = store
+      @tables = store.tables
+    end
+    
+    def execute_local_reads txn
+      local_read_ops = txn.all_read_ops.select {|r| @tables.include? r.table}
+      @store.execute *local_read_ops
+    end
+    
+    def serve_reads txn, local_read_results; end
+  end
+
+  def setup
+    @store = Store.new(
+      Table[:as, id: "integer", name: "string"],
+      Table[:bs, id: "integer", name: "string"])
+
+    @executor = Calvin::Executor.new(
+      store: @store,
+      readcaster: MockReadcaster.new(@store))
+  end
+  
+  def test_passive_txn
+    txn = transaction do
+      at(:as, id: 1).read
+      at(:bs, id: 2).read
+      at(:cs).insert id: 3, name: "c3"
+      at(:ds, id: 4).read
+    end
+    
+    assert @executor.passive? txn
+
+    result = @executor.execute_transaction txn
+    assert result
+    assert_equal 2, result.size
+    assert_equal txn.ops[0..1], result.map {|r| r.op}
+    assert @executor.ready?
+  end
+  
+  def test_txn_with_no_remote_reads
+    txn = transaction do
+      at(:as).insert id: 1, name: "a1"
+      at(:bs, id: 2).read
+      at(:cs).insert id: 3, name: "c3"
+    end
+    
+    refute @executor.passive? txn
+    assert @executor.all_reads_are_local? txn
+
+    result = @executor.execute_transaction txn
+    assert result
+    assert_equal 1, result.size
+    assert_equal txn.ops[1], result.map {|r| r.op}[0]
+    assert @executor.ready?
+  end
+  
+  def test_txn_with_remote_reads
+    txn = transaction do
+      at(:as).insert id: 1, name: "a1"
+      at(:bs, id: 2).read
+      at(:cs, id: 3).read
+      at(:cs, id: 4).read
+      at(:ds, id: 5).read
+    end
+
+    refute @executor.passive? txn
+    
+    result = @executor.execute_transaction txn
+    refute result
+    refute @executor.ready?
+    
+    result = @executor.recv_remote_reads :cs, [
+      ReadResult.new(val: {id: 3}),
+      ReadResult.new(val: {id: 4})
+    ]
+    refute result
+    refute @executor.ready?
+
+    # Same data, different replica:
+    result = @executor.recv_remote_reads :cs, [
+      ReadResult.new(val: {id: 3}),
+      ReadResult.new(val: {id: 4})
+    ]
+    refute result
+    refute @executor.ready?
+
+    result = @executor.recv_remote_reads :ds, [
+      ReadResult.new(val: {id: 5})
+    ]
+    assert result
+    assert @executor.ready?
+    assert_equal 4, result.size
+    
+    local_read = result.shift
+    refute local_read.val # never wrote this one
+
+    assert_equal Set[3,4,5], Set[*result.map {|r| r.val[:id]}]
+  end
+end