From: funny.falcon@... Date: 2018-07-04T07:37:56+00:00 Subject: [ruby-core:87776] [Ruby trunk Feature#13618] [PATCH] auto fiber schedule for rb_wait_for_single_fd and rb_waitpid Issue #13618 has been updated by funny_falcon (Yura Sokolov). Considering implementation, `Fiber.transfer` should be used, not `Fiber.resume`+`Fiber.yield`, ie exclusively use `fiber_switch(..., ..., ..., 0);` and never use `fiber_yield(..., ...)`+`fuber_resume(...,...,...)`. Reason: to allow nested fiber calls to be scheduled as well. Example: Lets have following class ```ruby class MyPipe def initialize(host, port) @con = TCPSocket.new(host, port) end def pipe while s = @con.gets yield s end end end mypipe = MyPipe.new ``` Now lets iterate: ```ruby mypipe.pipe{|s| puts s} ``` So far so good. But now lets use it as enumerator: ```ruby mypipe.to_enum(:pipe).each{|s| puts s} ``` BAAHHHMMMM!!!! Either we have to fallback to blocking io at `@conn.gets`, or `fiber_yield` inside of scheduler will yield our `puts s` block, instead of returning to scheduler. Both Enumerator and io scheduler could not use same `fiber_yield`. There should be scheduler fiber as a property of native thread (probably, its main fiber), and scheduled "Threadlets" should transfer control to it, not yield to. ------------- Second remark about design: please, do not create new beast! Ruby has Thread, Fiber, Continuation... It doesn't need new Thread::Light, Fred or any thing else! Let it be just Thread!!! In my opinion, Thread should be either "green" by default, or by constructor parameter. Looks like, for backward compatibility, it is better to have native threads still default: - first, all disk io heavy application will not magically turn into turtles after Ruby's version upgrade (so, Eric's application will work unmodified) - aside of disk io and network io, there are heavy computations, that are also wrapped with "release GVL". I think, it could be good to have possibility to specify different scheduler variants: - `Thread.new(scheduler: :current)` - create thread in a scheduler of current native thread. - `Thread.new(scheduler: :main)` - create thread in a scheduler of main native thread. - `Thread.new(scheduler: :new)` - create new native thread, and schedule new thread there. - `Thread.new(scheduler: other_thread.scheduler)` - create new thread in a scheduler of other thread. - `Thread.new(scheduler: :exclusive)` - create new native thread without scheduler, and run Thread on a native thread stack. Default `Thread.new` should be synonym for `Thread.new(scheduler: :new)` or `Thread.new(scheduler: :exclusive)`. Mutex and Queue should be aware of new scheduling model, because there will be only one Thread class. To be honest, I'd prefer Thread to be green by default. But given, it is desirable to accept this change before 3.0, it is better to keep compatible behavior, i think. ---------------------------------------- Feature #13618: [PATCH] auto fiber schedule for rb_wait_for_single_fd and rb_waitpid https://bugs.ruby-lang.org/issues/13618#change-72798 * Author: normalperson (Eric Wong) * Status: Assigned * Priority: Normal * Assignee: normalperson (Eric Wong) * Target version: ---------------------------------------- ``` auto fiber schedule for rb_wait_for_single_fd and rb_waitpid Implement automatic Fiber yield and resume when running rb_wait_for_single_fd and rb_waitpid. The Ruby API changes for Fiber are named after existing Thread methods. main Ruby API: Fiber#start -> enable auto-scheduling and run Fiber until it automatically yields (due to EAGAIN/EWOULDBLOCK) The following behave like their Thread counterparts: Fiber.start - Fiber.new + Fiber#start (prelude.rb) Fiber#join - run internal scheduler until Fiber is terminated Fiber#value - ditto Fiber#run - like Fiber#start (prelude.rb) Right now, it takes over rb_wait_for_single_fd() and rb_waitpid() function if the running Fiber is auto-enabled (cont.c::rb_fiber_auto_sched_p) Changes to existing functions are minimal. New files (all new structs and relations should be documented): iom.h - internal API for the rest of RubyVM (incomplete?) iom_internal.h - internal header for iom_(select|epoll|kqueue).h iom_epoll.h - epoll-specific pieces iom_kqueue.h - kqueue-specific pieces iom_select.h - select-specific pieces iom_pingable_common.h - common code for iom_(epoll|kqueue).h iom_common.h - common footer for iom_(select|epoll|kqueue).h Changes to existing data structures: rb_thread_t.afrunq - list of fibers to auto-resume rb_vm_t.iom - Ruby I/O Manager (rb_iom_t) :) Besides rb_iom_t, all the new structs are stack-only and relies extensively on ccan/list for branch-less, O(1) insert/delete. As usual, understanding the data structures first should help you understand the code. Right now, I reuse some static functions in thread.c, so thread.c includes iom_(select|epoll|kqueue).h TODO: Hijack other blocking functions (IO.select, ...) I am using "double" for timeout since it is more convenient for arithmetic like parts of thread.c. Most platforms have good FP, I think. Also, all "blocking" functions (rb_iom_wait*) will have timeout support. ./configure gains a new --with-iom=(select|epoll|kqueue) switch libkqueue: libkqueue support is incomplete; corner cases are not handled well: 1) multiple fibers waiting on the same FD 2) waiting for both read and write events on the same FD Bugfixes to libkqueue may be necessary to support all corner cases. Supporting these corner cases for native kqueue was challenging, even. See comments on iom_kqueue.h and iom_epoll.h for nuances. Limitations Test script I used to download a file from my server: ----8<--- require 'net/http' require 'uri' require 'digest/sha1' require 'fiber' url = 'http://80x24.org/git-i-forgot-to-pack/objects/pack/pack-97b25a76c03b489d4cbbd85b12d0e1ad28717e55.idx' uri = URI(url) use_ssl = "https" == uri.scheme fibs = 10.times.map do Fiber.start do cur = Fiber.current.object_id # XXX getaddrinfo() and connect() are blocking # XXX resolv/replace + connect_nonblock Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http| req = Net::HTTP::Get.new(uri) http.request(req) do |res| dig = Digest::SHA1.new res.read_body do |buf| dig.update(buf) #warn "#{cur} #{buf.bytesize}\n" end warn "#{cur} #{dig.hexdigest}\n" end end warn "done\n" :done end end warn "joining #{Time.now}\n" fibs[-1].join(4) warn "joined #{Time.now}\n" all = fibs.dup warn "1 joined, wait for the rest\n" until fibs.empty? fibs.each(&:join) fibs.keep_if(&:alive?) warn fibs.inspect end p all.map(&:value) Fiber.new do puts 'HI' end.run.join ``` ---Files-------------------------------- 0001-auto-fiber-schedule-for-rb_wait_for_single_fd-and-rb.patch (82.8 KB) -- https://bugs.ruby-lang.org/ Unsubscribe: