rbczmq 0.1

data/perf/runner.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path('lib')
+require 'zmq'
+
+class Runner
+  DEFAULT_MSG_COUNT = 100_000
+  DEFAULT_MSG_SIZE = 100
+  DEFAULT_ENCODING = :string
+
+  attr_reader :msg_count, :msg_size, :encoding, :workers_count, :stats_buf
+
+  def initialize(msg_count, msg_size, encoding, workers_count = 1)
+    @msg_count = (msg_count || DEFAULT_MSG_COUNT).to_i
+    @msg_size = (msg_size || DEFAULT_MSG_SIZE).to_i
+    @encoding = (encoding || DEFAULT_ENCODING).to_sym
+    @workers_count = (workers_count || 1).to_i
+    @stats_buf, @workers = [], []
+    register_signal_handlers
+  end
+
+  def start(test)
+    @workers_count.times{ fork_local(test) }
+    fork_remote(test)
+    puts "Workers: #{@workers.join(', ')}"
+    puts "Producer: #{@producer}"
+    after_start
+  ensure
+    stop
+  end
+
+  def process_msg_count
+    msg_count / workers_count
+  end
+
+  def endpoint
+    self.class.const_get(:ENDPOINT)
+  end
+
+  def payload
+    @payload ||= "#{'0'*msg_size}"
+  end
+
+  def stats(start_time)
+    end_time = Time.now
+    elapsed = (end_time.to_f - start_time.to_f) * 1000000
+    elapsed = 1 if elapsed == 0
+
+    throughput = process_msg_count * 1000000 / elapsed
+    megabits = throughput * msg_size * 8 / 1000000
+    stats_buf << "====== [#{Process.pid}] transfer stats ======"
+    stats_buf << "message encoding: %s" % encoding
+    stats_buf << "message size: %i [B]" % msg_size
+    stats_buf << "message count: %i" % process_msg_count
+    stats_buf << "mean throughput: %i [msg/s]" % throughput
+    stats_buf << "mean throughput: %.3f [Mb/s]" % megabits
+  end
+
+  private
+  def register_signal_handlers
+    %w(INT TERM QUIT).each do |sig|
+       trap(sig){ stop }
+     end
+  end
+
+  def before_fork
+    sample_mem(:before)
+  end
+
+  def after_fork
+    sample_mem(:after)
+    stats_buf.each{|s| puts(s) }
+  end
+
+  def sample_mem(w)
+    stats_buf << "[#{$$}] Memory used #{w}: %dkb" % `ps -o rss= -p #{$$}`.to_i
+  end
+end
+
+class ProcessRunner < Runner
+  ENDPOINT = "tcp://127.0.0.1:5221"
+
+  def stop
+    Process.kill(:INT, @producer) rescue nil
+    @workers.each{|p| Process.kill(:INT, p) rescue nil }
+  end
+
+  private
+  def after_start
+    Process.waitpid(@producer, Process::WNOHANG)
+    @workers.each{|p| Process.waitpid(p) }
+  end
+
+  def fork_local(test)
+    @workers << fork do
+      before_fork
+      require File.join(File.dirname(__FILE__), test.to_s, 'local')
+      after_fork
+    end
+  end
+
+  def fork_remote(test)
+    @producer = fork do
+      before_fork
+      sleep 1
+      require File.join(File.dirname(__FILE__), test.to_s, 'remote')
+      after_fork
+    end
+  end
+end
+
+class ThreadRunner < Runner
+  ENDPOINT = "inproc://perf"
+
+  def stop
+    @producer.kill rescue nil
+    @workers.each{|t| t.kill rescue nil }
+  end
+
+  private
+  def after_start
+    @producer.join
+    @workers.each{|t| t.join }
+  end
+
+  def fork_local(test)
+    @workers << Thread.new do
+      before_fork
+      require File.join(File.dirname(__FILE__), test.to_s, 'local')
+      after_fork
+    end
+  end
+
+  def fork_remote(test)
+    @producer = Thread.new do
+      before_fork
+      sleep 1
+      require File.join(File.dirname(__FILE__), test.to_s, 'remote')
+      after_fork
+    end
+  end
+end

data/rbczmq.gemspec

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/zmq/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "rbczmq"
+  s.version = ZMQ::VERSION
+  s.summary = "Ruby extension for CZMQ - High-level C Binding for ØMQ (http://czmq.zeromq.org)"
+  s.description = "Ruby extension for CZMQ - High-level C Binding for ØMQ (http://czmq.zeromq.org)"
+  s.authors = ["Lourens Naudé", "James Tucker"]
+  s.email = ["lourens@methodmissing.com", "jftucker@gmail.com"]
+  s.homepage = "http://github.com/methodmissing/rbczmq"
+  s.date = Time.now.utc.strftime('%Y-%m-%d')
+  s.platform = Gem::Platform::RUBY
+  s.extensions = "ext/rbczmq/extconf.rb"
+  s.has_rdoc = true
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files test`.split("\n")
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.add_development_dependency('rake-compiler', '~> 0.8.0')
+end

data/test/helper.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'test/unit'
+require 'zmq'
+require 'stringio'
+
+Thread.abort_on_exception = true
+
+class ZmqTestCase < Test::Unit::TestCase
+  undef_method :default_test if method_defined? :default_test
+
+  if ENV['STRESS_GC']
+    def setup
+      GC.stress = true
+    end
+
+    def teardown
+      GC.stress = false
+    end
+  end
+end

data/test/socket/test_dealer_socket.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestDealerSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:DEALER)
+    assert_equal ZMQ::DEALER, sock.type
+    assert_equal "DEALER socket", sock.to_s
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_pair_socket.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestPairSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PAIR)
+    assert_equal ZMQ::PAIR, sock.type
+    assert_equal "PAIR socket", sock.to_s
+  ensure
+    ctx.destroy
+  end
+
+  def test_inproc_only_transport
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PAIR)
+    assert_raises ZMQ::Error do
+      sock.bind("tcp://127.0.0.1:*")
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_pair_sockets.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestPairSockets < ZmqTestCase
+  def test_flow
+    ctx = ZMQ::Context.new
+    a = ctx.bind(:PAIR, "inproc://test.pair-flow")
+    b = ctx.connect(:PAIR, "inproc://test.pair-flow")
+    a.send("a")
+    b.send("b")
+    assert_equal "b", a.recv
+    assert_equal "a", b.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_transfer
+    ctx = ZMQ::Context.new
+    a = ctx.bind(:PAIR, "inproc://test.pair-transfer")
+    b = ctx.connect(:PAIR, "inproc://test.pair-transfer")
+    a.send("message")
+    assert_equal "message", b.recv
+
+    a.sendm("me")
+    a.sendm("ss")
+    a.send("age")
+    assert_equal "me", b.recv
+    assert_equal "ss", b.recv
+    assert_equal "age", b.recv
+
+    a.send_frame ZMQ::Frame("frame")
+    assert_equal ZMQ::Frame("frame"), b.recv_frame
+
+    5.times do |i|
+      frame = ZMQ::Frame("m#{i}")
+      a.send_frame(frame, ZMQ::Frame::MORE)
+    end
+    a.send_frame(ZMQ::Frame("m5"))
+    expected, frames = %w(m0 m1 m2 m3 m4 m5), []
+    5.times do
+      frames << b.recv_frame.data
+    end
+    frames << b.recv_frame.data
+    assert_equal expected, frames
+
+    msg = ZMQ::Message.new
+    msg.push ZMQ::Frame("header")
+
+    assert_nil a.send_message(msg)
+
+    recvd_msg = b.recv_message
+    assert_instance_of ZMQ::Message, recvd_msg
+    assert_equal ZMQ::Frame("header"), recvd_msg.pop
+  ensure
+    ctx.destroy
+  end
+
+  def test_distribution
+    ctx = ZMQ::Context.new
+    a = ctx.bind(:PAIR, "inproc://test.pair-distribution")
+    thread = Thread.new do
+      b = ctx.connect(:PAIR, "inproc://test.pair-distribution")
+      frame = b.recv_frame
+      b.close
+      frame
+    end
+
+    a.send_frame ZMQ::Frame("message")
+    assert_equal ZMQ::Frame("message"), thread.value
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_pub_socket.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestPubSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PUB)
+    assert_equal ZMQ::PUB, sock.type
+    assert_equal "PUB socket", sock.to_s
+    assert_raises ZMQ::Error do
+      sock.recv
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_pub_sub_sockets.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestPubSubSockets < ZmqTestCase
+  def test_flow
+    ctx = ZMQ::Context.new
+    pub = ctx.bind(:PUB, "inproc://test.pub-sub-flow")
+    sub = ctx.connect(:SUB, "inproc://test.pub-sub-flow")
+    sub.subscribe("")
+    pub.send("a")
+    assert_equal "a", sub.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_transfer
+    ctx = ZMQ::Context.new
+    pub = ctx.bind(:PUB, "inproc://test.pub-sub-transfer")
+    sub = ctx.connect(:SUB, "inproc://test.pub-sub-transfer")
+    sub.subscribe("")
+    pub.send("message")
+    assert_equal "message", sub.recv
+
+    pub.sendm("me")
+    pub.sendm("ss")
+    pub.send("age")
+    assert_equal "me", sub.recv
+    assert_equal "ss", sub.recv
+    assert_equal "age", sub.recv
+
+    pub.send_frame ZMQ::Frame("frame")
+    assert_equal ZMQ::Frame("frame"), sub.recv_frame
+
+    5.times do |i|
+      frame = ZMQ::Frame("m#{i}")
+      pub.send_frame(frame, ZMQ::Frame::MORE)
+    end
+    pub.send_frame(ZMQ::Frame("m5"))
+    expected, frames = %w(m0 m1 m2 m3 m4 m5), []
+    5.times do
+      frames << sub.recv_frame.data
+    end
+    frames << sub.recv_frame.data
+    assert_equal expected, frames
+
+    msg = ZMQ::Message.new
+    msg.push ZMQ::Frame("header")
+
+    assert_nil pub.send_message(msg)
+
+    recvd_msg = sub.recv_message
+    assert_instance_of ZMQ::Message, recvd_msg
+    assert_equal ZMQ::Frame("header"), recvd_msg.pop
+  ensure
+    ctx.destroy
+  end
+
+  def test_distribution
+    ctx = ZMQ::Context.new
+    pub = ctx.bind(:PUB, "inproc://test.pub-sub-distribution")
+    threads = []
+    5.times do |i|
+      threads << Thread.new do
+        sub = ctx.connect(:SUB, "inproc://test.pub-sub-distribution")
+        sub.subscribe("")
+        messages = []
+        5.times do
+          messages << sub.recv
+        end
+        sub.close
+        messages
+      end
+    end
+
+    sleep 0.5 # "slow joiner" syndrome
+    messages = %w(a b c d e)
+    messages.each do |m|
+      pub.send m
+    end
+
+    threads.each{|t| t.join }
+    assert threads.all?{|t| t.value == messages }
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_pull_socket.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestPullSocket < ZmqTestCase
+  def test_behavior
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PULL)
+    assert_equal ZMQ::PULL, sock.type
+    assert_equal "PULL socket", sock.to_s
+    assert_raises ZMQ::Error do
+      sock.send("message")
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/socket/test_push_pull_sockets.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+class TestPushPullSockets < ZmqTestCase
+  def test_flow
+    ctx = ZMQ::Context.new
+    push = ctx.bind(:PUSH, "inproc://test.push-pull-flow")
+    pull = ctx.connect(:PULL, "inproc://test.push-pull-flow")
+    push.send("a")
+    assert_equal "a", pull.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_transfer
+    ctx = ZMQ::Context.new
+    push = ctx.bind(:PUSH, "inproc://test.push-pull-transfer")
+    pull = ctx.connect(:PULL, "inproc://test.push-pull-transfer")
+    push.send("message")
+    assert_equal "message", pull.recv
+
+    push.sendm("me")
+    push.sendm("ss")
+    push.send("age")
+    assert_equal "me", pull.recv
+    assert_equal "ss", pull.recv
+    assert_equal "age", pull.recv
+
+    push.send_frame ZMQ::Frame("frame")
+    assert_equal ZMQ::Frame("frame"), pull.recv_frame
+
+    5.times do |i|
+      frame = ZMQ::Frame("m#{i}")
+      push.send_frame(frame, ZMQ::Frame::MORE)
+    end
+    push.send_frame(ZMQ::Frame("m5"))
+    expected, frames = %w(m0 m1 m2 m3 m4 m5), []
+    5.times do
+      frames << pull.recv_frame.data
+    end
+    frames << pull.recv_frame.data
+    assert_equal expected, frames
+
+    msg = ZMQ::Message.new
+    msg.push ZMQ::Frame("header")
+
+    assert_nil push.send_message(msg)
+
+    recvd_msg = pull.recv_message
+    assert_instance_of ZMQ::Message, recvd_msg
+    assert_equal ZMQ::Frame("header"), recvd_msg.pop
+  ensure
+    ctx.destroy
+  end
+
+  def test_distribution
+    ctx = ZMQ::Context.new
+    push = ctx.bind(:PUSH, "inproc://test.push-pull-distribution")
+    threads = []
+    5.times do |i|
+      threads << Thread.new do
+        pull = ctx.connect(:PULL, "inproc://test.push-pull-distribution")
+        msg = pull.recv
+        pull.close
+        msg
+      end
+    end
+
+    sleep 0.5 # "slow joiner" syndrome
+    messages = %w(a b c d e f)
+    messages.each do |m|
+      push.send m
+    end
+
+    threads.each{|t| t.join }
+    assert threads.all?{|t| messages.include?(t.value) }
+  ensure
+    ctx.destroy
+  end
+end