ffi-rzmq 1.0.3 → 2.0.1

data/examples/v2api/sub.rb

@@ -1,74 +0,0 @@
-
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
-
-#if ARGV.length != 3
-#  puts "usage: ruby local_throughtput.rb <bind-to> <message-size> <message-count>"
-#  Process.exit
-#end
-p ZMQ::Util.version
-
-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
-sleep_time = ARGV[3].to_f
-
-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
-
-#assert(s.setsockopt(ZMQ::LINGER, 100))
-assert(s.setsockopt(ZMQ::IDENTITY, rand(999_999).to_s))
-assert(s.setsockopt(ZMQ::SUBSCRIBE, ""))
-assert(s.setsockopt(ZMQ::HWM, 1))
-#assert(s.setsockopt(ZMQ::RCVHWM, 0))
-#assert(s.setsockopt(ZMQ::SNDHWM, 0))
-
-assert(s.connect(bind_to))
-sleep 1
-
-msg = ZMQ::Message.new
-msg = ''
-assert(s.recv_string(msg))
-raise unless msg.to_i == 0
-
-start_time = Time.now
-
-i = 1
-while i < message_count - 1
-  assert(s.recv_string(msg))
-  msg_i = msg.to_i
-  missed = (msg_i - i) - 1
-  puts "missed [#{missed}] messages" if missed > 0
-  i = msg_i
-  
-  start = Time.now
-  while (Time.now - start) < sleep_time
-  end
-end
-
-end_time = Time.now
-
-elapsed = (end_time.to_f - start_time.to_f) * 1000000
-if elapsed == 0
-  elapsed = 1
-end
-
-throughput = message_count * 1000000 / elapsed
-megabits = throughput * message_size * 8 / 1000000
-
-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/throughput_measurement.rb

@@ -1,138 +0,0 @@
-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.recvmsg(msg))
-
-    elapsed = elapsed_microseconds do
-      (@count -1).times do
-        assert(@socket.recvmsg(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.sendmsg(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

data/examples/v2api/xreqxrep_poll.rb

@@ -1,93 +0,0 @@
-
-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::XREQ)
-  s2 = ctx.socket(ZMQ::XREP)
-rescue ContextError => e
-  STDERR.puts "Failed to allocate context or socket"
-  raise
-end
-
-s1.identity = 'socket1.xreq'
-s2.identity = 'socket2.xrep'
-
-assert(s1.setsockopt(ZMQ::LINGER, 100))
-assert(s2.setsockopt(ZMQ::LINGER, 100))
-
-assert(s1.bind(link))
-assert(s2.connect(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
-    puts "sending payload nonblocking"
-
-    5.times do |i|
-      payload = "#{ i.to_s * 40 }"
-      assert(s1.send_string(payload, ZMQ::NonBlocking))
-    end
-    @unsent = false
-  end
-
-  # check for messages after 1 second
-  if Time.now - start_time > 1
-    poller.readables.each do |sock|
-
-      if sock.identity =~ /xrep/
-        routing_info = ''
-        assert(sock.recv_string(routing_info, ZMQ::NonBlocking))
-        puts "routing_info received [#{routing_info}] on socket.identity [#{sock.identity}]"
-      else
-        routing_info = nil
-        received_msg = ''
-        assert(sock.recv_string(received_msg, ZMQ::NonBlocking))
-
-        # skip to the next iteration if received_msg is nil; that means we got an EAGAIN
-        next unless received_msg
-        puts "message received [#{received_msg}] on socket.identity [#{sock.identity}]"
-      end
-
-      while sock.more_parts? do
-        received_msg = ''
-        assert(sock.recv_string(received_msg, ZMQ::NonBlocking))
-
-        puts "message received [#{received_msg}]"
-      end
-
-      puts "kick back a reply"
-      assert(sock.send_string(routing_info, ZMQ::SNDMORE | ZMQ::NonBlocking)) if routing_info
-      time = Time.now.strftime "%Y-%m-%dT%H:%M:%S.#{Time.now.usec}"
-      reply = "reply " + sock.identity.upcase + " #{time}"
-      puts "sent reply [#{reply}], #{time}"
-      assert(sock.send_string(reply))
-      @done = true
-      poller.register_readable(s1)
-    end
-  end
-end
-
-puts "executed in [#{Time.now - start_time}] seconds"
-
-assert(s1.close)
-assert(s2.close)
-
-ctx.terminate

data/examples/v3api/publish_subscribe.rb

@@ -1,82 +0,0 @@
-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::NonBlocking)
-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/v3api/remote_lat.rb

@@ -1,71 +0,0 @@
-#
-#    Copyright (c) 2007-2010 iMatix Corporation
-#
-#    This file is part of 0MQ.
-#
-#    0MQ is free software; you can redistribute it and/or modify it under
-#    the terms of the Lesser GNU General Public License as published by
-#    the Free Software Foundation; either version 3 of the License, or
-#    (at your option) any later version.
-#
-#    0MQ is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    Lesser GNU General Public License for more details.
-#
-#    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 File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
-
-if ARGV.length < 3
-  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
-
-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
-  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
-
-end_time = Time.now
-elapsed_secs = (end_time.to_f - start_time.to_f)
-elapsed_usecs = elapsed_secs * 1000000
-latency = elapsed_usecs / roundtrip_count / 2
-
-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/v3api/reqrep_poll.rb

@@ -1,62 +0,0 @@
-
-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::NonBlocking))
-    @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::NonBlocking))
-
-      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/v3api/request_response.rb

@@ -1,40 +0,0 @@
-
-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.sendmsg(sent_msg))
-assert(s2.recvmsg(received_msg))
-
-result = payload == received_msg.copy_out_string ? "Request received" : "Received wrong payload"
-
-p result
-
-assert(s1.close)
-assert(s2.close)
-
-ctx.terminate