concurrent-ruby 0.7.0.rc0-x86-solaris-2.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f111f23c370d20a790c02e2830ad9e8ef3a071bc
+  data.tar.gz: 8ca092d2e3535ca851c062bebeba3af3f63f9077
+SHA512:
+  metadata.gz: aabbbb7ff2d6c9679fc4d5f9c7cd13abb7094ea12ec043aba17cd063434ee02d97867bf6bb071434c2959a93a26353310cb8aa45f026e6c59642ef4b31a67e97
+  data.tar.gz: 9b3e81bf55b5d45123c8b5628b31c165a53bb02d5c33c944f688f07835143b4fab83fb566e46b3243e1f6d57c08209b53cc96b88d012654217e4759acc2528ae

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) Jerry D'Antonio -- released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy  
+of this software and associated documentation files (the "Software"), to deal  
+in the Software without restriction, including without limitation the rights  
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+copies of the Software, and to permit persons to whom the Software is  
+furnished to do so, subject to the following conditions:  
+ 
+The above copyright notice and this permission notice shall be included in  
+all copies or substantial portions of the Software.  
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
+THE SOFTWARE. 

data/README.md

@@ -0,0 +1,166 @@
+# Concurrent Ruby
+[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.png)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Coverage Status](https://coveralls.io/repos/ruby-concurrency/concurrent-ruby/badge.png)](https://coveralls.io/r/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.png)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.png)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.png)](https://gemnasium.com/ruby-concurrency/concurrent-ruby)
+
+<table>
+  <tr>
+    <td align="left" valign="top">
+      <p>
+        Modern concurrency tools for Ruby. Inspired by
+        <a href="http://www.erlang.org/doc/reference_manual/processes.html">Erlang</a>,
+        <a href="http://clojure.org/concurrent_programming">Clojure</a>,
+        <a href="http://akka.io/">Scala</a>,
+        <a href="http://www.haskell.org/haskellwiki/Applications_and_libraries/Concurrency_and_parallelism#Concurrent_Haskell">Haskell</a>,
+        <a href="http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx">F#</a>,
+        <a href="http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx">C#</a>,
+        <a href="http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html">Java</a>,
+        and classic concurrency patterns.
+      </p>
+      <p>
+        The design goals of this gem are:
+        <ul>
+          <li>Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why</li>
+          <li>Remain free of external gem dependencies</li>
+          <li>Stay true to the spirit of the languages providing inspiration</li>
+          <li>But implement in a way that makes sense for Ruby</li>
+          <li>Keep the semantics as idiomatic Ruby as possible</li>
+          <li>Support features that make sense in Ruby</li>
+          <li>Exclude features that don't make sense in Ruby</li>
+          <li>Be small, lean, and loosely coupled</li>
+        </ul>
+      </p>
+    </td>
+    <td align="right" valign="top">
+      <img src="https://raw.githubusercontent.com/wiki/ruby-concurrency/concurrent-ruby/logo/concurrent-ruby-logo-300x300.png"/>
+    </td>
+  </tr>
+</table>
+
+## Install
+
+```shell
+gem install concurrent-ruby
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'concurrent-ruby'
+```
+
+and run `bundle install` from your shell.
+
+_NOTE: There is an old gem from 2007 called "concurrent" that does not appear to be under active development. That isn't us. Please do not run* `gem install concurrent`*. It is not the droid you are looking for._
+
+## Features & Documentation
+
+Please see the [Concurrent Ruby Wiki](https://github.com/ruby-concurrency/concurrent-ruby/wiki)
+or the [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html))
+for more information or join our [mailing list](http://groups.google.com/group/concurrent-ruby).
+
+There are many concurrency abstractions in this library. These abstractions can be broadly categorized
+into several general groups:
+
+* Asynchronous concurrency abstractions including
+  [Async](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Async),
+  [Agent](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Agent),
+  [Future](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Future),
+  [Promise](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Promise),
+  [ScheduledTask](https://github.com/ruby-concurrency/concurrent-ruby/wiki/ScheduledTask),
+  and [TimerTask](https://github.com/ruby-concurrency/concurrent-ruby/wiki/TimerTask) 
+* Erlang-inspired [Supervisor](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Supervisor) and other lifecycle classes/mixins
+  for managing long-running threads
+* Thread-safe variables including [M-Structures](https://github.com/ruby-concurrency/concurrent-ruby/wiki/MVar-(M-Structure)),
+  [I-Structures](https://github.com/ruby-concurrency/concurrent-ruby/wiki/IVar-(I-Structure)),
+  [thread-local variables](https://github.com/ruby-concurrency/concurrent-ruby/wiki/ThreadLocalVar),
+  atomic counters, and [software transactional memory](https://github.com/ruby-concurrency/concurrent-ruby/wiki/TVar-(STM))
+* Thread synchronization classes and algorithms including [dataflow](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Dataflow), 
+  timeout, condition, countdown latch, dependency counter, and event
+* Java-inspired [thread pools](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Thread%20Pools)
+* New fast light-weighted [Actor model](http://ruby-concurrency.github.io/concurrent-ruby/frames.html#!Concurrent/Actress.html) implementation. 
+* And many more...
+
+### Semantic Versioning
+
+This gem adheres to the rules of [semantic versioning](http://semver.org/).
+
+### Supported Ruby versions
+
+MRI 1.9.3, 2.0, 2.1, JRuby (1.9 mode), and Rubinius 2.x.
+This library is pure Ruby and has no gem dependencies.
+It should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
+
+### Examples
+
+Many more code examples can be found in the documentation for each class (linked above).
+This one simple example shows some of the power of this gem.
+
+```ruby    
+require 'concurrent'
+require 'thread'   # for Queue
+require 'open-uri' # for open(uri)
+
+class Ticker
+  def get_year_end_closing(symbol, year)
+    uri = "http://ichart.finance.yahoo.com/table.csv?s=#{symbol}&a=11&b=01&c=#{year}&d=11&e=31&f=#{year}&g=m"
+    data = open(uri) {|f| f.collect{|line| line.strip } }
+    data[1].split(',')[4].to_f
+  end
+end
+
+# Future
+price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013) }
+price.state #=> :pending
+sleep(1)    # do other stuff
+price.value #=> 63.65
+price.state #=> :fulfilled
+
+# Promise
+prices = Concurrent::Promise.new{ puts Ticker.new.get_year_end_closing('AAPL', 2013) }.
+           then{ puts Ticker.new.get_year_end_closing('MSFT', 2013) }.
+           then{ puts Ticker.new.get_year_end_closing('GOOG', 2013) }.
+           then{ puts Ticker.new.get_year_end_closing('AMZN', 2013) }.execute
+prices.state #=> :pending
+sleep(1)     # do other stuff
+#=> 561.02
+#=> 37.41
+#=> 1120.71
+#=> 398.79
+
+# ScheduledTask
+task = Concurrent::ScheduledTask.execute(2){ Ticker.new.get_year_end_closing('INTC', 2013) }
+task.state #=> :pending
+sleep(3)   # do other stuff
+task.value #=> 25.96
+```
+
+## Contributors
+
+* [Jerry D'Antonio](https://github.com/jdantonio)
+* [Michele Della Torre](https://github.com/mighe)
+* [Chris Seaton](https://github.com/chrisseaton)
+* [Lucas Allan](https://github.com/lucasallan)
+* [Petr Chalupa](https://github.com/pitr-ch)
+* [Ravil Bayramgalin](https://github.com/brainopia)
+* [Larry Lv](https://github.com/larrylv)
+* [Giuseppe Capizzi](https://github.com/gcapizzi)
+* [Bill Dueber](https://github.com/billdueber)
+* [Brian Shirai](https://github.com/brixen)
+* [Chip Miller](https://github.com/chip-miller)
+* [Jamie Hodge](https://github.com/jamiehodge)
+* [Zander Hill](https://github.com/zph)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License and Copyright
+
+*Concurrent Ruby* is free software released under the [MIT License](http://www.opensource.org/licenses/MIT).
+
+The *Concurrent Ruby* [logo](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Logo)
+was designed by [David Jones](https://twitter.com/zombyboy).
+It is Copyright &copy; 2014 [Jerry D'Antonio](https://twitter.com/jerrydantonio). All Rights Reserved.

data/ext/concurrent_ruby_ext/atomic_reference.c

@@ -0,0 +1,78 @@
+#include <ruby.h>
+#if defined(__sun)
+#include <atomic.h>
+#endif
+
+#ifdef HAVE_LIBKERN_OSATOMIC_H
+#include <libkern/OSAtomic.h>
+#endif
+
+#include "atomic_reference.h"
+
+void ir_mark(void *value) {
+    rb_gc_mark_maybe((VALUE) value);
+}
+
+VALUE ir_alloc(VALUE klass) {
+    return rb_data_object_alloc(klass, (void *) Qnil, ir_mark, NULL);
+}
+
+VALUE ir_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE value = Qnil;
+    if (rb_scan_args(argc, argv, "01", &value) == 1) {
+	value = argv[0];
+    }
+    DATA_PTR(self) = (void *) value;
+    return Qnil;
+}
+
+VALUE ir_get(VALUE self) {
+    return (VALUE) DATA_PTR(self);
+}
+
+VALUE ir_set(VALUE self, VALUE new_value) {
+    DATA_PTR(self) = (void *) new_value;
+    return new_value;
+}
+
+VALUE ir_get_and_set(VALUE self, VALUE new_value) {
+    VALUE old_value;
+    old_value = (VALUE) DATA_PTR(self);
+    DATA_PTR(self) = (void *) new_value;
+    return old_value;
+}
+
+VALUE ir_compare_and_set(volatile VALUE self, VALUE expect_value, VALUE new_value) {
+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
+    if (OSAtomicCompareAndSwap64(expect_value, new_value, &DATA_PTR(self))) {
+	return Qtrue;
+    }
+#elif defined(__sun)
+/*  Assuming VALUE is uintptr_t */
+/*  Based on the definition of uintptr_t from /usr/include/sys/int_types.h */
+#if defined(_LP64) || defined(_I32LPx)
+    /*  64-bit: uintptr_t === unsigned long */
+    if (atomic_cas_ulong((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
+        return Qtrue;
+    }
+#else
+    /*  32-bit: uintptr_t === unsigned int */
+    if (atomic_cas_uint((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
+        return Qtrue;
+    }
+#endif
+#elif defined _MSC_VER && defined _M_AMD64
+    if (InterlockedCompareExchange64((LONGLONG*)&DATA_PTR(self), new_value, expect_value)) {
+	return Qtrue;
+    }
+#elif defined _MSC_VER && defined _M_IX86
+    if (InterlockedCompareExchange((LONG*)&DATA_PTR(self), new_value, expect_value)) {
+	return Qtrue;
+    }
+#else
+    if (__sync_bool_compare_and_swap(&DATA_PTR(self), expect_value, new_value)) {
+	return Qtrue;
+    }
+#endif
+    return Qfalse;
+}

data/ext/concurrent_ruby_ext/atomic_reference.h

@@ -0,0 +1,12 @@
+#ifndef __ATOMIC_REFERENCE_H__
+#define __ATOMIC_REFERENCE_H__
+
+void ir_mark(void*);
+VALUE ir_alloc(VALUE);
+VALUE ir_initialize(int, VALUE*, VALUE);
+VALUE ir_get(VALUE);
+VALUE ir_set(VALUE, VALUE);
+VALUE ir_get_and_set(VALUE, VALUE);
+VALUE ir_compare_and_set(volatile VALUE, VALUE, VALUE);
+
+#endif

data/ext/concurrent_ruby_ext/extconf.rb

@@ -0,0 +1,59 @@
+require 'fileutils'
+
+$:.push File.join(File.dirname(__FILE__), '../../lib')
+require 'extension_helper'
+
+EXTENSION_NAME = 'concurrent_ruby_ext'
+
+def create_dummy_makefile
+  File.open('Makefile', 'w') do |f|
+    f.puts 'all:'
+    f.puts 'install:'
+  end
+end
+
+if defined?(JRUBY_VERSION) || ! Concurrent.use_c_extensions? 
+  create_dummy_makefile
+  warn 'C optimizations are not supported on this version of Ruby.'
+else
+  begin
+
+    require 'mkmf'
+    dir_config(EXTENSION_NAME)
+
+    have_header "libkern/OSAtomic.h"
+
+    def compiler_is_gcc
+      if CONFIG["GCC"] && CONFIG["GCC"] != ""
+        return true
+      elsif ( # This could stand to be more generic...  but I am afraid.
+             CONFIG["CC"] =~ /\bgcc\b/
+            )
+        return true
+      end
+      return false
+    end
+
+    if compiler_is_gcc
+      case CONFIG["arch"]
+      when /mswin32|mingw|solaris/
+        $CFLAGS += " -march=native"
+      when 'i686-linux'
+        $CFLAGS += " -march=i686"
+      end
+    end
+
+    try_run(<<CODE,$CFLAGS) && ($defs << '-DHAVE_GCC_CAS')
+int main() {
+  int i = 1;
+  __sync_bool_compare_and_swap(&i, 1, 4);
+  return (i != 4);
+}
+CODE
+
+    create_makefile(EXTENSION_NAME)
+  rescue
+    create_dummy_makefile
+    warn 'C optimizations cannot be compiled on this version of Ruby.'
+  end
+end

data/ext/concurrent_ruby_ext/rb_concurrent.c

@@ -0,0 +1,28 @@
+#include <ruby.h>
+
+#include "atomic_reference.h"
+
+// module and class definitions
+
+static VALUE rb_mConcurrent;
+static VALUE rb_cAtomic;
+
+// Init_concurrent_ruby_ext
+
+void Init_concurrent_ruby_ext() {
+
+  // define modules and classes
+  rb_mConcurrent = rb_define_module("Concurrent");
+  rb_cAtomic = rb_define_class_under(rb_mConcurrent, "CAtomic", rb_cObject);
+
+  // CAtomic
+  rb_define_alloc_func(rb_cAtomic, ir_alloc);
+  rb_define_method(rb_cAtomic, "initialize", ir_initialize, -1);
+  rb_define_method(rb_cAtomic, "get", ir_get, 0);
+  rb_define_method(rb_cAtomic, "value", ir_get, 0);
+  rb_define_method(rb_cAtomic, "set", ir_set, 1);
+  rb_define_method(rb_cAtomic, "value=", ir_set, 1);
+  rb_define_method(rb_cAtomic, "get_and_set", ir_get_and_set, 1);
+  rb_define_method(rb_cAtomic, "swap", ir_get_and_set, 1);
+  rb_define_method(rb_cAtomic, "_compare_and_set", ir_compare_and_set, 2);
+}

data/lib/concurrent.rb

@@ -0,0 +1,45 @@
+require 'concurrent/version'
+
+require 'concurrent/configuration'
+
+require 'concurrent/atomics'
+require 'concurrent/channels'
+require 'concurrent/collections'
+require 'concurrent/executors'
+require 'concurrent/utilities'
+
+require 'concurrent/actress'
+require 'concurrent/atomic'
+require 'concurrent/agent'
+require 'concurrent/async'
+require 'concurrent/dataflow'
+require 'concurrent/delay'
+require 'concurrent/dereferenceable'
+require 'concurrent/errors'
+require 'concurrent/exchanger'
+require 'concurrent/future'
+require 'concurrent/ivar'
+require 'concurrent/mvar'
+require 'concurrent/obligation'
+require 'concurrent/observable'
+require 'concurrent/options_parser'
+require 'concurrent/promise'
+require 'concurrent/scheduled_task'
+require 'concurrent/supervisor'
+require 'concurrent/timer_task'
+require 'concurrent/tvar'
+
+# Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
+# F#, C#, Java, and classic concurrency patterns.
+# 
+# The design goals of this gem are:
+# 
+# * Stay true to the spirit of the languages providing inspiration
+# * But implement in a way that makes sense for Ruby
+# * Keep the semantics as idiomatic Ruby as possible
+# * Support features that make sense in Ruby
+# * Exclude features that don't make sense in Ruby
+# * Be small, lean, and loosely coupled
+module Concurrent
+
+end

data/lib/concurrent/actress.rb

@@ -0,0 +1,221 @@
+require 'concurrent/configuration'
+require 'concurrent/executor/serialized_execution'
+require 'concurrent/ivar'
+require 'concurrent/logging'
+
+module Concurrent
+
+  # # Actor model
+  #
+  # -  Light-weighted.
+  # -  Inspired by Akka and Erlang.
+  #
+  # Actors are sharing a thread-pool by default which makes them very cheap to create and discard.
+  # Thousands of actors can be created allowing to brake the program to small maintainable pieces
+  # without breaking single responsibility principles.
+  #
+  # ## What is an actor model?
+  #
+  # [Wiki](http://en.wikipedia.org/wiki/Actor_model) says:
+  # The actor model in computer science is a mathematical model of concurrent computation
+  # that treats _actors_ as the universal primitives of concurrent digital computation:
+  # in response to a message that it receives, an actor can make local decisions,
+  # create more actors, send more messages, and determine how to respond to the next
+  # message received.
+  #
+  # ## Why?
+  #
+  # Concurrency is hard this is one of many ways how to simplify the problem.
+  # It is simpler to reason about actors then about locks (and all their possible states).
+  #
+  # ## How to use it
+  #
+  # {include:file:doc/actress/quick.out.rb}
+  #
+  # ## Messaging
+  #
+  # Messages are processed in same order as they are sent by a sender. It may interleaved with
+  # messages form other senders though. There is also a contract in actor model that
+  # messages sent between actors should be immutable. Gems like
+  #
+  # - [Algebrick](https://github.com/pitr-ch/algebrick) - Typed struct on steroids based on
+  #   algebraic types and pattern matching
+  # - [Hamster](https://github.com/hamstergem/hamster) - Efficient, Immutable, Thread-Safe
+  #   Collection classes for Ruby
+  #
+  # are very useful.
+  #
+  # ## Architecture
+  #
+  # Actors are running on shared thread poll which allows user to create many actors cheaply.
+  # Downside is that these actors cannot be directly used to do IO or other blocking operations.
+  # Blocking operations could starve the `default_task_pool`. However there are two options:
+  #
+  # - Create an regular actor which will schedule blocking operations in `global_operation_pool`
+  #   (which is intended for blocking operations) sending results back to self in messages.
+  # - Create an actor using `global_operation_pool` instead of `global_task_pool`, e.g.
+  #   `AnIOActor.spawn name: :blocking, executor: Concurrent.configuration.global_operation_pool`.
+  #
+  # Each actor is composed from 3 objects:
+  #
+  # ### {Reference}
+  # {include:Actress::Reference}
+  #
+  # ### {Core}
+  # {include:Actress::Core}
+  #
+  # ### {Context}
+  # {include:Actress::Context}
+  #
+  # ## Speed
+  #
+  # Simple benchmark Actress vs Celluloid, the numbers are looking good
+  # but you know how it is with benchmarks. Source code is in
+  # `examples/actress/celluloid_benchmark.rb`. It sends numbers between x actors
+  # and adding 1 until certain limit is reached.
+  #
+  # Benchmark legend:
+  #
+  # - mes.  - number of messages send between the actors
+  # - act.  - number of actors exchanging the messages
+  # - impl. - which gem is used
+  #
+  # ### JRUBY
+  #
+  #     Rehearsal --------------------------------------------------------
+  #     50000    2 actress    24.110000   0.800000  24.910000 (  7.728000)
+  #     50000    2 celluloid  28.510000   4.780000  33.290000 ( 14.782000)
+  #     50000  500 actress    13.700000   0.280000  13.980000 (  4.307000)
+  #     50000  500 celluloid  14.520000  11.740000  26.260000 ( 12.258000)
+  #     50000 1000 actress    10.890000   0.220000  11.110000 (  3.760000)
+  #     50000 1000 celluloid  15.600000  21.690000  37.290000 ( 18.512000)
+  #     50000 1500 actress    10.580000   0.270000  10.850000 (  3.646000)
+  #     50000 1500 celluloid  14.490000  29.790000  44.280000 ( 26.043000)
+  #     --------------------------------------------- total: 201.970000sec
+  #     
+  #      mes. act.      impl.      user     system      total        real
+  #     50000    2 actress     9.820000   0.510000  10.330000 (  5.735000)
+  #     50000    2 celluloid  10.390000   4.030000  14.420000 (  7.494000)
+  #     50000  500 actress     9.880000   0.200000  10.080000 (  3.310000)
+  #     50000  500 celluloid  12.430000  11.310000  23.740000 ( 11.727000)
+  #     50000 1000 actress    10.590000   0.190000  10.780000 (  4.029000)
+  #     50000 1000 celluloid  14.950000  23.260000  38.210000 ( 20.841000)
+  #     50000 1500 actress    10.710000   0.250000  10.960000 (  3.892000)
+  #     50000 1500 celluloid  13.280000  30.030000  43.310000 ( 24.620000) (1)
+  #
+  # ### MRI 2.1.0
+  #
+  #     Rehearsal --------------------------------------------------------
+  #     50000    2 actress     4.640000   0.080000   4.720000 (  4.852390)
+  #     50000    2 celluloid   6.110000   2.300000   8.410000 (  7.898069)
+  #     50000  500 actress     6.260000   2.210000   8.470000 (  7.400573)
+  #     50000  500 celluloid  10.250000   4.930000  15.180000 ( 14.174329)
+  #     50000 1000 actress     6.300000   1.860000   8.160000 (  7.303162)
+  #     50000 1000 celluloid  12.300000   7.090000  19.390000 ( 17.962621)
+  #     50000 1500 actress     7.410000   2.610000  10.020000 (  8.887396)
+  #     50000 1500 celluloid  14.850000  10.690000  25.540000 ( 24.489796)
+  #     ---------------------------------------------- total: 99.890000sec
+  #     
+  #      mes. act.      impl.      user     system      total        real
+  #     50000    2 actress     4.190000   0.070000   4.260000 (  4.306386)
+  #     50000    2 celluloid   6.490000   2.210000   8.700000 (  8.280051)
+  #     50000  500 actress     7.060000   2.520000   9.580000 (  8.518707)
+  #     50000  500 celluloid  10.550000   4.980000  15.530000 ( 14.699962)
+  #     50000 1000 actress     6.440000   1.870000   8.310000 (  7.571059)
+  #     50000 1000 celluloid  12.340000   7.510000  19.850000 ( 18.793591)
+  #     50000 1500 actress     6.720000   2.160000   8.880000 (  7.929630)
+  #     50000 1500 celluloid  14.140000  10.130000  24.270000 ( 22.775288) (1)
+  #
+  # *Note (1):* Celluloid is using thread per actor so this bench is creating about 1500
+  # native threads. Actress is using constant number of threads.
+  module Actress
+
+    require 'concurrent/actress/type_check'
+    require 'concurrent/actress/errors'
+    require 'concurrent/actress/core_delegations'
+    require 'concurrent/actress/envelope'
+    require 'concurrent/actress/reference'
+    require 'concurrent/actress/core'
+    require 'concurrent/actress/context'
+
+    require 'concurrent/actress/ad_hoc'
+
+    # @return [Reference, nil] current executing actor if any
+    def self.current
+      Thread.current[:__current_actor__]
+    end
+
+    # implements ROOT
+    class Root
+      include Context
+      # to allow spawning of new actors, spawn needs to be called inside the parent Actor
+      def on_message(message)
+        if message.is_a?(Array) && message.first == :spawn
+          spawn message[1], &message[2]
+        else
+          # ignore
+        end
+      end
+    end
+
+    # A root actor, a default parent of all actors spawned outside an actor
+    ROOT = Core.new(parent: nil, name: '/', class: Root).reference
+
+    # Spawns a new actor.
+    #
+    # @example simple
+    #   Actress.spawn(AdHoc, :ping1) { -> message { message } }
+    #
+    # @example complex
+    #   Actress.spawn name:     :ping3,
+    #                 class:    AdHoc,
+    #                 args:     [1]
+    #                 executor: Concurrent.configuration.global_task_pool do |add|
+    #     lambda { |number| number + add }
+    #   end
+    #
+    # @param block for actress_class instantiation
+    # @param args see {.spawn_optionify}
+    # @return [Reference] never the actual actor
+    def self.spawn(*args, &block)
+      experimental_acknowledged? or
+          warn '[EXPERIMENTAL] A full release of `Actress`, renamed `Actor`, is expected in the 0.7.0 release.'
+
+      if Actress.current
+        Core.new(spawn_optionify(*args).merge(parent: Actress.current), &block).reference
+      else
+        ROOT.ask([:spawn, spawn_optionify(*args), block]).value
+      end
+    end
+
+    # as {.spawn} but it'll raise when Actor not initialized properly
+    def self.spawn!(*args, &block)
+      spawn(spawn_optionify(*args).merge(initialized: ivar = IVar.new), &block).tap { ivar.no_error! }
+    end
+
+    # @overload spawn_optionify(actress_class, name, *args)
+    #   @param [Context] actress_class to be spawned
+    #   @param [String, Symbol] name of the instance, it's used to generate the {Core#path} of the actor
+    #   @param args for actress_class instantiation
+    # @overload spawn_optionify(opts)
+    #   see {Core#initialize} opts
+    def self.spawn_optionify(*args)
+      if args.size == 1 && args.first.is_a?(Hash)
+        args.first
+      else
+        { class: args[0],
+          name:  args[1],
+          args:  args[2..-1] }
+      end
+    end
+
+    # call this to disable experimental warning
+    def self.i_know_it_is_experimental!
+      @experimental_acknowledged = true
+    end
+
+    def self.experimental_acknowledged?
+      !!@experimental_acknowledged
+    end
+  end
+end