class
   Fiber::ExecutionContext::Parallel
  
  
  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 being able to start running on a system thread, so multiple schedulers can run in parallel. The fibers are resumable by any scheduler in the context, they can thus move from one system thread to another at any time.
The actual parallelism is controlled by the execution context. As the need for parallelism increases, for example more fibers running longer, the more schedulers will start (and thus system threads), as the need decreases, for example not enough fibers, the schedulers will pause themselves and parallelism will decrease.
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 shared value variable. Running
the example without Atomic#add would 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 # => 523776Included Modules
Defined in:
fiber/execution_context/parallel.crfiber/execution_context/parallel/scheduler.cr
Constructors
- 
        .new(name : String, maximum : Int32) : self
        
          Starts a context with a maximum number of threads. 
- 
        .new(name : String, size : Range(Nil, Int32)) : self
        
          Starts a context with a maximum number of threads. 
- 
        .new(name : String, size : Range(Int32, Int32)) : self
        
          Starts a context with a minimum and maximum number of threads. 
Instance Method Summary
- 
        #capacity : Int32
        
          The maximum number of threads that can be started. 
- 
        #inspect(io : IO) : Nil
        
          Appends a String representation of this object which includes its class name, its object address and the values of all instance variables. 
- #name : String
- 
        #size : Int32
        
          The number of threads that have been started. 
- 
        #to_s(io : IO) : Nil
        
          Appends a short String representation of this object which includes its class name and its object address. 
Instance methods inherited from module Fiber::ExecutionContext
  
  
    
      spawn(*, name : String | Nil = nil, &block :  -> ) : Fiber
    spawn
    
  
      
  Constructor methods inherited from module Fiber::ExecutionContext
  
  
    
      current : ExecutionContext
    current, 
    
  
    
      default : ExecutionContext
    default
    
  
      
  Class methods inherited from module Fiber::ExecutionContext
  
  
    
      current? : ExecutionContext | Nil
    current?, 
    
  
    
      default_workers_count : Int32
    default_workers_count, 
    
  
    
      each(&) : Nil
    each
    
  
      
    
      
  Instance methods inherited from class Reference
  
  
    
      ==(other : self)==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup, hash(hasher) hash, initialize initialize, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference) : Bool
same?(other : Nil) same?, to_s(io : IO) : Nil to_s
Constructor methods inherited from class Reference
  
  
    
      new
    new, 
    
  
    
      unsafe_construct(address : Pointer, *args, **opts) : self
    unsafe_construct
    
  
      
  Class methods inherited from class Reference
  
  
    
      pre_initialize(address : Pointer)
    pre_initialize
    
  
      
    
      
  Instance methods inherited from class Object
  
  
    
      ! : Bool
    !, 
    
  
    
      !=(other)
    !=, 
    
  
    
      !~(other)
    !~, 
    
  
    
      ==(other)
    ==, 
    
  
    
      ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
  
  
    
      from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  Constructor Detail
Starts a context with a maximum number of threads. Threads aren't started right away but will be started as needed to increase parallelism up to the configured maximum.
Starts a context with a maximum number of threads. Threads aren't started right away but will be started as needed to increase parallelism up to the configured maximum.
Starts a context with a minimum and maximum number of threads. Only the minimum number of threads will be started right away. The minimum can be 0 (or nil) in which case no threads will be started. More threads will be started as needed to increase parallelism up to the configured maximum.
Instance Method Detail
Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.
class Person
  def initialize(@name : String, @age : Int32)
  end
end
Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>