ffi-rzmq 1.0.3 → 2.0.0

data/examples/v2api/local_lat_poll.rb

@@ -1,66 +0,0 @@
-
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'ffi-rzmq')
-
-if ARGV.length < 3
-  puts "usage: ruby local_lat.rb <connect-to> <message-size> <roundtrip-count>"
-  exit
-end
-
-link = ARGV[0]
-message_size = ARGV[1].to_i
-roundtrip_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
-  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_readable(s1)
-
-
-start_time = Time.now
-
-# kick it off
-message = ZMQ::Message.new("a" * message_size)
-assert(s1.sendmsg(message, ZMQ::NonBlocking))
-
-i = roundtrip_count
-
-until i.zero?
-  i -= 1
-
-  assert(poller.poll_nonblock)
-
-  poller.readables.each do |socket|
-    received_message = ''
-    assert(socket.recv_string(received_message, ZMQ::NonBlocking))
-    assert(socket.sendmsg(ZMQ::Message.new(received_message), ZMQ::NonBlocking))
-  end
-end
-
-elapsed_usecs = (Time.now.to_f - start_time.to_f) * 1_000_000
-latency = elapsed_usecs / roundtrip_count / 2
-
-puts "mean latency: %.3f [us]" % latency
-puts "received all messages in %.3f seconds" % (elapsed_usecs / 1_000_000)
-
-assert(s1.close)
-assert(s2.close)
-
-ctx.terminate

data/examples/v2api/local_throughput.rb

@@ -1,58 +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
-
-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
-
-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::SUBSCRIBE, ""))
-
-assert(s.bind(bind_to))
-
-msg = ZMQ::Message.new
-assert(s.recvmsg(msg))
-
-start_time = Time.now
-
-i = 1
-while i < message_count
-  assert(s.recvmsg(msg))
-  i += 1
-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/pub.rb

@@ -1,46 +0,0 @@
-
-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.setsockopt(ZMQ::RCVHWM, 0))
-assert(s.setsockopt(ZMQ::HWM, 10))
-assert(s.bind(connect_to))
-
-# the sleep gives the downstream SUB socket a chance to register its
-# subscription filters with this PUB socket
-puts "Hit any key to start publishing"
-STDIN.gets
-
-i = 0
-while i < message_count
-  msg = ZMQ::Message.new(i.to_s)
-  assert(s.sendmsg(msg))
-  puts i
-  i += 1
-end
-
-sleep 10
-assert(s.close)
-
-ctx.terminate

data/examples/v2api/remote_throughput.rb

@@ -1,39 +0,0 @@
-
-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.sendmsg(msg))
-  i += 1
-end
-
-assert(s.close)
-
-ctx.terminate

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