class Fiber::ExecutionContext::Parallel

• Fiber::ExecutionContext::Parallel
• Reference
• Object

Overview

Parallel execution context.

Fibers running in the same context run both concurrently and in parallel to each others, in addition to the other fibers running in other execution contexts.

The context internally keeps a number of fiber schedulers, each scheduler runs on a system thread, so multiple schedulers can run in parallel. The fibers are resumable by any scheduler in the context, and can thus move from one system thread to another at any time.

The actual parallelism is dynamic. As the need for parallelism increases, for example more fibers running longer, the more schedulerswill start (and thus system threads), as the need decreases, for example not enough fibers, the schedulerswill pause themselves and parallelismwill decrease.

The parallelism can be as low as 1, inwhich case the context becomes a concurrent context (no parallelism) until resized.

For example:we can start a parallel context to run consumer fibers,while the default context produces values. Because the consumer fibers can run in parallel,we must protect accesses to the sharedvalue variable. Running the examplewithoutAtomic#addwould produce a different result every time!

require "wait_group"

consumers = Fiber::ExecutionContext::Parallel.new("consumers", 8)
channel = Channel(Int32).new(64)
wg = WaitGroup.new(32)

result = Atomic.new(0)

32.times do
  consumers.spawn do
    while value = channel.receive?
      result.add(value)
    end
  ensure
    wg.done
  end
end

1024.times { |i| channel.send(i) }
channel.close

# wait for all workers to be done
wg.wait

p result.get # => 523776

NOTE TheParallel execution context isn't tied to a fixed set of system threads, and execution can switch to other system threads, for examplewhen a fiber is blocked on a syscall.

Included Modules

• Fiber::ExecutionContext

Direct Known Subclasses

• Fiber::ExecutionContext::Concurrent

Defined in:

Constructors

• .new(name : String, maximum : Int32) : self

  Starts aParallel contextwith amaximum parallelism.

• .new(name : String, size : Range(Nil, Int32)) : self

  DEPRECATED Use Fiber::ExecutionContext::Parallel.new(String, Int32) instead.

• .new(name : String, size : Range(Int32, Int32)) : self

  DEPRECATED Use Fiber::ExecutionContext::Parallel.new(String, Int32) instead.

Instance Method Summary

• #capacity : Int32

  The maximum number of schedulers that can be started, aka how many fibers can run in parallel or maximum parallelism of the context.

• #inspect(io : IO) : Nil

  Appends a String representation of this objectwhich includes its class name, its object address and the values of all instance variables.

• #name : String
• #resize(maximum : Int32) : Nil

  Resizes the context to the newmaximum parallelism.

• #scale_up(to size : Int32 = capacity) : Nil

  Manually scales the context up tosize running schedulers now,withoutwaiting for auto-scaling.

• #to_s(io : IO) : Nil

  Appends a short String representation of this objectwhich includes its class name and its object address.

Constructor Detail

Instance Method Detail

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>