agent 0.1.0 → 0.9.0

data/spec/error_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Agent::Error do
+  before do
+    @error = Agent::Error.new("msg")
+  end
+
+  it "should create an error" do
+    @error.to_s.should == "msg"
+  end
+
+  it "should match the error's message" do
+    @error.should be_message("msg")
+  end
+end

data/spec/examples/channel_of_channels_spec.rb

@@ -1,4 +1,4 @@
-require "helper"
+require "spec_helper"
 
 describe "Channel of Channels" do
 
@@ -7,24 +7,26 @@ describe "Channel of Channels" do
   it "should be able to pass channels as first class citizens" do
     server = Proc.new do |reqs|
       2.times do |n|
-        res = Request.new(n, Agent::Channel.new(:name => "resultChan-#{n}", :type => Integer))
+        res = Request.new(n, channel!(Integer))
 
         reqs << res
-        res.resultChan.receive.should == n+1
+        res.resultChan.receive[0].should == n+1
+        res.resultChan.close
       end
     end
 
     worker = Proc.new do |reqs|
       loop do
-        req = reqs.receive
+        req, ok = reqs.receive
+        break unless ok
         req.resultChan << req.args+1
       end
     end
 
-    clientRequests = Agent::Channel.new(:name => :clientRequests, :type => Request)
+    clientRequests = channel!(Request)
 
-    s = go(clientRequests, &server)
-    c = go(clientRequests, &worker)
+    s = go!(clientRequests, &server)
+    c = go!(clientRequests, &worker)
 
     s.join
     clientRequests.close
@@ -33,24 +35,25 @@ describe "Channel of Channels" do
   it "should work with multiple workers" do
     worker = Proc.new do |reqs|
       loop do
-        req = reqs.receive
+        req, _ = reqs.receive
         req.resultChan << req.args+1
       end
     end
 
-    clientRequests = Agent::Channel.new(:name => :clientRequests, :type => Request)
+    clientRequests = channel!(Request)
 
     # start multiple workers
-    go(clientRequests, &worker)
-    go(clientRequests, &worker)
+    go!(clientRequests, &worker)
+    go!(clientRequests, &worker)
 
     # start server
-    s = go clientRequests do |reqs|
+    s = go! clientRequests do |reqs|
       2.times do |n|
-        res = Request.new(n, Agent::Channel.new(:name => "resultChan-#{n}", :type => Integer))
+        res = Request.new(n, channel!(Integer))
 
         reqs << res
-        res.resultChan.receive.should == n+1
+        res.resultChan.receive[0].should == n+1
+        res.resultChan.close
       end
     end
 

data/spec/examples/producer_consumer_spec.rb

@@ -1,4 +1,4 @@
-require "helper"
+require "spec_helper"
 
 describe "Producer-Consumer" do
   it "should synchronize by communication" do
@@ -32,31 +32,42 @@ describe "Producer-Consumer" do
     #     }
 
     producer = Proc.new do |c, n, s|
+      # print "producer: starting\n"
+
       n.times do |i|
+        # print "producer: #{i+1} of #{n}\n"
         c << i
-        # puts "producer: #{i}"
+        # print "producer sent: #{i}\n"
       end
 
+      # print "producer: finished\n"
+
       s << "producer finished"
     end
 
     consumer = Proc.new do |c, n, s|
+      # print "consumer: starting\n"
       n.times do |i|
+        # print "consumer: #{i+1} of #{n}\n"
         msg = c.receive
-        # puts "consumer got: #{msg}"
+        # print "consumer got: #{msg}\n"
       end
 
+      # print "consumer: finished\n"
+
       s << "consumer finished"
     end
 
-    c = Agent::Channel.new(name: :c, type: Integer)
-    s = Agent::Channel.new(name: :s, type: String)
+    c = channel!(Integer)
+    s = channel!(String)
 
-    go(c, 3, s, &producer)
-    go(c, 3, s, &consumer)
+    go!(c, 3, s, &producer)
+    sleep 0.1
+    go!(c, 3, s, &consumer)
 
-    s.pop.should == "producer finished"
-    s.pop.should == "consumer finished"
+    messages = [s.pop[0], s.pop[0]]
+    messages.should include("producer finished")
+    messages.should include("consumer finished")
 
     c.close
     s.close
@@ -69,15 +80,14 @@ describe "Producer-Consumer" do
     end
 
     Generator = Struct.new(:name, :pipe)
-    c = Agent::Channel.new(name: :incr, type: Integer)
+    c = channel!(Integer)
     g = Generator.new(:incr, c)
 
-    go(g, &producer)
+    go!(g, &producer)
 
-    c.receive.should == 1
-    c.receive.should == 2
-
-    c.chan.size.should == 0
-    c.receive.should == 3
+    c.receive[0].should == 1
+    c.receive[0].should == 2
+    c.receive[0].should == 3
+    c.close
   end
 end

data/spec/examples/sieve_spec.rb

@@ -1,4 +1,4 @@
-require "helper"
+require "spec_helper"
 
 describe "sieve of Eratosthenes" do
 
@@ -7,24 +7,22 @@ describe "sieve of Eratosthenes" do
   it "should work using Channel primitives" do
 
     # send the sequence 2,3,4, ... to returned channel
-    def generate
-      ch = Agent::Channel.new(name: 'generator', type: Integer)
-
-      go do
-        i = 1
-        loop { ch << i+= 1 }
-      end
+    def generate(channels)
+      ch = channel!(Integer)
+      channels << ch
+      go!{ i = 1; loop { ch << i+= 1} }
 
       return ch
     end
 
     # filter out input values divisible by *prime*, send rest to returned channel
-    def filter(in_channel, prime)
-      out = Agent::Channel.new(name: "filter-#{prime}", type: Integer)
+    def filter(in_channel, prime, channels)
+      out = channel!(Integer)
+      channels << out
 
-      go do
+      go! do
         loop do
-          i = in_channel.receive
+          i, _ = in_channel.receive
           out << i if (i % prime) != 0
         end
       end
@@ -32,15 +30,16 @@ describe "sieve of Eratosthenes" do
       return out
     end
 
-    def sieve
-      out = Agent::Channel.new(name: 'sieve', type: Integer)
+    def sieve(channels)
+      out = channel!(Integer)
+      channels << out
 
-      go do
-        ch = generate
+      go! do
+        ch = generate(channels)
         loop do
-          prime = ch.receive
+          prime, _ = ch.receive
           out << prime
-          ch = filter(ch, prime)
+          ch = filter(ch, prime, channels)
         end
       end
 
@@ -50,16 +49,17 @@ describe "sieve of Eratosthenes" do
     # run the sieve
     n = 20
     nth = false
+    channels = []
 
-    primes = sieve
+    primes = sieve(channels)
     result = []
 
     if nth
       n.times { primes.receive }
-      puts primes.receive
+      puts primes.receive[0]
     else
       loop do
-        p = primes.receive
+        p, _ = primes.receive
 
         if p <= n
           result << p
@@ -70,15 +70,17 @@ describe "sieve of Eratosthenes" do
     end
 
     result.should == [2,3,5,7,11,13,17,19]
+    channels.each(&:close)
   end
 
   it "should work with Ruby blocks" do
 
     # send the sequence 2,3,4, ... to returned channel
-    generate = Proc.new do
-      ch = Agent::Channel.new(name: 'generator-block', type: Integer)
+    generate = Proc.new do |channels|
+      ch = channel!(Integer)
+      channels << ch
 
-      go do
+      go! do
         i = 1
         loop { ch << i+= 1 }
       end
@@ -87,12 +89,13 @@ describe "sieve of Eratosthenes" do
     end
 
     # filter out input values divisible by *prime*, send rest to returned channel
-    filtr = Proc.new do |in_channel, prime|
-      out = Agent::Channel.new(name: "filter-#{prime}-block", type: Integer)
+    filtr = Proc.new do |in_channel, prime, channels|
+      out = channel!(Integer)
+      channels << out
 
-      go do
+      go! do
         loop do
-          i = in_channel.receive
+          i, _ = in_channel.receive
           out << i if (i % prime) != 0
         end
       end
@@ -100,16 +103,17 @@ describe "sieve of Eratosthenes" do
       out
     end
 
-    sieve = -> do
-      out = Agent::Channel.new(name: 'sieve-block', type: Integer)
+    sieve = Proc.new do |channels|
+      out = channel!(Integer)
+      channels << out
 
-      go do
-        ch = generate.call
+      go! do
+        ch = generate.call(channels)
 
         loop do
-          prime = ch.receive
+          prime, _ = ch.receive
           out << prime
-          ch = filtr.call(ch, prime)
+          ch = filtr.call(ch, prime, channels)
         end
       end
 
@@ -119,16 +123,17 @@ describe "sieve of Eratosthenes" do
     # run the sieve
     n = 20
     nth = false
+    channels = []
 
-    primes = sieve.call
+    primes = sieve.call(channels)
     result = []
 
     if nth
       n.times { primes.receive }
-      puts primes.receive
+      puts primes.receive[0]
     else
       loop do
-        p = primes.receive
+        p, _ = primes.receive
 
         if p <= n
           result << p
@@ -139,5 +144,6 @@ describe "sieve of Eratosthenes" do
     end
 
     result.should == [2,3,5,7,11,13,17,19]
+    channels.each(&:close)
   end
 end

data/spec/go_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "Agent.go!" do
+  it "should launch a 'goroutine' that is actually a thread" do
+    Agent.go!{}.should be_a(Thread)
+  end
+
+  it "should pass into the thread any arguments passed to it" do
+    b = nil
+    Agent.go!(1){|a| b = a }.join
+    b.should == 1
+  end
+
+  it "should raise an error if no block is passed" do
+    lambda{ Agent.go! }.should raise_error(Agent::Errors::BlockMissing)
+  end
+end

data/spec/notifier_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Agent::Notifier do
+  before do
+    @notifier = Agent::Notifier.new
+  end
+
+  it "should notify using a payload" do
+    @notifier.notify(1)
+    @notifier.payload.should == 1
+  end
+
+  it "should acknowledge notification" do
+    @notifier.should_not be_notified
+    @notifier.notify(1)
+    @notifier.should be_notified
+  end
+
+  it "should only notify once" do
+    @notifier.notify(1)
+    @notifier.notify(2)
+    @notifier.payload.should == 1
+  end
+
+  it "should return nil when notified for the first time" do
+    @notifier.notify(1).should be_nil
+  end
+
+  it "should return an error when notified more than once" do
+    @notifier.notify(1)
+    @notifier.notify(2).should be_message("already notified")
+  end
+
+  it "should allow waiting on a notification and should signal when it is notified" do
+    ack = channel!(Integer)
+    go!{ @notifier.wait; ack.send(@notifier.payload) }
+    sleep 0.1 # make sure the notifier in the goroutine is waiting
+    @notifier.notify(1)
+    payload, _ = ack.receive
+    payload.should == 1
+  end
+end

data/spec/once_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe Agent::Once do
+
+  before do
+    @once = Agent::Once.new
+  end
+
+  it "should execute the block passed to it" do
+    r = []
+
+    @once.perform do
+      r << 1
+    end
+
+    r.size.should == 1
+    r.first.should == 1
+  end
+
+  it "should only execute the first block passed to it" do
+    r = []
+
+    @once.perform do
+      r << 1
+    end
+
+    @once.perform do
+      r << 2
+    end
+
+    r.size.should == 1
+    r.first.should == 1
+  end
+
+  it "should return the value returned from the block" do
+    value, error = @once.perform do
+      1
+    end
+
+    value.should == 1
+  end
+
+  it "should return nil for value and an error if it has already been used" do
+    value, error = @once.perform{ 1 }
+    value.should == 1
+    error.should be_nil
+
+    value, error = @once.perform{ 2 }
+    value.should be_nil
+    error.should_not be_nil
+    error.should be_message("already performed")
+  end
+
+  it "should have minimal contention between threads when they contend for position" do
+    r, s = [], Time.now.to_f
+
+    # Using condition variables to maximize potential contention
+    mutex     = Mutex.new
+    condition = ConditionVariable.new
+
+    waiting_channel  = channel!(TrueClass, 2)
+    finished_channel = channel!(TrueClass, 2)
+
+    go! do
+      mutex.synchronize{ waiting_channel.send(true); condition.wait(mutex) }
+      @once.perform{ sleep 0.1; r << 1 }
+      finished_channel.send(true)
+    end
+
+    go! do
+      mutex.synchronize{ waiting_channel.send(true); condition.wait(mutex) }
+      @once.perform{ sleep 0.1; r << 1 }
+      finished_channel.send(true)
+    end
+
+    # wait for both the goroutines to be waiting
+    2.times{ waiting_channel.receive }
+
+    mutex.synchronize{ condition.broadcast }
+
+    # wait for the finished channel to be completed
+    2.times{ finished_channel.receive }
+
+    r.size.should == 1
+    # Onlt the first sleep should be performed, so things should quickly
+    (Time.now.to_f - s).should be_within(0.05).of(0.15)
+
+    waiting_channel.close
+    finished_channel.close
+  end
+end