uringmachine 0.23.1 → 0.25.0

data/benchmark/bm_io_socketpair.rb

@@ -3,10 +3,10 @@
 require_relative './common'
 require 'socket'
 
-GROUPS = 50
+GROUPS = 48
 ITERATIONS = 10000
 
-SIZE = 1024
+SIZE = 1 << 14
 DATA = '*' * SIZE
 
 class UMBenchmark
@@ -55,6 +55,22 @@ class UMBenchmark
     end
   end
 
+  def do_scheduler_x(div, scheduler, ios)
+    (GROUPS/div).times do
+      r, w = Socket.socketpair(:AF_UNIX, :SOCK_STREAM, 0)
+      r.sync = true
+      w.sync = true
+      Fiber.schedule do
+        ITERATIONS.times { w.send(DATA, 0) }
+        w.close
+      end
+      Fiber.schedule do
+        ITERATIONS.times { r.recv(SIZE) }
+        r.close
+      end
+    end
+  end
+
   def do_um(machine, fibers, fds)
     GROUPS.times do
       r, w = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
@@ -68,4 +84,18 @@ class UMBenchmark
       end
     end
   end
+
+  def do_um_x(div, machine, fibers, fds)
+    (GROUPS/div).times do
+      r, w = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
+      fibers << machine.spin do
+        ITERATIONS.times { machine.send(w, DATA, SIZE, UM::MSG_WAITALL) }
+        machine.close_async(w)
+      end
+      fibers << machine.spin do
+        ITERATIONS.times { machine.recv(r, +'', SIZE, 0) }
+        machine.close_async(r)
+      end
+    end
+  end
 end

data/benchmark/bm_mutex_io.rb

@@ -4,9 +4,9 @@ require_relative './common'
 require 'securerandom'
 require 'fileutils'
 
-GROUPS = ENV['N']&.to_i || 50
+GROUPS = ENV['N']&.to_i || 48
 WORKERS = 10
-ITERATIONS = 1000
+ITERATIONS = 10000
 
 puts "N=#{GROUPS}"
 
@@ -14,10 +14,15 @@ SIZE = 1024
 DATA = "*" * SIZE
 
 class UMBenchmark
+  def cleanup
+    # `rm /tmp/mutex*` rescue nil
+  end
+
   def do_threads(threads, ios)
     GROUPS.times do
       mutex = Mutex.new
-      ios << (f = File.open("/tmp/mutex_io_threads_#{SecureRandom.hex}", 'w'))
+      # ios << (f = File.open("/tmp/mutex_io_threads_#{SecureRandom.hex}", 'w'))
+      ios << (f = File.open("/dev/null", 'w'))
       f.sync = true
       WORKERS.times do
         threads << Thread.new do
@@ -34,7 +39,24 @@ class UMBenchmark
   def do_scheduler(scheduler, ios)
     GROUPS.times do
       mutex = Mutex.new
-      ios << (f = File.open("/tmp/mutex_io_fiber_scheduler_#{SecureRandom.hex}", 'w'))
+      # ios << (f = File.open("/tmp/mutex_io_fiber_scheduler_#{SecureRandom.hex}", 'w'))
+      ios << (f = File.open("/dev/null", 'w'))
+      f.sync = true
+      WORKERS.times do
+        Fiber.schedule do
+          ITERATIONS.times do
+            mutex.synchronize { f.write(DATA) }
+          end
+        end
+      end
+    end
+  end
+
+  def do_scheduler_x(div, scheduler, ios)
+    (GROUPS/div).times do
+      mutex = Mutex.new
+      # ios << (f = File.open("/tmp/mutex_io_fiber_scheduler_#{SecureRandom.hex}", 'w'))
+      ios << (f = File.open("/dev/null", 'w'))
       f.sync = true
       WORKERS.times do
         Fiber.schedule do
@@ -49,7 +71,27 @@ class UMBenchmark
   def do_um(machine, fibers, fds)
     GROUPS.times do
       mutex = UM::Mutex.new
-      fds << (fd = machine.open("/tmp/mutex_io_um_#{SecureRandom.hex}", UM::O_CREAT | UM::O_WRONLY))
+      # fds << (fd = machine.open("/tmp/mutex_io_um_#{SecureRandom.hex}", UM::O_CREAT | UM::O_WRONLY))
+      fds << (fd = machine.open("/dev/null", UM::O_WRONLY))
+      WORKERS.times do
+        fibers << machine.spin do
+          ITERATIONS.times do
+            machine.synchronize(mutex) do
+              machine.write(fd, DATA)
+            end
+          end
+        rescue => e
+          p e
+        end
+      end
+    end
+  end
+
+  def do_um_x(div, machine, fibers, fds)
+    (GROUPS/div).times do
+      mutex = UM::Mutex.new
+      # fds << (fd = machine.open("/tmp/mutex_io_um_#{SecureRandom.hex}", UM::O_CREAT | UM::O_WRONLY))
+      fds << (fd = machine.open("/dev/null", UM::O_WRONLY))
       WORKERS.times do
         fibers << machine.spin do
           ITERATIONS.times do

data/benchmark/common.rb

@@ -9,6 +9,9 @@ gemfile do
   gem 'io-event'
   gem 'async'
   gem 'pg'
+  gem 'gvltools'
+  gem 'openssl'
+  gem 'localhost'
 end
 
 require 'uringmachine/fiber_scheduler'
@@ -54,26 +57,56 @@ class UMBenchmark
   end
 
   @@benchmarks = {
-    baseline:     [:baseline,     "No Concurrency"],
-    threads:      [:threads,      "Threads"],
-    thread_pool:  [:thread_pool,  "ThreadPool"],
-    async_uring:  [:scheduler,    "Async uring"],
-    async_epoll:  [:scheduler,    "Async epoll"],
-    um_fs:        [:scheduler,    "UM FS"],
-    um:           [:um,           "UM"],
-    um_sqpoll:    [:um,           "UM sqpoll"]
+    # baseline:     [:baseline,     "No Concurrency"],
+    # baseline_um:  [:baseline_um,  "UM no concurrency"],
+    # thread_pool:  [:thread_pool,  "ThreadPool"],
+
+    threads:        [:threads,      "Threads"],
+
+    async_uring:    [:scheduler,    "Async uring"],
+    async_uring_x2: [:scheduler_x,  "Async uring x2"],
+
+    # async_epoll:    [:scheduler,    "Async epoll"],
+    # async_epoll_x2: [:scheduler_x,  "Async epoll x2"],
+
+    um_fs:          [:scheduler,    "UM FS"],
+    um_fs_x2:       [:scheduler_x,  "UM FS x2"],
+
+    um:             [:um,           "UM"],
+    um_sidecar:     [:um,           "UM sidecar"],
+    # um_sqpoll:      [:um,           "UM sqpoll"],
+    um_x2:          [:um_x,         "UM x2"],
+    um_x4:          [:um_x,         "UM x4"],
+    um_x8:          [:um_x,         "UM x8"],
   }
 
   def run_benchmarks(b)
+    STDOUT.sync = true
     @@benchmarks.each do |sym, (doer, name)|
-      b.report(name) { send(:"run_#{sym}") } if respond_to?(:"do_#{doer}")
+      if respond_to?(:"do_#{doer}")
+        STDOUT << "Running #{name}... "
+        ts = nil
+        b.report(name) {
+          ts = measure_time { send(:"run_#{sym}") }
+        }
+        p ts
+        cleanup
+      end
     end
   end
 
+  def cleanup
+  end
+
   def run_baseline
     do_baseline
   end
 
+  def run_baseline_um
+    machine = UM.new(4096)
+    do_baseline_um(machine)
+  end
+
   def run_threads
     threads = []
     ios = []
@@ -117,27 +150,140 @@ class UMBenchmark
     ios.each { it.close rescue nil }
   end
 
+  def run_async_uring_x2
+    threads  = 2.times.map do
+      Thread.new do
+        selector ||= IO::Event::Selector::URing.new(Fiber.current)
+        worker_pool = Async::Scheduler::WorkerPool.new
+        scheduler = Async::Scheduler.new(selector:, worker_pool:)
+        Fiber.set_scheduler(scheduler)
+        ios = []
+        scheduler.run { do_scheduler_x(2, scheduler, ios) }
+        ios.each { it.close rescue nil }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  def run_async_epoll_x2
+    threads  = 2.times.map do
+      Thread.new do
+        selector ||= IO::Event::Selector::EPoll.new(Fiber.current)
+        scheduler = Async::Scheduler.new(selector:)
+        Fiber.set_scheduler(scheduler)
+        ios = []
+        scheduler.run { do_scheduler_x(2, scheduler, ios) }
+        ios.each { it.close rescue nil }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  def run_um_fs_x2
+    threads  = 2.times.map do
+      Thread.new do
+        machine = UM.new
+        thread_pool = UM::BlockingOperationThreadPool.new(2)
+        scheduler = UM::FiberScheduler.new(machine, thread_pool)
+        Fiber.set_scheduler(scheduler)
+        ios = []
+        do_scheduler_x(2, scheduler, ios)
+        scheduler.join
+        ios.each { it.close rescue nil }
+      end
+    end
+    threads.each(&:join)
+  end
+
   def run_um
-    machine = UM.new(4096)
+    machine = UM.new
+    fibers = []
+    fds = []
+    do_um(machine, fibers, fds)
+    machine.await_fibers(fibers)
+    fds.each { machine.close(it) }
+  end
+
+  def run_um_sidecar
+    machine = UM.new(sidecar: true)
     fibers = []
     fds = []
     do_um(machine, fibers, fds)
     machine.await_fibers(fibers)
-    puts "UM:"
-    p machine.metrics
     fds.each { machine.close(it) }
   end
 
   def run_um_sqpoll
-    machine = UM.new(4096, true)
+    machine = UM.new(sqpoll: true)
     fibers = []
     fds = []
     do_um(machine, fibers, fds)
     machine.await_fibers(fibers)
-    fds.each { machine.close_async(it) }
-    puts "UM sqpoll:"
-    p machine.metrics
-    machine.snooze
+    fds.each { machine.close(it) }
+  end
+
+  def run_um_x2
+    threads  = 2.times.map do
+      Thread.new do
+        machine = UM.new
+        fibers = []
+        fds = []
+        do_um_x(2, machine, fibers, fds)
+        machine.await_fibers(fibers)
+        fds.each { machine.close(it) }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  def run_um_x4
+    threads  = 4.times.map do
+      Thread.new do
+        machine = UM.new
+        fibers = []
+        fds = []
+        do_um_x(4, machine, fibers, fds)
+        machine.await_fibers(fibers)
+        fds.each { machine.close(it) }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  def run_um_x8
+    threads  = 8.times.map do
+      Thread.new do
+        machine = UM.new
+        fibers = []
+        fds = []
+        do_um_x(8, machine, fibers, fds)
+        machine.await_fibers(fibers)
+        fds.each { machine.close(it) }
+      end
+    end
+    threads.each(&:join)
+  end
+
+  def measure_time
+    GVLTools::GlobalTimer.enable
+    t0s = [
+      Process.clock_gettime(Process::CLOCK_MONOTONIC),
+      Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID),
+      GVLTools::GlobalTimer.monotonic_time / 1_000_000_000.0
+    ]
+    yield
+    t1s = [
+      Process.clock_gettime(Process::CLOCK_MONOTONIC),
+      Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID),
+      GVLTools::GlobalTimer.monotonic_time / 1_000_000_000.0
+    ]
+    {
+      monotonic:  t1s[0] - t0s[0],
+      cpu:        t1s[1] - t0s[1],
+      gvl:        t1s[2] - t0s[2]
+    }
+  ensure
+    GVLTools::GlobalTimer.disable
   end
 end
 

data/benchmark/http_parse.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-# require 'bundler/inline'
-
-# gemfile do
-#   source 'https://rubygems.org'
-#   gem 'uringmachine', path: '..'
-#   gem 'benchmark-ips'
-#   gem 'http_parser.rb'
-# end
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+  gem 'http_parser.rb'
+end
 
-require 'bundler/setup'
 require 'uringmachine'
 require 'benchmark/ips'
 require 'http/parser'

data/benchmark/http_server_accept_queue.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+end
+
+require 'uringmachine'
+
+RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
+RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
+
+def stream_get_request_line(stream, buf)
+  line = stream.get_line(buf, 0)
+  m = line&.match(RE_REQUEST_LINE)
+  return nil if !m
+
+  {
+    'method'   => m[1].downcase,
+    'path'     => m[2],
+    'protocol' => m[3].downcase
+  }
+end
+
+class InvalidHeadersError < StandardError; end
+
+def get_headers(stream, buf)
+  headers = stream_get_request_line(stream, buf)
+  return nil if !headers
+
+  while true
+    line = stream.get_line(buf, 0)
+    break if line.empty?
+
+    m = line.match(RE_HEADER_LINE)
+    raise InvalidHeadersError, "Invalid header" if !m
+
+    headers[m[1]] = m[2]
+  end
+
+  headers
+end
+
+BODY = "Hello, world!" * 1000
+
+def send_response(machine, fd)
+  headers = "HTTP/1.1 200\r\nContent-Length: #{BODY.bytesize}\r\n\r\n"
+  machine.sendv(fd, headers, BODY)
+end
+
+def handle_connection(machine, fd)
+  stream = UM::Stream.new(machine, fd)
+  buf = String.new(capacity: 65536)
+
+  while true
+    headers = get_headers(stream, buf)
+    break if !headers
+
+    send_response(machine, fd)
+  end
+rescue InvalidHeadersError, SystemCallError => e
+  # ignore
+ensure
+  machine.close_async(fd)
+end
+
+N = ENV['N']&.to_i || 1
+PORT = ENV['PORT']&.to_i || 1234
+
+accept_queue = UM::Queue.new
+
+acceptor = Thread.new do
+  machine = UM.new
+  fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+  machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+  machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEPORT, true)
+  machine.bind(fd, '127.0.0.1', PORT)
+  machine.listen(fd, 128)
+  machine.accept_into_queue(fd, accept_queue)
+rescue Exception => e
+  p e
+  p e.backtrace
+  exit!
+end
+
+workers = N.times.map do |idx|
+  Thread.new do
+    machine = UM.new
+
+    loop do
+      fd = machine.shift(accept_queue)
+      machine.spin { handle_connection(machine, fd) }
+    end
+  rescue Exception => e
+    p e
+    p e.backtrace
+    exit!
+  end
+end
+
+puts "Listening on localhost:#{PORT}, #{N} worker thread(s)"
+acceptor.join

data/benchmark/http_server_multi_accept.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+end
+
+require 'uringmachine'
+
+RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
+RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
+
+def stream_get_request_line(stream, buf)
+  line = stream.get_line(buf, 0)
+  m = line&.match(RE_REQUEST_LINE)
+  return nil if !m
+
+  {
+    'method'   => m[1].downcase,
+    'path'     => m[2],
+    'protocol' => m[3].downcase
+  }
+end
+
+class InvalidHeadersError < StandardError; end
+
+def get_headers(stream, buf)
+  headers = stream_get_request_line(stream, buf)
+  return nil if !headers
+
+  while true
+    line = stream.get_line(buf, 0)
+    break if line.empty?
+
+    m = line.match(RE_HEADER_LINE)
+    raise InvalidHeadersError, "Invalid header" if !m
+
+    headers[m[1]] = m[2]
+  end
+
+  headers
+end
+
+BODY = "Hello, world!" * 1000
+
+def send_response(machine, fd)
+  headers = "HTTP/1.1 200\r\nContent-Length: #{BODY.bytesize}\r\n\r\n"
+  machine.sendv(fd, headers, BODY)
+end
+
+def handle_connection(machine, fd)
+  stream = UM::Stream.new(machine, fd)
+  buf = String.new(capacity: 65536)
+
+  while true
+    headers = get_headers(stream, buf)
+    break if !headers
+
+    send_response(machine, fd)
+  end
+rescue InvalidHeadersError, SystemCallError => e
+  # ignore
+ensure
+  machine.close_async(fd)
+end
+
+N = ENV['N']&.to_i || 1
+PORT = ENV['PORT']&.to_i || 1234
+
+workers = N.times.map do |idx|
+  Thread.new do
+    machine = UM.new
+
+    listen_fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    machine.setsockopt(listen_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    machine.setsockopt(listen_fd, UM::SOL_SOCKET, UM::SO_REUSEPORT, true)
+    machine.bind(listen_fd, '127.0.0.1', PORT)
+    machine.listen(listen_fd, 128)
+
+    machine.accept_each(listen_fd) { |fd|
+      machine.spin { handle_connection(machine, fd) }
+    }
+  rescue Exception => e
+    p e
+    p e.backtrace
+    exit!
+  end
+end
+
+puts "Listening on localhost:#{PORT}, #{N} worker thread(s)"
+workers.each(&:join)

data/benchmark/http_server_multi_ractor.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+end
+
+require 'uringmachine'
+
+RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
+RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
+
+def stream_get_request_line(stream, buf)
+  line = stream.get_line(buf, 0)
+  m = line&.match(RE_REQUEST_LINE)
+  return nil if !m
+
+  {
+    'method'   => m[1].downcase,
+    'path'     => m[2],
+    'protocol' => m[3].downcase
+  }
+end
+
+class InvalidHeadersError < StandardError; end
+
+def get_headers(stream, buf)
+  headers = stream_get_request_line(stream, buf)
+  return nil if !headers
+
+  while true
+    line = stream.get_line(buf, 0)
+    break if line.empty?
+
+    m = line.match(RE_HEADER_LINE)
+    raise InvalidHeadersError, "Invalid header" if !m
+
+    headers[m[1]] = m[2]
+  end
+
+  headers
+end
+
+BODY = "Hello, world!" * 1000
+Ractor.make_shareable(BODY)
+
+def send_response(machine, fd)
+  headers = "HTTP/1.1 200\r\nContent-Length: #{BODY.bytesize}\r\n\r\n"
+  machine.sendv(fd, headers, BODY)
+end
+
+def handle_connection(machine, fd)
+  machine.setsockopt(fd, UM::IPPROTO_TCP, UM::TCP_NODELAY, true)
+  stream = UM::Stream.new(machine, fd)
+  buf = String.new(capacity: 65536)
+
+  while true
+    headers = get_headers(stream, buf)
+    break if !headers
+
+    send_response(machine, fd)
+  end
+# rescue InvalidHeadersError, SystemCallError => e
+  # ignore
+rescue Exception => e
+  p e: e
+  p bt: e.backtrace
+  exit!
+ensure
+  machine.close_async(fd)
+end
+
+N = ENV['N']&.to_i || 1
+PORT = ENV['PORT']&.to_i || 1234
+
+workers = N.times.map do |idx|
+  Ractor.new do
+    machine = UM.new
+
+    listen_fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    machine.setsockopt(listen_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    machine.setsockopt(listen_fd, UM::SOL_SOCKET, UM::SO_REUSEPORT, true)
+    machine.bind(listen_fd, '127.0.0.1', PORT)
+    machine.listen(listen_fd, 128)
+
+    machine.accept_each(listen_fd) { |fd|
+      machine.spin { handle_connection(machine, fd) }
+    }
+  rescue Exception => e
+    p e
+    p e.backtrace
+    exit!
+  end
+end
+
+puts "Listening on localhost:#{PORT}, #{N} worker ractor(s)"
+workers.each(&:join)