uringmachine 0.21.0 → 0.22.0

data/benchmark/bm_pg_client.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative './common'
+require 'securerandom'
+
+C = ENV['C']&.to_i ||50
+I = 1000
+puts "C=#{C}"
+
+class UMBenchmark
+  CONTAINER_NAME = "pg-#{SecureRandom.hex}"
+
+  def start_pg_server
+    `docker run --name #{CONTAINER_NAME} -e POSTGRES_PASSWORD=my_password -d -p 5432:5432 postgres`
+  end
+
+  def stop_pg_server
+    `docker stop #{CONTAINER_NAME}`
+  end
+
+  PG_OPTS = {
+    host:                         'localhost',
+    user:                         'postgres',
+    password:                     'my_password',
+    dbname:                       'postgres'
+  }
+
+  def create_db_conn(retries = 0)
+    ::PG.connect(PG_OPTS)
+  rescue ::PG::ConnectionBad
+    if retries < 3
+      sleep 0.5
+      create_db_conn(retries + 1)
+    else
+    raise
+    end
+  end
+
+  PREPARE_SQL = <<~SQL
+    create table if not exists foo(value int, name text);
+    create index if not exists idx_foo_value on foo(value);
+    with t1 as (
+      select generate_series(1,100000)
+      ),
+    t2 as (
+      select (random()*1000000)::integer as value,
+             (md5(random()::text)) as name
+      from t1
+    )
+    insert into foo(value, name) select * from t2;
+  SQL
+
+  def prepare_db
+    STDOUT << "Preparing database..."
+    t0 = Time.now
+    conn = create_db_conn
+    conn.exec(PREPARE_SQL)
+    puts " elapsed: #{Time.now - t0}"
+  end
+
+  def query_db(conn)
+    min = rand(1000000)
+    max = min + 2000
+    sql = format(
+      'select * from foo where value >= %d and value < %d;', min, max
+    )
+    conn.query(sql).to_a
+  end
+
+  def with_container
+    start_pg_server
+    sleep 0.5
+    prepare_db
+    yield
+  rescue Exception => e
+    p e
+    p e.backtrace
+  ensure
+  stop_pg_server
+  end
+
+  def benchmark
+    with_container {
+      Benchmark.bm { run_benchmarks(it) }
+    }
+  end
+
+  def do_threads(threads, ios)
+    C.times.map do
+      threads << Thread.new do
+        conn = create_db_conn
+        I.times { query_db(conn) }
+      ensure
+        conn.close
+      end
+    end
+  end
+
+  def do_scheduler(scheduler, ios)
+    C.times do
+      Fiber.schedule do
+        conn = create_db_conn
+        I.times { query_db(conn) }
+      ensure
+        conn.close
+      end
+    end
+  end
+end

data/benchmark/bm_queue.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative './common'
+
+GROUPS = 40
+PRODUCERS = 5
+CONSUMERS = 10
+ITEMS = 200000
+
+class UMBenchmark
+  def do_threads(threads, ios)
+    GROUPS.times do
+      queue = Queue.new
+      PRODUCERS.times do
+        threads << Thread.new do
+          ITEMS.times { queue << rand(1000) }
+          CONSUMERS.times { queue << :stop }
+        end
+      end
+      CONSUMERS.times do
+        threads << Thread.new do
+          loop do
+            item = queue.shift
+            break if item == :stop
+
+            item * rand(1000)
+          end
+        end
+      end
+    end
+  end
+
+  def do_scheduler(scheduler, ios)
+    GROUPS.times do
+      queue = Queue.new
+      PRODUCERS.times do
+        Fiber.schedule do
+          ITEMS.times { queue << rand(1000) }
+          CONSUMERS.times { queue << :stop }
+        end
+      end
+      CONSUMERS.times do
+        Fiber.schedule do
+          loop do
+            item = queue.shift
+            break if item == :stop
+
+            item * rand(1000)
+          end
+        end
+      end
+    end
+  end
+
+  def do_um(machine, fibers, fds)
+    GROUPS.times do
+      queue = UM::Queue.new
+      PRODUCERS.times do
+        fibers << machine.spin do
+          ITEMS.times { machine.push(queue, rand(1000)) }
+          CONSUMERS.times { machine.push(queue, :stop) }
+        end
+      end
+      CONSUMERS.times do
+        fibers << machine.spin do
+          loop do
+            item = machine.shift(queue)
+            break if item == :stop
+
+            item * rand(1000)
+          end
+        end
+      end
+    end
+  end
+end

data/benchmark/common.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+  gem 'io-event'
+  gem 'async'
+  gem 'pg'
+end
+
+require 'uringmachine/fiber_scheduler'
+
+class WorkerThreadPool
+  def initialize(size)
+    @size = size
+    @queue = Queue.new
+    setup_threads
+    sleep 0.01 * @size
+  end
+
+  def queue(&block)
+    @queue << block
+  end
+
+  def join
+    @size.times { @queue << :stop }
+    @threads.each(&:join)
+  end
+
+  def setup_threads
+    @threads = @size.times.map {
+      Thread.new do
+        loop do
+          job = @queue.shift
+          break if job == :stop
+
+          job.()
+        end
+      end
+    }
+  end
+end
+
+class UMBenchmark
+  def initialize
+    @thread_pool = WorkerThreadPool.new(10)
+  end
+
+  def benchmark
+    Benchmark.bm { run_benchmarks(it) }
+  end
+
+  @@benchmarks = {
+    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"]
+  }
+
+  def run_benchmarks(b)
+    @@benchmarks.each do |sym, (doer, name)|
+      b.report(name) { send(:"run_#{sym}") } if respond_to?(:"do_#{doer}")
+    end
+  end
+
+  def run_threads
+    threads = []
+    ios = []
+    do_threads(threads, ios)
+    threads.each(&:join)
+    ios.each { it.close rescue nil }
+  end
+
+  def run_thread_pool
+    ios = []
+    do_thread_pool(@thread_pool, ios)
+    @thread_pool.join
+    ios.each { it.close rescue nil }
+  end
+
+  def run_async_uring
+    selector ||= IO::Event::Selector::URing.new(Fiber.current)
+    scheduler = Async::Scheduler.new(selector:)
+    Fiber.set_scheduler(scheduler)
+    ios = []
+    scheduler.run { do_scheduler(scheduler, ios) }
+    ios.each { it.close rescue nil }
+  end
+
+  def run_async_epoll
+    selector ||= IO::Event::Selector::EPoll.new(Fiber.current)
+    scheduler = Async::Scheduler.new(selector:)
+    Fiber.set_scheduler(scheduler)
+    ios = []
+    scheduler.run { do_scheduler(scheduler, ios) }
+    ios.each { it.close rescue nil }
+  end
+
+  def run_um_fs
+    machine = UM.new
+    scheduler = UM::FiberScheduler.new(machine)
+    Fiber.set_scheduler(scheduler)
+    ios = []
+    do_scheduler(scheduler, ios)
+    scheduler.join
+    ios.each { it.close rescue nil }
+  end
+
+  def run_um
+    machine = UM.new(4096)
+    fibers = []
+    fds = []
+    do_um(machine, fibers, fds)
+    machine.await_fibers(fibers)
+    fds.each { machine.close(it) }
+  end
+
+  def run_um_sqpoll
+    machine = UM.new(4096, true)
+    fibers = []
+    fds = []
+    do_um(machine, fibers, fds)
+    machine.await_fibers(fibers)
+    fds.each { machine.close_async(it) }
+    machine.snooze
+  end
+end
+
+at_exit { UMBenchmark.new.benchmark }

data/benchmark/dns_client.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+end
+
+require 'uringmachine'
+require 'resolv'
+
+def do_addrinfo
+  Addrinfo.tcp("status.realiteq.net", 80)
+end
+
+def do_resolv
+  Resolv.getaddresses('status.realiteq.net')
+end
+
+@machine = UM.new
+def do_um
+  @machine.resolve('status.realiteq.net')
+end
+
+# p do_addrinfo
+# p do_resolv
+# p do_um
+# exit
+
+Benchmark.ips do |x|
+  x.report("Addrinfo")    { do_addrinfo }
+  x.report("resolv")      { do_resolv }
+  x.report("UM.resolve")  { do_um }
+
+  x.compare!(order: :baseline)
+end
+
+
+
+# addrs = machine.resolve('status.realiteq.net')
+
+# puts '*' * 40
+# puts addrs.join("\n")
+# puts

data/{examples/bm_http_parse.rb → benchmark/http_parse.rb}

@@ -221,4 +221,4 @@ def benchmark
 end
 
 compare_allocs
-benchmark
+benchmark

data/benchmark/run_bm.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Dir["#{__dir__}/bm_*.rb"].each do |fn|
+  puts "* #{File.basename(fn)}"
+  puts
+  puts `ruby -W0 --yjit #{fn}`
+  puts
+end

data/benchmark/sqlite.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'extralite'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+end
+
+require 'uringmachine'
+require 'extralite'
+require 'benchmark/ips'
+require 'securerandom'
+require 'uringmachine/actor'
+
+class DBActor2
+  def initialize(machine, db)
+    @machine = machine
+    @db = db
+    @mailbox = UM::Queue.new
+  end
+
+  def act
+    while (a, k, peer = @machine.shift(@mailbox))
+
+      begin
+        ret = @db.query(*a, **k)
+        @machine.schedule(peer, ret)
+      rescue => e
+        @machine.schedule(peer, e)
+      end
+    end
+  rescue Exception => e
+    # handle unhandled exceptions
+  ensure
+    @machine.fiber_map.delete(self)
+    @machine.yield
+  end
+
+  def query(*a, **k)
+    @machine.push(@mailbox, [a, k, Fiber.current])
+    ret = @machine.yield
+    raise(ret) if ret.is_a?(Exception)
+    ret
+  end
+
+  def self.spin(machine, db)
+    actor = new(machine, db)
+    machine.spin { actor.act }
+    actor
+  end
+end
+
+PATH = "/tmp/um_bm_sqlite_#{SecureRandom.hex}"
+
+module DBActor
+  def setup(db)
+    @db = db
+  end
+
+  def query(*, **)
+    @db.query(*, **)
+  end
+end
+
+class Locker
+  def initialize(machine, target)
+    @machine = machine
+    @target = target
+    @mutex = UM::Mutex.new
+  end
+
+  def method_missing(sym, *a, **k)
+    @machine.synchronize(@mutex) { @target.send(sym, *a, **k) }
+  end
+end
+
+def prepare_db(machine, path)
+  Extralite::Database.new(path).tap {
+    it.on_progress(mode: :at_least_once, period: 100, tick: 10) { machine.snooze }
+  }
+end
+
+machine = UM.new
+mailbox = UM::Queue.new
+raw_db = prepare_db(machine, PATH)
+actor_db = machine.spin_actor(DBActor, prepare_db(machine, PATH))
+actor2_db = DBActor2.spin(machine, prepare_db(machine, PATH))
+locker_db = Locker.new(machine, prepare_db(machine, PATH))
+
+p raw_db.query('select 1')
+p actor_db.call(mailbox, :query, 'select 1')
+p actor2_db.query('select 1')
+p locker_db.query('select 1')
+
+bm = Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 2)
+
+  x.report("raw")     { raw_db.query('select 1') }
+  x.report("actor")   { actor_db.call(mailbox, :query, 'select 1') }
+  x.report("actor2")  { actor2_db.query('select 1') }
+  x.report("locker")  { locker_db.query('select 1') }
+
+  x.compare!(order: :baseline)
+end

data/{examples/bm_write.rb → benchmark/write.rb}

@@ -11,7 +11,7 @@ end
 require 'benchmark'
 require 'uringmachine'
 
-ITERATIONS = 10000
+ITERATIONS = 100000
 BUF = ('*' * 8192).freeze
 FN = '/tmp/bm_write'
 
@@ -50,10 +50,10 @@ end
 run_io_write(1)
 run_um_write(1)
 
-Benchmark.bm do |x|
-  [1, 2, 4, 8].each do |c|
+[1, 2, 4, 8].each do |c|
+  Benchmark.bm do |x|
     x.report("IO (#{c} threads)")     { run_io_write(c) }
     x.report("UM (#{c} fibers) ")     { run_um_write(c) }
-    puts
   end
+  puts
 end