elaine 0.0.3

data/lib/elaine.rb

@@ -0,0 +1,30 @@
+require 'elaine/vertex'
+require 'elaine/worker'
+require 'elaine/coordinator'
+
+require 'singleton'
+
+class PostOffice
+  include Singleton
+
+  def initialize
+    @mailboxes = Hash.new
+    @mutex = Mutex.new
+  end
+
+  def deliver(to, msg)
+    @mutex.synchronize do
+      if @mailboxes[to]
+        @mailboxes[to].push msg
+      else
+        @mailboxes[to] = [msg]
+      end
+    end
+  end
+
+  def read(box)
+    @mutex.synchronize do
+      @mailboxes.delete(box) || []
+    end
+  end
+end

data/lib/elaine/coordinator.rb

@@ -0,0 +1,33 @@
+module Elaine
+  class Coordinator
+    attr_reader :workers
+
+    def initialize(graph, options = {})
+      raise "empty graph" if graph.empty?
+
+      @workers = []
+      @options = {
+        :partitions => 1
+      }.merge(options)
+
+      partition(graph) do |subgraph|
+        @workers << Worker.new(subgraph)
+      end
+    end
+
+    def partition(graph)
+      size = (graph.size.to_f / @options[:partitions]).ceil
+      graph.each_slice(size) { |slice| yield slice }
+    end
+
+    def run
+      loop do
+        # execute a superstep and wait for workers to complete
+        step = @workers.select {|w| w.active > 0}.collect {|w| w.superstep }
+        step.each {|t| t.join}
+
+        break if @workers.select {|w| w.active > 0}.size.zero?
+      end
+    end
+  end
+end

data/lib/elaine/distributed.rb

@@ -0,0 +1,11 @@
+require 'dcell'
+require 'elaine/distributed/coordinator'
+require 'elaine/distributed/worker'
+require 'elaine/distributed/post_office'
+require 'elaine/distributed/vertex'
+
+module Elaine
+  module Distributed
+    # ... code goes here ...
+  end # module Distributed
+end # module Elaine

data/lib/elaine/distributed/coordinator.rb

@@ -0,0 +1,134 @@
+# require 'dnssd'
+# require 'celluloid/io'
+require 'dcell'
+
+module Elaine
+  module Distributed
+    class Coordinator
+      include Celluloid
+      include Celluloid::Logger
+      # finalizer :shutdown
+
+      attr_reader :workers
+      attr_reader :partitions
+      attr_reader :num_partitions
+
+      def initialize(graph: nil, num_partitions: 1, stop_condition: Celluloid::Condition.new)
+        @workers = []
+        @num_partitions = num_partitions
+        @graph = graph
+        info "GOT GRAPH: #{graph}"
+        @partitions = Hash.new
+        @stop_condition = stop_condition
+      end
+
+      def graph=(g)
+        debug "Setting graph"
+        @graph = g
+        debug "done setting graph"
+      end
+
+      def zipcodes
+        zips = {}
+        @partitions.each_pair do |zip, vertices|
+          vertices.each do |vertex|
+            zips[vertex[:id]] = zip
+          end
+        end
+        zips
+      end
+
+      def partition
+        # not sure if we should re-initialize or not
+        @partitions = Hash.new
+
+        size = (@graph.size.to_f / workers.size).ceil
+
+        @graph.each_slice(size).with_index do |slice, index|
+          @partitions[@workers[index]] = slice
+        end
+        
+        @partitions
+      end
+
+      def register_worker(worker_node)
+        # we could, in theory, have multiple workers in the same node, however
+        # i think it makes more sense to just have multiple nodes running on the
+        # same machine instead of multiple workers in a single node
+        # This should be re-evaluated at some point in the future.
+        info "Registering worker: #{worker_node}"
+        unless @workers.include? worker_node
+          @workers << worker_node
+        end
+      end
+
+      def run_until_finished
+        # zipcodes = {}
+        debug "partitioning"
+        partition
+        # debug "Partitions: #{@partitions}"
+
+        # distribute the zipcodes
+        debug "building zipcodes"
+        zips = zipcodes
+        debug "distributing zipcodes"
+        @workers.each do |worker_node|
+          DCell::Node[worker_node][:postoffice].zipcodes = zips
+        end
+
+        # now send the graph
+        debug "distributing graph"
+        @partitions.each_pair do |worker_node, vertices|
+          DCell::Node[worker_node][:worker].init_graph vertices
+        end
+
+
+        debug "Running job"
+        step_num = 0
+        loop do
+          step_num += 1
+          # execute a superstep and wait for workers to complete
+          debug "Initializing superstep #{step_num}"
+          step = @workers.select do |w|
+            DCell::Node[w][:worker].active > 0
+          end.map {|w| DCell::Node[w][:worker].future(:init_superstep)}
+          step.map { |f| f.value }
+
+          debug "Running superstep #{step_num}"
+          step = @workers.select do |w|
+            DCell::Node[w][:worker].active > 0
+          end.map {|w| DCell::Node[w][:worker].future(:superstep)}
+
+          step.map { |f| f.value }
+
+          break if @workers.select { |w| DCell::Node[w][:worker].active > 0 }.size.zero?
+        end
+        debug "Job finished!"
+      end
+
+      def run_job
+        run_until_finished
+      end
+
+      def stop
+        @workers.each do |w|
+          DCell::Node[w][:worker].async.stop
+        end
+        @stop_condition.signal(true)
+      end
+
+      def run_and_stop
+        run_until_finished
+        @stop_condition.signal(true)
+      end
+
+      def vertex_values(&block)
+        @workers.map do |w|
+          worker_node = DCell::Node[w]
+          worker_node[:worker].vertex_values
+        end.flatten
+      end
+
+    end # class Coordinator
+  end # module Distributed
+end # module Elaine

data/lib/elaine/distributed/post_office.rb

@@ -0,0 +1,80 @@
+require 'dcell'
+
+module Elaine
+  module Distributed
+    class PostOffice
+      include Celluloid
+      include Celluloid::Logger
+
+      attr_reader :mailboxes
+      attr_reader :zipcodes
+
+      def initialize
+        @mailboxes = Hash.new
+        @zipcodes = Hash.new
+      end
+
+      def zipcodes=(zipcodes)
+        @zipcodes = zipcodes
+
+        # do we need to initialize all the mailboxes here?
+        # might be smart?
+        @mailboxes = Hash.new
+        my_id = DCell.me.id
+        @zipcodes.each_pair do |k, v|
+          if v == my_id
+            debug "Creating mailbox for: #{k}"
+            @mailboxes[k] = []
+          end
+        end
+
+      end
+
+      def address(to)
+        node = DCell::Node[@zipcodes[to]]
+      end
+
+
+      def deliver(to, msg)
+        
+        node = address(to)
+
+        if node.id.eql?(DCell.me.id)
+          # debug "Delivering to mailbox: #{to}"
+          @mailboxes[to].push msg
+          # debug "Done delivering to mailbox: #{to}"
+          nil
+        else
+          # debug "Delivering message to remote mailbox: #{msg}"
+          node[:postoffice].async.deliver(to, msg)
+          # debug "Finished delivery remnote box: to #{node.id}"
+          nil
+        end
+      end
+
+      def read(mailbox)
+        node = address(mailbox)
+        if node.id.eql?(Dcell.me.id)
+          @mailboxes[mailbox]
+        else
+          node[:postoffice].read mailbox
+        end
+      end
+
+      def read_all(mailbox)
+        node = address(mailbox)
+        # debug "node: #{node}"
+        # debug "node.id: '#{node.id}'"
+        # debug "DCell.me.id: '#{DCell.me.id}'"
+        if node.id.eql?(DCell.me.id)
+          msgs = @mailboxes[mailbox].map { |v| v }
+          @mailboxes[mailbox].clear
+          msgs
+        else
+          raise "Can't destructively read a non-local mailbox!"
+        end
+      end
+
+    end # class PostOffice
+  end # module Distributed
+end # module Elaine

data/lib/elaine/distributed/vertex.rb

@@ -0,0 +1,52 @@
+require 'celluloid'
+module Elaine
+  module Distributed
+    class Vertex
+      # include Celluloid
+      # include Celluloid::Logger
+
+      attr_reader :id
+      attr_accessor :value, :messages
+
+      def initialize(id, value, postoffice, outedges)
+        # Might be better to grab post_office dynamically with Celluloid::Actor ?
+        @id = id
+        @value = value
+        @outedges = outedges
+        @messages = []
+        @active = true
+        @superstep = 0
+        @postoffice = postoffice
+      end
+
+      def edges
+        block_given? ? @outedges.each {|e| yield e} : @outedges
+      end
+
+      def deliver_to_all_neighbors(msg)
+        edges.each {|e| deliver(e, msg)}
+      end
+
+      def deliver(to, msg)
+       @postoffice.async.deliver(to, msg)
+      end
+
+      def step
+        @superstep += 1
+        # debug "Running super step ##{@superstep}"
+        compute
+      end
+
+      def halt;     @active = false;  end
+      def active!;  @active = true;   end
+      def active?;  @active;          end
+
+      def superstep; @superstep; end
+      def neighbors; @outedges; end
+
+      def vote_to_stop; @active = false; end
+
+      def compute; end
+    end # class Vertex
+  end # module Distributed
+end # module Elaine

data/lib/elaine/distributed/worker.rb

@@ -0,0 +1,85 @@
+require 'dcell'
+
+module Elaine
+  module Distributed
+    class Worker
+      include Celluloid
+      include Celluloid::Logger
+
+      attr_reader :vertices, :active, :vertices2
+
+
+      def initialize(coordinator_node: "elaine.coordinator", g: [], zipcodes: {}, stop_condition: Celluloid::Condition.new)
+
+        # @coordinator_node = DCell::Node["elaine.coordinator"]
+        @coordinator_node = coordinator_node
+        DCell::Node[@coordinator_node][:coordinator].register_worker DCell.me.id
+
+        @vertices = []
+        @superstep_num = 0
+        @stop_condition = stop_condition
+      end
+
+      def init_graph(g=[])
+        raise 'empty worker graph' if g.empty?
+        if @vertices.size > 0
+          @vertices.each do |v|
+            # Celluloid::Actor[v].terminate
+          end
+        end
+        @vertices = []
+        # raise "Graph already initialized!" if @vertices.size > 0
+
+        # we are going to assume that graphs come in as json documents
+        # *describing* the graph.
+        # @vertices = graph
+        # @active   = graph.size
+
+        # HACK the local vertices should be dealt with differently than
+        # the @vertices2 member
+        @vertices2 = []
+        g.each do |n|
+          # n[:klazz].supervise_as n[:id], n[:id], n[:value], Celluloid::Actor[:postoffice], n[:outedges]
+          @vertices << n[:id]
+          v = n[:klazz].new n[:id], n[:value], Celluloid::Actor[:postoffice], n[:outedges]
+          @vertices2 << v
+        end
+        @active = @vertices.size
+
+        debug "There are #{@vertices.size} vertices in this worker."
+
+      end
+
+      # HACK this should be handled better...
+      def init_superstep
+        @vertices2.each do |v|
+          v.messages = Celluloid::Actor[:postoffice].read_all(v.id)
+        end
+        debug "#{DCell.me.id} finished init_superstep"
+      end
+
+      def pmap(enum, &block)
+        futures = enum.map { |elem| Celluloid::Future.new(elem, &block) }
+        futures.map { |future| future.value }
+      end
+
+      def stop
+        @stop_condition.signal(true)
+      end
+
+      def superstep
+        active = @vertices2.select {|v| v.active?}
+
+        
+        pmap(active) do |v|
+          v.step
+        end
+        @active = active.select {|v| v.active?}.size    
+      end
+
+      def vertex_values
+        @vertices2.map { |v| {id: v.id, value: v.value} }
+      end
+    end # class Worker
+  end # module Distributed
+end # module Elaine

data/lib/elaine/version.rb

@@ -0,0 +1,3 @@
+module Elaine
+  VERSION = "0.0.3"
+end

data/lib/elaine/vertex.rb

@@ -0,0 +1,41 @@
+module Elaine
+  class Vertex
+    attr_reader :id
+    attr_accessor :value, :messages
+
+    def initialize(id, value, *outedges)
+      @id = id
+      @value = value
+      @outedges = outedges
+      @messages = []
+      @active = true
+      @superstep = 0
+    end
+
+    def edges
+      block_given? ? @outedges.each {|e| yield e} : @outedges
+    end
+
+    def deliver_to_all_neighbors(msg)
+      edges.each {|e| deliver(e, msg)}
+    end
+
+    def deliver(to, msg)
+      PostOffice.instance.deliver(to, msg)
+    end
+
+    def step
+      @superstep += 1
+      compute
+    end
+
+    def halt;     @active = false;  end
+    def active!;  @active = true;   end
+    def active?;  @active;          end
+
+    def superstep; @superstep; end
+    def neighbors; @outedges; end
+
+    def compute; end
+  end
+end