fibril 0.0.1 → 0.0.5

data/examples/{example_loop.rb → example_tick.rb}

@@ -1,4 +1,4 @@
-require_relative "../lib/fibril/loop"
+require 'fibril/loop'
 
 fibril{
   puts 1

data/examples/example_tick2.rb

@@ -0,0 +1,22 @@
+require 'fibril/loop'
+
+fibril{
+  [1,3,5].each do |i|
+    print i.to_s+?:
+    tick
+  end
+}
+
+fibril{
+  [2,4,6].each do |i|
+    print i.to_s
+    tick
+  end
+}
+
+fibril{
+  3.times{
+    print "\n"
+    tick
+  }
+}

data/examples/example_timeout.rb

@@ -0,0 +1,9 @@
+require 'fibril/loop'
+
+def heartbeat
+  puts "•"
+end
+
+fibril.puts('ping').loop(20, 0.5)
+fibril{ puts "pong" }.loop(20, 0.5)
+fibril.heartbeat.loop(3, 2)

data/fibril.gemspec

@@ -21,11 +21,11 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "byebug", "~> 8.2.1"
   spec.add_development_dependency "pry-byebug", "~> 3.3.0"
   spec.add_development_dependency 'pry', '~> 0.10.2', '>= 0.10.0'
+  spec.add_development_dependency 'redis'
   spec.add_development_dependency "minitest"
 end

data/fibril.todo

@@ -6,34 +6,40 @@
  ✔ Create event loop import @done (16-02-18 21:15)
  ✔ Create continous and counting loop construct @done (16-02-18 21:15)
  ✔ Create async object @done (16-02-19 07:35)
- ✔ Create promises @done (16-02-19 07:49)
+ ✔ Create futures @done (16-02-19 07:49)
  ✔ Turn into gem @done (16-02-19 07:49)
+ ✔ Create Fibril proxy @done (16-02-19 19:18)
+ ✔ Provide optional timeout value to Fibril looping @done (16-02-23 08:58)
+ ✔ Create smarter loop importer. Finds import statement and only evals everything past itself @done (16-02-23 09:01)
+ ✔ Add fasync and ffuture @done (16-02-27 11:19)
+ ✘ Add keywords syntax highlighting in Sublime @cancelled (16-03-01 18:34)
+    ✘ future, async, fibril, await, await_all @cancelled (16-03-01 18:34)
 
- ☐ Add keywords syntax highlighting in Sublime
-    - promise, async, fibril, await, await_all
 
- ☐ Create smarter loop importer. Finds import statement and only evals everything past itself
-
- ☐ Write performance tests
- ☐ Use efficient ring buffer as queue and block when full
+ ✘ Use efficient ring buffer as queue and block when full @cancelled (16-03-01 09:05)
+ ✔ Split imports into core, and full functionality to prevent conflicts @done (16-03-01 18:41)
+ ✔ Enumerable ticking with fibril @done (16-03-21 09:03)
+ ✔ Enumerable concurrency, every nth @done (16-03-21 09:03)
+ ☐ Add meaningful errors when common mistakes are made
+ ☐ Add option to peek and consume in non blocking IO wrapper
 
  ☐ Examples:
 
-   ☐ Weave with tick
-   ☐ Weave with async IO
-   ☐ Weave external await
-   ☐ Weave with internal await
-   ☐ Promises
+   ✔ Fibril with tick @done (16-03-21 09:03)
+   ✔ Fibril with async IO @done (16-03-21 09:03)
+   ✔ Fibril external await @done (16-03-21 09:03)
+   ✔ Fibril with internal await @done (16-03-21 09:03)
+   ✔ Fibril wrapping redis @done (16-03-21 09:03)
+   ✔ Futures @done (16-03-21 09:03)
 
    ☐ Disk read + write
    ☐ Database queries using AR
-   ☐ Network IO
+   ☐ Network IO = Https
    ☐ Asyncifying common functions
    ☐ Asyncifying class methods
    ☐ Asyncifying instance methods
    ☐ Asyncifying module methods
    ☐ Comparison to thread
    ☐ Comparison to event machine
-
- ☐ Rename to Weave
- ☐ Refactor
+ ☐ Write performance tests
+ ☐ Write tests

data/lib/fibril.rb

@@ -1,241 +1,3 @@
 require "fibril/version"
-require 'ostruct'
-
-
-class Fibril < Fiber
-  class << self
-    attr_accessor :running, :stopped, :queue, :task_count, :guards, :current, :id_seq
-  end
-
-  self.queue = []
-  self.guards = Hash.new{|h,k| }
-  self.id_seq = 0
-
-  attr_accessor :fiber, :guards, :block, :id
-
-  def self.log(msg)
-    # puts msg
-  end
-
-  def variables
-    @@variables ||= OpenStruct.new
-  end
-
-  def initialize(&blk)
-    self.id = Fibril.id_seq += 1
-    self.block  = blk
-    self.guards = []
-    define_singleton_method :execute_fibril, self.block
-    super(&method(:execute))
-    Fibril.queue << self
-  end
-
-  def reset(guard)
-    copy = Fibril.new(&self.block)
-    copy.guards << guard
-    return copy
-  end
-
-  def execute
-    Fibril.task_count += 1
-    execute_fibril
-    self.guards.each(&:visit)
-    Fibril.task_count -= 1
-    Fibril.log "Ending #{id}"
-  end
-
-  def tick
-    Fibril.enqueue self
-    self.yield
-  end
-
-  def self.enqueue(fibril)
-    Fibril.log "Enqueing fibril #{fibril.id}"
-    Fibril.queue << fibril
-  end
-
-  def yield
-    Fibril.log "Yielding #{id}"
-    Fiber.yield
-  end
-
-  def current
-    self
-  end
-
-  def self.deplete_guard(guard)
-    return unless waiters = guards[guard.id]
-    switches = waiters[:switches]
-    switches[guard.id] = true
-    waiters[:block][] if switches.values.all?
-  end
-
-  def await(*guards, &block)
-
-    if guards.length == 1 && guards[0].kind_of?(Promise)
-      return await_promise(guards[0])
-    end
-
-    await_block = {
-      switches: Hash[guards.map{|guard| [guard.id, false]}],
-      block: block
-    }
-    guards.each do |guard|
-      Fibril.guards[guard.id] = await_block
-    end
-  end
-
-  def promise(&blk)
-    return Promise.new(&blk)
-  end
-
-  def await_promise(promise)
-    promise.await
-  end
-
-  def await_all(*promises)
-    promises.map(&:await)
-  end
-
-  def self.stop
-    Fibril do
-      Fibril.stopped = true
-    end
-  end
-
-  def resume
-    Fibril.current = self
-    Fibril.log "Resuming #{id}"
-    super
-  end
-
-  def self.start
-    self.task_count = 0
-    self.stopped = false
-    self.running = true
-    if queue.any?
-      queue.shift.resume
-      self.loop if queue.any? || Fibril.task_count > 0
-    end
-    self.running = false
-  end
-
-  def self.loop
-    Fibril.log "Starting loop inside #{Fibril.current}"
-    while ((Fibril.task_count > 0 || queue.any?) && !Fibril.stopped)
-      Fibril.queue.shift.resume if Fibril.queue.any?
-    end
-  end
-
-  def Guard(i, fibril)
-    return Guard.new(i, fibril)
-  end
-
-  class AsyncProxy
-    attr_accessor :target
-
-    def initialize(target)
-      self.target = target
-    end
-
-    def method_missing(name, *args, &block)
-      waiting = Fibril.current
-      Thread.new do
-        target.send(name, *args, &block).tap{ Fibril.enqueue waiting }
-      end.tap{
-        Fibril.current.yield
-      }.value
-    end
-  end
-
-
-  class Guard
-    class << self
-      attr_accessor :guard_seq
-    end
-
-    attr_accessor :fibril, :id, :break_condition, :depleted
-
-    self.guard_seq = 0
-
-    def self.create(fibril, counter=1)
-      self.guard_seq += 1
-      guard = Fibril::Guard.new(self.guard_seq, counter, fibril)
-      fibril.guards << guard
-      return guard
-    end
-
-    def await
-      Fibril.current.tick while !self.depleted
-    end
-
-    def initialize(id, counter, fibril)
-      self.id = id
-      self.fibril =  fibril
-      self.break_condition = 1
-    end
-
-    def visit
-      case self.break_condition
-      when Proc
-        if self.break_condition[]
-          self.depleted = true
-          Fibril.deplete_guard(self)
-        else
-          self.fibril    = self.fibril.reset(self)
-        end
-      else
-        self.break_condition -= 1
-        if self.break_condition.zero?
-          self.depleted = true
-          Fibril.deplete_guard(self)
-        else
-          self.fibril = self.fibril.reset(self)
-        end
-      end
-    end
-
-    def loop(break_condition=-1, &blck)
-      self.break_condition = block_given? ? blck : break_condition
-      self
-    end
-
-    def while(&blk)
-      loop{ !blk[] }
-    end
-
-    def until(&blk)
-      loop{ blk[] }
-    end
-  end
-
-  class Promise
-    attr_accessor :promise_thread
-    def initialize(&blk)
-      self.promise_thread = Thread.new(&blk)
-    end
-
-    def await
-      self.promise_thread.join.value
-    end
-  end
-
-end
-
-class ::BasicObject
-  def async
-    @async_proxy ||= ::Fibril::AsyncProxy.new(self)
-  end
-end
-
-
-def Fibril(&block)
-  fibril = Fibril.new(&block).tap do |t|
-    Fibril.start unless Fibril.running
-  end
-  guard = Fibril::Guard.create(fibril)
-end
-
-
-
-Kernel.send :alias_method, :fibril, :Fibril
+require "fibril/core"
+require "fibril/extras"

data/lib/fibril/async_proxy.rb

@@ -0,0 +1,28 @@
+class Fibril::AsyncProxy
+  attr_accessor :target
+
+  def initialize(target)
+    self.target = target
+  end
+
+  ##
+  # Execute target method on proxied target. Enqueue the current fibril
+  # to be resumed as soon as async task is finished
+  ##
+  def method_missing(name, *_args, &_block)
+    define_singleton_method(name) do |*args, &block|
+      waiting = Fibril.current
+      Thread.new do
+        begin
+          target.send(name, *args, &block).tap{ Fibril.enqueue waiting }
+        rescue Exception => e
+          puts "Exception! #{e}"
+          Fibril.enqueue waiting
+        end
+      end.tap do
+        Fibril.current.yield
+      end.value
+    end
+    send(name, *_args, &_block)
+  end
+end

data/lib/fibril/basic_object.rb

@@ -0,0 +1,20 @@
+class ::BasicObject
+  ##
+  # Expose the async, fasync and fibril methods on all objects
+  ##
+
+  ##
+  # An asynchronous proxy. Executes any methods invoked via proxy on target in a separate thread
+  ##
+  def async
+    @async_proxy ||= ::Fibril::AsyncProxy.new(self)
+  end
+
+  ##
+  # An asynchronous proxy. Executes any methods invoked via proxy on target in a separate fork
+  ##
+  def fasync
+    @fasync_proxy ||= ::Fibril::FAsyncProxy.new(self)
+  end
+
+end

data/lib/fibril/control.rb

@@ -0,0 +1,20 @@
+##
+# Expose thefuture and ffuture top level functions
+##
+
+##
+# Create a new future
+#
+
+class ::BasicObject
+  def future(&blk)
+    return ::Fibril::Future.new(&blk)
+  end
+
+  ##
+  # Create a new forked future
+  ##
+  def ffuture(&blk)
+    return ::Fibril::FFuture.new(&blk)
+  end
+end

data/lib/fibril/core.rb

@@ -0,0 +1,299 @@
+require 'fibril/guard'
+require 'fibril/future'
+require 'fibril/fibril_proxy'
+require 'fibril/tick_proxy'
+require 'ostruct'
+
+class Fibril < Fiber
+  class << self
+    attr_accessor :running, :stopped, :queue, :task_count, :guards, :current, :id_seq, :loop_thread
+  end
+
+  self.queue = []
+  self.guards = Hash.new{|h,k| h[k] = [] }
+  self.id_seq = 0
+  self.task_count = 0
+
+  attr_accessor :fiber, :guards, :block, :id
+
+  def self.log(msg)
+    # puts msg
+  end
+
+  def guard
+    Fibril.guard
+  end
+
+  def self.guard
+    @@guard ||= OpenStruct.new
+  end
+
+  def variables
+    Fibril.variables
+  end
+
+  def self.variables
+    @@variables ||= OpenStruct.new
+  end
+
+  def initialize(&blk)
+    self.id = Fibril.id_seq += 1
+    self.block  = blk
+    self.guards = []
+    define_singleton_method :execute_fibril, self.block
+    if Fibril.running
+      super(&method(:execute))
+      Fibril.enqueue self
+    else
+      Fibril.task_count = 0
+      Fibril.stopped = false
+      Fibril.running = true
+      super(&method(:execute))
+      Fibril.enqueue self
+      Fibril.start
+    end
+  end
+
+  def reset(guard)
+    copy = Fibril.new(&self.block)
+    copy.guards << guard
+    return copy
+  end
+
+  def execute
+    Fibril.task_count += 1
+    exception = nil
+    result = begin
+      execute_fibril
+    rescue Exception => e
+      exception = e
+    end
+    self.guards.each do |guard|
+      guard.visit(result)
+    end
+    Fibril.task_count -= 1
+    Fibril.log "Ending #{id}"
+    raise exception if exception
+  end
+
+  def tick
+    if Thread.current != Fibril.loop_thread
+      Fibril.log "Current thread is #{Thread.current.object_id}"
+      Fibril.log "Fibril thread is #{Fibril.loop_thread.object_id}"
+      Fibril.log "WARN: Cannot tick inside async code outside of main loop thread. This will be a noop"
+    elsif !Fibril.queue.empty?
+      Fibril.enqueue self
+      self.yield
+    end
+  end
+
+  def enqueue
+    Fibril.enqueue(self)
+  end
+
+  def self.enqueue(fibril)
+    Fibril.log "Enqueing fibril #{fibril.id}"
+    Fibril.queue << fibril
+  end
+
+  def yield
+    Fibril.log "Yielding #{id}"
+    yield(self) if block_given?
+    Fiber.yield
+  end
+
+  def current
+    self
+  end
+
+  def self.deplete_guard(guard, result)
+    return unless waiter_list = guards[guard.id]
+    waiter_list.each do |waiters|
+      switches = waiters[:switches]
+      switches[guard.id] = true
+      if waiters.has_key?(:to_fulfill)
+        Fibril.enqueue waiters[:to_fulfill] if switches.values.all?
+        waiters[:result] ||= []
+        waiters[:result] << result
+      else
+        waiters[:result] ||= []
+        waiters[:result] << result
+        waiters[:block][*sort_results(waiters[:result], waiters[:guards])] if waiters[:block] && switches.values.all?
+      end
+    end
+  end
+
+  def await_fibril(guards)
+    singular = guards.one?
+    return singular ? guards[0].result : guards.map(&:result) if guards.all?(&:result?)
+    await_block = {
+      switches: Hash[guards.map{|guard| [guard.id, false]}],
+      to_fulfill: Fibril.current
+    }
+    guards.each do |guard|
+      Fibril.guards[guard.id] << await_block
+    end
+    self.yield
+    return singular ? await_block[:result][0] : Fibril.sort_results(await_block[:result], guards)
+  end
+
+  def self.sort_results(results, guards)
+    by_complete_order = guards.sort_by(&:depleted_at)
+    results.zip(by_complete_order).sort do |(_, guard_a), (_, guard_b)|
+      guards.index(guard_a) <=> guards.index(guard_b)
+    end.map(&:first)
+  end
+
+  def await(*guards, &block)
+    guards.map!{|guard| guard.kind_of?(Symbol) ? Fibril.guard.send(guard) : guard}
+    raise "Invalid guard given #{guards}" unless guards.all?{|g| g.kind_of?(Guard) || g.kind_of?(Future)}
+    if block_given?
+      return block[*guards.map(&:result)] if guards.all?(&:result?)
+      await_block = {
+        switches: Hash[guards.map{|guard| [guard.id, false]}],
+        block: block,
+        guards: guards
+      }
+      guards.each do |guard|
+        Fibril.guards[guard.id] << await_block
+      end
+    else
+      guard = guards.first
+      guard.kind_of?(Future) ? await_future(guard) : await_fibril(guards)
+    end
+  end
+
+  def await_future(future)
+    tick while future.alive?
+    future.await
+  end
+
+  def await_all(*futures)
+    futures.map(&:await)
+  end
+
+  def self.stop
+    Fibril do
+      Fibril.stopped = true
+    end
+  end
+
+  def resume
+    Fibril.current = self
+    Fibril.log "Resuming #{id}"
+    super
+  end
+
+  def self.start
+    self.start_loop if !queue.empty?
+    self.running = false
+  end
+
+  def self.profile(test)
+    starts = Time.now
+    result = yield
+    ends   = Time.now
+    Fibril.log "#{test} took #{ends - starts}"
+    return result
+  end
+
+  def self.start_loop
+    Fibril.log "Starting loop inside #{Fibril.current}"
+    Fibril.loop_thread = Thread.current
+    while pending_tasks?
+      Fibril.current = nil
+      Fibril.queue.shift.resume while !queue.empty?
+    end
+  end
+
+  def self.pending_tasks?
+    ((@task_count > 0 || !@queue.empty?) && !@stopped)
+  end
+
+  def Guard(i, fibril)
+    return Guard.new(i, fibril)
+  end
+end
+
+
+##
+# Create a new fibril
+##
+
+def Fibril(*guard_names, &block)
+  fibril = Fibril.new(&block)
+  return fibril unless Fibril.running
+  Fibril::Guard.create(fibril).tap do |guard|
+    guard_names.each do |name|
+      Fibril.guard.send("#{name}=", guard)
+    end
+  end
+end
+
+class Enumerator
+  def fibril(*guard_names, &block)
+    context = self
+    Kernel.fibril(*guard_names){
+      e = Enumerator.new do |enum|
+        context.each do |*elm|
+          result = enum.yield(*elm)
+          tick
+          result
+        end
+      end
+      e.each(&block)
+    }
+  end
+
+  def n_fibrils(*guard_names, n, &block)
+    context = self
+
+    guards = n.times.map do |i|
+      Kernel.fibril{
+        e = Enumerator.new do |enum|
+          context.each.with_index do |elm, index|
+            next unless ((index - i) % n).zero?
+            result = enum.yield(*elm)
+            tick
+            result
+          end
+        end
+        e.each(&block)
+      }
+    end
+    Kernel.fibril(*guard_names){
+      all_results = await(*guards)
+      length = all_results.max{|x| x.length}.length
+      length.times.map do |i|
+        all_results.find{|list|
+          list[i] != nil
+        }[i]
+      end
+    }
+  end
+end
+
+class ::BasicObject
+  ##
+  # This method has two methods of use.
+  # Either
+  # A. call with block to create a new fibril
+  # B. call without block to create a fibril proxy. Any methods invoked on a proxy are executed on the target from
+  # within a new Fibril
+  ##
+  def fibril(*guard_names, &block)
+    if block_given?
+      Fibril(*guard_names, &block)
+    else
+      ::Fibril::FibrilProxy.new(self, *guard_names)
+    end
+  end
+
+  def tick(*guard_names, **args)
+    ::Fibril::TickProxy.new(self, *guard_names, **args)
+  end
+
+  def await(*args, &block)
+    ::Fibril.current.await(*args, &block)
+  end
+end