ffi-rzmq 0.8.2 → 0.9.0

data/examples/{local_throughput.rb → v2api/local_throughput.rb}

@@ -1,29 +1,40 @@
-require 'rubygems'
-require 'ffi-rzmq'
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
 
 if ARGV.length != 3
-  puts "usage: local_thr <bind-to> <message-size> <message-count>"
+  puts "usage: ruby local_throughtput.rb <bind-to> <message-size> <message-count>"
   Process.exit
 end
 
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
 bind_to = ARGV[0]
 message_size = ARGV[1].to_i
 message_count = ARGV[2].to_i
 
-ctx = ZMQ::Context.new
-s = ZMQ::Socket.new ctx.pointer, ZMQ::SUB
-s.setsockopt ZMQ::SUBSCRIBE, ""
+begin
+  ctx = ZMQ::Context.new
+  s = ZMQ::Socket.new(ctx.pointer, ZMQ::SUB)
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket!"
+  raise
+end
 
-s.bind bind_to
+assert(s.setsockopt(ZMQ::LINGER, 100))
+assert(s.setsockopt(ZMQ::SUBSCRIBE, ""))
+
+assert(s.bind(bind_to))
 
 msg = ZMQ::Message.new
-rc = s.recv msg
+assert(s.recv(msg))
 
 start_time = Time.now
 
 i = 1
 while i < message_count
-  result_code = s.recv msg
+  assert(s.recv(msg))
   i += 1
 end
 
@@ -41,3 +52,7 @@ puts "message size: %i [B]" % message_size
 puts "message count: %i" % message_count
 puts "mean throughput: %i [msg/s]" % throughput
 puts "mean throughput: %.3f [Mb/s]" % megabits
+
+assert(s.close)
+
+ctx.terminate

data/examples/v2api/publish_subscribe.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
+
+
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
+link = "tcp://127.0.0.1:5555"
+
+begin
+  ctx = ZMQ::Context.new
+  s1 = ctx.socket(ZMQ::PUB)
+  s2 = ctx.socket(ZMQ::SUB)
+  s3 = ctx.socket(ZMQ::SUB)
+  s4 = ctx.socket(ZMQ::SUB)
+  s5 = ctx.socket(ZMQ::SUB)
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket!"
+  raise
+end
+
+assert(s1.setsockopt(ZMQ::LINGER, 100))
+assert(s2.setsockopt(ZMQ::SUBSCRIBE, '')) # receive all
+assert(s3.setsockopt(ZMQ::SUBSCRIBE, 'animals')) # receive any starting with this string
+assert(s4.setsockopt(ZMQ::SUBSCRIBE, 'animals.dog'))
+assert(s5.setsockopt(ZMQ::SUBSCRIBE, 'animals.cat'))
+
+assert(s1.bind(link))
+assert(s2.connect(link))
+assert(s3.connect(link))
+assert(s4.connect(link))
+assert(s5.connect(link))
+
+sleep 1
+
+topic = "animals.dog"
+payload = "Animal crackers!"
+
+s1.identity = "publisher-A"
+puts "sending"
+# use the new multi-part messaging support to
+# automatically separate the topic from the body
+assert(s1.send_string(topic, ZMQ::SNDMORE))
+assert(s1.send_string(payload, ZMQ::SNDMORE))
+assert(s1.send_string(s1.identity))
+
+topic = ''
+assert(s2.recv_string(topic))
+
+body = ''
+assert(s2.recv_string(body)) if s2.more_parts?
+
+identity = ''
+assert(s2.recv_string(identity)) if s2.more_parts?
+puts "s2 received topic [#{topic}], body [#{body}], identity [#{identity}]"
+
+
+
+topic = ''
+assert(s3.recv_string(topic))
+
+body = ''
+assert(s3.recv_string(body)) if s3.more_parts?
+puts "s3 received topic [#{topic}], body [#{body}]"
+
+topic = ''
+assert(s4.recv_string(topic))
+
+body = ''
+assert(s4.recv_string(body)) if s4.more_parts?
+puts "s4 received topic [#{topic}], body [#{body}]"
+
+s5_string = ''
+rc = s5.recv_string(s5_string, ZMQ::NOBLOCK)
+eagain = (rc == -1 && ZMQ::Util.errno == ZMQ::EAGAIN)
+puts(eagain ? "s5 received no messages" : "s5 FAILED")
+
+[s1, s2, s3, s4, s5].each do |socket|
+  assert(socket.close)
+end
+
+ctx.terminate

data/examples/{remote_lat.rb → v2api/remote_lat.rb}

@@ -16,29 +16,43 @@
 #    You should have received a copy of the Lesser GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'rubygems'
-require 'ffi-rzmq'
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
 
 if ARGV.length < 3
-  puts "usage: remote_lat <connect-to> <message-size> <roundtrip-count>"
+  puts "usage: ruby remote_lat.rb <connect-to> <message-size> <roundtrip-count>"
   exit
 end
 
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
 connect_to = ARGV[0]
 message_size = ARGV[1].to_i
 roundtrip_count = ARGV[2].to_i
 
-ctx = ZMQ::Context.new 1
-s = ctx.socket ZMQ::REQ
-s.connect(connect_to)
+begin
+  ctx = ZMQ::Context.new
+  s = ctx.socket(ZMQ::REQ)
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket!"
+  raise
+end
+
+assert(s.setsockopt(ZMQ::LINGER, 100))
+assert(s.connect(connect_to))
 
 msg = "#{ '3' * message_size }"
 
 start_time = Time.now
 
 roundtrip_count.times do
-  s.send_string msg, 0
-  msg = s.recv_string 0
+  assert(s.send_string(msg, 0))
+
+  msg = ''
+  assert(s.recv_string(msg, 0))
+
   raise "Message size doesn't match, expected [#{message_size}] but received [#{msg.size}]" if message_size != msg.size
 end
 
@@ -51,3 +65,7 @@ puts "message size: %i [B]" % message_size
 puts "roundtrip count: %i" % roundtrip_count
 puts "throughput (msgs/s): %i" % (roundtrip_count / elapsed_secs)
 puts "mean latency: %.3f [us]" % latency
+
+assert(s.close)
+
+ctx.terminate

data/examples/v2api/remote_throughput.rb

@@ -0,0 +1,39 @@
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
+
+if ARGV.length != 3
+  puts "usage: ruby remote_throughput.rb <connect-to> <message-size> <message-count>"
+  Process.exit
+end
+
+connect_to = ARGV[0]
+message_size = ARGV[1].to_i
+message_count = ARGV[2].to_i
+
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
+begin
+  ctx = ZMQ::Context.new
+  s = ZMQ::Socket.new(ctx.pointer, ZMQ::PUB)
+rescue ContextError => e
+  STDERR.puts "Could not allocate a context or socket!"
+  raise
+end
+
+assert(s.setsockopt(ZMQ::LINGER, 1_000))
+assert(s.connect(connect_to))
+
+contents = "#{'0'*message_size}"
+
+i = 0
+while i < message_count
+  msg = ZMQ::Message.new(contents)
+  assert(s.send(msg))
+  i += 1
+end
+
+assert(s.close)
+
+ctx.terminate

data/examples/v2api/reqrep_poll.rb

@@ -0,0 +1,62 @@
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
+
+
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
+link = "tcp://127.0.0.1:5554"
+
+begin
+  ctx = ZMQ::Context.new
+  s1 = ctx.socket(ZMQ::REQ)
+  s2 = ctx.socket(ZMQ::REP)
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket!"
+  raise
+end
+
+assert(s1.setsockopt(ZMQ::LINGER, 100))
+assert(s2.setsockopt(ZMQ::LINGER, 100))
+
+assert(s1.connect(link))
+assert(s2.bind(link))
+
+poller = ZMQ::Poller.new
+poller.register_readable(s2)
+poller.register_writable(s1)
+
+start_time = Time.now
+@unsent = true
+
+until @done do
+  assert(poller.poll_nonblock)
+
+  # send the message after 5 seconds
+  if Time.now - start_time > 5 && @unsent
+    payload = "#{ '3' * 1024 }"
+
+    puts "sending payload nonblocking"
+    assert(s1.send_string(payload, ZMQ::NOBLOCK))
+    @unsent = false
+  end
+
+  # check for messages after 1 second
+  if Time.now - start_time > 1
+    poller.readables.each do |sock|
+      received_msg = ''
+      assert(sock.recv_string(received_msg, ZMQ::NOBLOCK))
+
+      puts "message received [#{received_msg}]"
+      @done = true
+    end
+  end
+end
+
+puts "executed in [#{Time.now - start_time}] seconds"
+
+assert(s1.close)
+assert(s2.close)
+
+ctx.terminate

data/examples/v2api/request_response.rb

@@ -0,0 +1,40 @@
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
+
+
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
+link = "tcp://127.0.0.1:5555"
+
+begin
+  ctx = ZMQ::Context.new
+  s1 = ctx.socket(ZMQ::REQ)
+  s2 = ctx.socket(ZMQ::REP)
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket"
+  raise
+end
+
+assert(s1.setsockopt(ZMQ::LINGER, 100))
+assert(s2.setsockopt(ZMQ::LINGER, 100))
+
+assert(s2.bind(link))
+assert(s1.connect(link))
+
+payload = "#{ '3' * 2048 }"
+sent_msg = ZMQ::Message.new(payload)
+received_msg = ZMQ::Message.new
+
+assert(s1.send(sent_msg))
+assert(s2.recv(received_msg))
+
+result = payload == received_msg.copy_out_string ? "Request received" : "Received wrong payload"
+
+p result
+
+assert(s1.close)
+assert(s2.close)
+
+ctx.terminate

data/examples/v2api/throughput_measurement.rb

@@ -0,0 +1,138 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
+
+
+# Within a single process, we start up five threads. Main thread has a PUB (publisher)
+# socket and the secondary threads have SUB (subscription) sockets. We measure the
+# *throughput* between these sockets. A high-water mark (HWM) is *not* set, so the
+# publisher queue is free to grow to the size of memory without dropping packets.
+#
+# This example also illustrates how a single context can be shared amongst several
+# threads. Sharing a single context also allows a user to specify the "inproc"
+# transport in addition to "tcp" and "ipc".
+#
+#  % ruby throughput_measurement.rb tcp://127.0.0.1:5555 1024 1_000_000
+#
+#  % ruby throughput_measurement.rb inproc://lm_sock 1024 1_000_000
+#
+
+if ARGV.length < 3
+  puts "usage: ruby throughput_measurement.rb <connect-to> <message-size> <roundtrip-count>"
+  exit
+end
+
+link = ARGV[0]
+message_size = ARGV[1].to_i
+count = ARGV[2].to_i
+
+def assert(rc)
+  raise "Last API call failed at #{caller(1)}" unless rc >= 0
+end
+
+begin
+  master_context = ZMQ::Context.new
+rescue ContextError => e
+  STDERR.puts "Failed to allocate context or socket!"
+  raise
+end
+
+
+class Receiver
+  def initialize context, link, size, count
+    @context = context
+    @link = link
+    @size = size
+    @count = count
+
+    begin
+      @socket = @context.socket(ZMQ::SUB)
+    rescue ContextError => e
+      STDERR.puts "Failed to allocate SUB socket!"
+      raise
+    end
+
+    assert(@socket.setsockopt(ZMQ::LINGER, 100))
+    assert(@socket.setsockopt(ZMQ::SUBSCRIBE, ""))
+
+    assert(@socket.connect(@link))
+  end
+
+  def run
+    msg = ZMQ::Message.new
+    assert(@socket.recv(msg))
+
+    elapsed = elapsed_microseconds do
+      (@count -1).times do
+        assert(@socket.recv(msg))
+      end
+    end
+
+    throughput = @count * 1000000 / elapsed
+    megabits = throughput * @size * 8 / 1000000
+
+    puts "message size: %i [B]" % @size
+    puts "message count: %i" % @count
+    puts "mean throughput: %i [msg/s]" % throughput
+    puts "mean throughput: %.3f [Mb/s]" % megabits
+
+    assert(@socket.close)
+  end
+
+  def elapsed_microseconds(&blk)
+    start = Time.now
+    yield
+    ((Time.now - start) * 1_000_000)
+  end
+end
+
+class Transmitter
+  def initialize context, link, size, count
+    @context = context
+    @link = link
+    @size = size
+    @count = count
+
+    begin
+      @socket = @context.socket(ZMQ::PUB)
+    rescue ContextError => e
+      STDERR.puts "Failed to allocate PUB socket!"
+      raise
+    end
+
+    assert(@socket.setsockopt(ZMQ::LINGER, 100))
+
+    assert(@socket.bind(@link))
+  end
+
+  def run
+    sleep 1
+    contents = "#{'0' * @size}"
+
+    i = 0
+    while i < @count
+      msg = ZMQ::Message.new(contents)
+      assert(@socket.send(msg))
+      i += 1
+    end
+
+    assert(@socket.close)
+  end
+end
+
+threads = []
+
+threads << Thread.new do
+  transmitter = Transmitter.new(master_context, link, message_size, count)
+  transmitter.run
+end
+
+1.times do
+  threads << Thread.new do
+    receiver = Receiver.new(master_context, link, message_size, count)
+    receiver.run
+  end
+end
+
+
+threads.each {|t| t.join}
+
+master_context.terminate