A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://docs.ruby-lang.org/en/3.0/ractor_md.html below:

ractor - RDoc Documentation

Ractor - Ruby's Actor-like concurrent abstraction ↑

Ractor is designed to provide a parallel execution feature of Ruby without thread-safety concerns.

Summary ↑ Multiple Ractors in an interpreter process ↑

You can make multiple Ractors and they run in parallel.

Limited sharing between multiple ractors ↑

Ractors don't share everything, unlike threads.

Two-types communication between Ractors ↑

Ractors communicate with each other and synchronize the execution by message exchanging between Ractors. There are two message exchange protocols: push type (message passing) and pull type.

Copy & Move semantics to send messages ↑

To send unshareable objects as messages, objects are copied or moved.

Thread-safety ↑

Ractor helps to write a thread-safe concurrent program, but we can make thread-unsafe programs with Ractors.

Without Ractor, we need to trace all of state-mutations to debug thread-safety issues. With Ractor, you can concentrate to suspicious code which are shared with Ractors.

Creation and termination ↑ Ractor.new ↑ 
r = Ractor.new do
  
end


r = Ractor.new name: 'test-name' do
end


r.name
Given block isolation ↑

The Ractor execute given expr in a given block. Given block will be isolated from outer scope by Proc#isolate. To prevent sharing unshareable objects between ractors, block outer-variables, self and other information are isolated.

Given block will be isolated by Proc#isolate method (not exposed yet for Ruby users). Proc#isolate is called at Ractor creation timing (Ractor.new is called). If given Proc object is not enable to isolate because of outer variables and so on, an error will be raised.

begin
  a = true
  r = Ractor.new do
    a 
  end
  r.take 
rescue ArgumentError
end

r = Ractor.new do
  p self.class 
  self.object_id
end
r.take == self.object_id

Passed arguments to Ractor.new() becomes block parameters for the given block. However, an interpreter does not pass the parameter object references, but send them as messages (see below for details).

r = Ractor.new 'ok' do |msg|
  msg 
end
r.take 

r = Ractor.new do
  msg = Ractor.receive
  msg
end
r.send 'ok'
r.take
An execution result of given block ↑

Return value of the given block becomes an outgoing message (see below for details).

r = Ractor.new do
  'ok'
end
r.take 

r = Ractor.new do
  Ractor.yield 'ok'
end
r.take

Error in the given block will be propagated to the receiver of an outgoing message.

r = Ractor.new do
  raise 'ok' 
end

begin
  r.take
rescue Ractor::RemoteError => e
  e.cause.class   
  e.cause.message 
  e.ractor        
end
Communication between Ractors ↑

Communication between Ractors is achieved by sending and receiving messages. There is two way to communicate each other.

Users can control program execution timing with (1), but should not control with (2) (only manage as critical section).

For message sending and receiving, there are two types APIs: push type and pull type.

Sending/Receiving ports ↑

Each Ractor has incoming-port and outgoing-port. Incoming-port is connected to the infinite sized incoming queue.

Ractor r
                 +-------------------------------------------+
                 | incoming                         outgoing |
                 | port                                 port |
   r.send(obj) ->*->[incoming queue]     Ractor.yield(obj) ->*-> r.take
                 |                |                          |
                 |                v                          |
                 |           Ractor.receive                  |
                 +-------------------------------------------+


Connection example: r2.send obj on r1、Ractor.receive on r2
  +----+     +----+
  * r1 |---->* r2 *
  +----+     +----+


Connection example: Ractor.yield(obj) on r1, r1.take on r2
  +----+     +----+
  * r1 *---->- r2 *
  +----+     +----+

Connection example: Ractor.yield(obj) on r1 and r2,
                    and waiting for both simultaneously by Ractor.select(r1, r2)

  +----+
  * r1 *------+
  +----+      |
              +----> Ractor.select(r1, r2)
  +----+      |
  * r2 *------|
  +----+
r = Ractor.new do
    msg = Ractor.receive 
    msg 
  end
  r.send 'ok' 
  r.take

The last example shows the following ractor network.

  +------+        +---+
  * main |------> * r *---+
  +-----+         +---+   |
      ^                   |
      +-------------------+

And this code can be rewrite more simple way by using an argument for Ractor.new.

  r = Ractor.new 'ok' do |msg|
    
    

    msg 
  end

  
  r.take
Return value of a block for Ractor.new ↑

As already explained, the return value of Ractor.new (an evaluated value of expr in Ractor.new{ expr }) can be taken by Ractor#take.

Ractor.new{ 42 }.take

When the block return value is available, the Ractor is dead so that no ractors except taken Ractor can touch the return value, so any values can be sent with this communication path without any modification.

r = Ractor.new do
  a = "hello"
  binding
end

r.take.eval("p a")
Wait for multiple Ractors with Ractor.select ↑

You can wait multiple Ractor's yield with Ractor.select(*ractors). The return value of Ractor.select() is [r, msg] where r is yielding Ractor and msg is yielded message.

Wait for a single ractor (same as Ractor.take):

r1 = Ractor.new{'r1'}

r, obj = Ractor.select(r1)
r == r1 and obj == 'r1'

Wait for two ractors:

r1 = Ractor.new{'r1'}
r2 = Ractor.new{'r2'}
rs = [r1, r2]
as = []


r, obj = Ractor.select(*rs)
rs.delete(r)
as << obj


r, obj = Ractor.select(*rs)
rs.delete(r)
as << obj
as.sort == ['r1', 'r2']

Complex example:

pipe = Ractor.new do
    loop do
      Ractor.yield Ractor.receive
    end
  end

  RN = 10
  rs = RN.times.map{|i|
    Ractor.new pipe, i do |pipe, i|
      msg = pipe.take
      msg 
    end
  }
  RN.times{|i|
    pipe << i
  }
  RN.times.map{
    r, n = Ractor.select(*rs)
    rs.delete r
    n
  }.sort

Multiple Ractors can send to one Ractor.

  pipe = Ractor.new do
    loop do
      Ractor.yield Ractor.receive
    end
  end

  RN = 10
  rs = RN.times.map{|i|
    Ractor.new pipe, i do |pipe, i|
      pipe << i
    end
  }

  RN.times.map{
    pipe.take
  }.sort

TODO: Current Ractor.select() has the same issue of select(2), so this interface should be refined.

TODO: select syntax of go-language uses round-robin technique to make fair scheduling. Now Ractor.select() doesn't use it.

Closing Ractor's ports ↑

Example (try to take from closed Ractor):

r = Ractor.new do
    'finish'
  end
  r.take 
  begin
    o = r.take 
  rescue Ractor::ClosedError
    'ok'
  else
    "ng: #{o}"
  end

Example (try to send to closed (terminated) Ractor):

r = Ractor.new do
  end

  r.take 

  begin
    r.send(1)
  rescue Ractor::ClosedError
    'ok'
  else
    'ng'
  end

When multiple Ractors waiting for Ractor.yield(), Ractor#close_outgoing will cancel all blocking by raise an exception (ClosedError).

Send a message by copying ↑

Ractor#send(obj) or Ractor.yield(obj) copy obj deeply if obj is an unshareable object.

obj = 'str'.dup
r = Ractor.new obj do |msg|
  
  msg.object_id
end

obj.object_id == r.take

Some objects are not supported to copy the value, and raise an exception.

obj = Thread.new{}
begin
  Ractor.new obj do |msg|
    msg
  end
rescue TypeError => e
  e.message 
else
  'ng' 
end
Send a message by moving ↑

Ractor#send(obj, move: true) or Ractor.yield(obj, move: true) move obj to the destination Ractor. If the source Ractor touches the moved object (for example, call the method like obj.foo()), it will be an error.

r = Ractor.new do
  obj = Ractor.receive
  obj << ' world'
end

str = 'hello'
r.send str, move: true
modified = r.take 



begin
  
  str << ' exception' 
rescue Ractor::MovedError
  modified 
else
  raise 'unreachable'
end

  r = Ractor.new do
    obj = 'hello'
    Ractor.yield obj, move: true
    obj << 'world'  
  end

  str = r.take
  begin
    r.take
  rescue Ractor::RemoteError
    p str 
  end

Some objects are not supported to move, and an exception will be raise.

r = Ractor.new do
  Ractor.receive
end

r.send(Thread.new{}, move: true)

To achieve the access prohibition for moved objects, class replacement technique is used to implement it.

Shareable objects ↑

The following objects are shareable.

Implementation: Now shareable objects (RVALUE) have FL_SHAREABLE flag. This flag can be added lazily.

To make sharable objects, Ractor.make_shareable(obj) method is provided. In this case, try to make sharaeble by freezing obj and recursively travasible objects. This method accepts copy: keyword (default value is false).Ractor.make_sharable(obj, copy: true) tries to make a deep copy of obj and make the copied object sharable.

To isolate unshareable objects between Ractors, we introduced additional language semantics on multi-Ractor Ruby programs.

Note that without using Ractors, these additional semantics is not needed (100% compatible with Ruby 2).

Global variables ↑

Only the main Ractor (a Ractor created at starting of interpreter) can access global variables.

$gv = 1
  r = Ractor.new do
    $gv
  end

  begin
    r.take
  rescue Ractor::RemoteError => e
    e.cause.message 
  end

Note that some special global variables are ractor-local, like $stdin, $stdout, $stderr. See [Bug #17268] for more details.

Only the main Ractor can access instance variables of shareable objects.

class C
    @iv = 'str'
  end

  r = Ractor.new do
    class C
      p @iv
    end
  end


  begin
    r.take
  rescue => e
    e.class 
  end

shared = Ractor.new{}
  shared.instance_variable_set(:@iv, 'str')

  r = Ractor.new shared do |shared|
    p shared.instance_variable_get(:@iv)
  end

  begin
    r.take
  rescue Ractor::RemoteError => e
    e.cause.message 
  end

Note that instance variables for class/module objects are also prohibited on Ractors.

Class variables ↑

Only the main Ractor can access class variables.

class C
    @@cv = 'str'
  end

  r = Ractor.new do
    class C
      p @@cv
    end
  end


  begin
    r.take
  rescue => e
    e.class 
  end
Constants ↑

Only the main Ractor can read constants which refer to the unshareable object.

class C
    CONST = 'str'
  end
  r = Ractor.new do
    C::CONST
  end
  begin
    r.take
  rescue => e
    e.class 
  end

Only the main Ractor can define constants which refer to the unshareable object.

class C
  end
  r = Ractor.new do
    C::CONST = 'str'
  end
  begin
    r.take
  rescue => e
    e.class 
  end

To make multi-ractor supported library, the constants should only refer sharable objects.

TABLE = {a: 'ko1', b: 'ko2', c: 'ko3'}

In this case, TABLE reference an unsharable Hash object. So that other ractors can not refer TABLE constant. To make it shareable, we can use Ractor.make_sharable() like that.

TABLE = Ractor.make_sharable( {a: 'ko1', b: 'ko2', c: 'ko3'} )

To make it easy, Ruby 3.0 introduced new shareable_constant_value Directive.

shareable_constant_value: literal

TABLE = {a: 'ko1', b: 'ko2', c: 'ko3'}

shareable_constant_value directive accepts the following modes (descriptions use the example: CONST = expr):

Except the none mode (default), it is guaranteed that the assigned constants refer to only sharable objects.

See doc/syntax/comment.rdoc for more details.

Implementation note ↑ Examples ↑ Traditional Ring example in Actor-model ↑ 
RN = 1_000
CR = Ractor.current

r = Ractor.new do
  p Ractor.receive
  CR << :fin
end

RN.times{
  r = Ractor.new r do |next_r|
    next_r << Ractor.receive
  end
}

p :setup_ok
r << 1
p Ractor.receive
Fork-join ↑ 
def fib n
  if n < 2
    1
  else
    fib(n-2) + fib(n-1)
  end
end

RN = 10
rs = (1..RN).map do |i|
  Ractor.new i do |i|
    [i, fib(i)]
  end
end

until rs.empty?
  r, v = Ractor.select(*rs)
  rs.delete r
  p answer: v
end
Worker pool ↑ 
require 'prime'

pipe = Ractor.new do
  loop do
    Ractor.yield Ractor.receive
  end
end

N = 1000
RN = 10
workers = (1..RN).map do
  Ractor.new pipe do |pipe|
    while n = pipe.take
      Ractor.yield [n, n.prime?]
    end
  end
end

(1..N).each{|i|
  pipe << i
}

pp (1..N).map{
  _r, (n, b) = Ractor.select(*workers)
  [n, b]
}.sort_by{|(n, b)| n}
Pipeline ↑ 
r1 = Ractor.new do
  'r1'
end

r2 = Ractor.new r1 do |r1|
  r1.take + 'r2'
end

r3 = Ractor.new r2 do |r2|
  r2.take + 'r3'
end

p r3.take 

r3 = Ractor.new Ractor.current do |cr|
  cr.send Ractor.receive + 'r3'
end

r2 = Ractor.new r3 do |r3|
  r3.send Ractor.receive + 'r2'
end

r1 = Ractor.new r2 do |r2|
  r2.send Ractor.receive + 'r1'
end

r1 << 'r0'
p Ractor.receive
Supervise ↑ 
r = Ractor.current
(1..10).map{|i|
  r = Ractor.new r, i do |r, i|
    r.send Ractor.receive + "r#{i}"
  end
}

r.send "r0"
p Ractor.receive 

r = Ractor.current
rs = (1..10).map{|i|
  r = Ractor.new r, i do |r, i|
    loop do
      msg = Ractor.receive
      raise if /e/ =~ msg
      r.send msg + "r#{i}"
    end
  end
}

r.send "r0"
p Ractor.receive 
r.send "r0"
p Ractor.select(*rs, Ractor.current) 
r.send "e0"
p Ractor.select(*rs, Ractor.current)


Traceback (most recent call last):
        2: from /home/ko1/src/ruby/trunk/test.rb7:in `block (2 levels) in <main>'
        1: from /home/ko1/src/ruby/trunk/test.rb:7:in `loop'
/home/ko1/src/ruby/trunk/test.rb:9:in `block (3 levels) in <main>': unhandled exception
Traceback (most recent call last):
        2: from /home/ko1/src/ruby/trunk/test.rb7:in `block (2 levels) in <main>'
        1: from /home/ko1/src/ruby/trunk/test.rb:7:in `loop'
/home/ko1/src/ruby/trunk/test.rb:9:in `block (3 levels) in <main>': unhandled exception
        1: from /home/ko1/src/ruby/trunk/test.rb21:in `<main>'
<internal:ractor>:69:in `select': thrown by remote Ractor. (Ractor::RemoteError)

r = Ractor.current
rs = (1..10).map{|i|
  r = Ractor.new r, i do |r, i|
    loop do
      msg = Ractor.receive
      raise if /e/ =~ msg
      r.send msg + "r#{i}"
    end
  end
}

r.send "r0"
p Ractor.receive 
r.send "r0"
p Ractor.select(*rs, Ractor.current)
[:receive, "r0r10r9r8r7r6r5r4r3r2r1"]
msg = 'e0'
begin
  r.send msg
  p Ractor.select(*rs, Ractor.current)
rescue Ractor::RemoteError
  msg = 'r0'
  retry
end




def make_ractor r, i
  Ractor.new r, i do |r, i|
    loop do
      msg = Ractor.receive
      raise if /e/ =~ msg
      r.send msg + "r#{i}"
    end
  end
end

r = Ractor.current
rs = (1..10).map{|i|
  r = make_ractor(r, i)
}

msg = 'e0' 
begin
  r.send msg
  p Ractor.select(*rs, Ractor.current)
rescue Ractor::RemoteError
  r = rs[-1] = make_ractor(rs[-2], rs.size-1)
  msg = 'x0'
  retry
end

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.3