rubinius

Version 3.28 (2016-04-24)

• Improved cache metrics. (Brian Shirai)
• Reworked call site, inline cache mechanism. (Brian Shirai)
  A CallSite is an abstraction of the point of call & return for another
  procedure. An InlineCache is an abstraction of a particular instance of an
  executable at a CallSite.

In a 'statically typed' (or early bound) language, the executable at the call
site is known 'statically', via textual analysis of the program text. In a
'dynamically-typed' (or late bound) language, the particular executable is not
known until the program is executed. Consequently, in a late-bound language, a
call site must permit dynamic reconfiguration based on the program's
execution.

This dynamic reconfiguration requires prediction: when this kind of object is
seen, we predict we will see it again. The cost of finding the executable in
the first place can then be reduced by caching the previous result of looking
up the executable. When we see this kind of object, we can retrieve the
executable from the cache at less cost than looking it up.

If our predictions are correct, and the mechanism of creating and retrieving
items from the cache is actually less than searching for the item, we can
execute the program more efficiently. However, predictions can be wrong. If
they are wrong, the cache mechanism can become pure overhead, work done that
produces no value. In this case, the caching mechanism will make the program
less efficient rather than more efficient.

The number of cached items is typically limited because as the number grows,
the cost of retrieving items typically grows. Ideally, the first cached item
would always be the desired one. When that is not true, some (hopefully less
costly than lookup) search mechanism is required. Contiguous structures that
permit linear probing and are CPU cache-efficient usually perform very well.
If the number of entries grows, the algorithm needs to change from on O(n)
complexity to something closer to O(1), or the extra work of the caching
mechanism will be a cost increase instead of a cost reduction.

To account for our predictions being wrong, we need to be able to update,
replace, or even discard previous predictions. In same cases, we may need to
disable the caching mechanism completely. This latter case is true when the
types of objects seen at a call site vary widely.

This change also adds some new metrics for understanding how a program is
performing from the perspective of the call sites and inline caches. The next
mechanism to add is diagnostics to see the operation of individual caches
instead of the aggregate values that the metrics provide.

Another improvement that is needed is to cache #method_missing,
#respond_to? and #send call sites.

• Added C-API define for rb_big_pack. Closes #3637. (Brian Shirai)
• Always report build status in Gitter. (Brian Shirai)
• Compile in debug mode when in git submodule (Dylan McKay)
  We currently compile in debug mode if there is a .git directory in the project
  root.

This compiles Rubinius in debug mode even if .git is a file, so that
we compile in debug mode when rubinius is in a git submodule.

• Attempt to use secure env var for Gitter URL. (Brian Shirai)
• Revert "Attempt to use secure env var for Gitter URL." (Brian Shirai)
  This reverts commit a141ba02eaeefe60bfab62c7b6e3cb4f66dd6148.

This can be set directly through the Travis interface.

• Attempt to use Travis UI-set env var for Gitter. (Brian Shirai)
• Revert "Attempt to use Travis UI-set env var for Gitter." (Brian Shirai)
  This reverts commit dba105de28d7a5cd5344b11a29ffe330f6b79b2a.

Apparently, nope.

• Re-added caching at check_serial instruction. (Brian Shirai)
• Singleton classes can't have subclasses. (Brian Shirai)

Version 3.27 (2016-04-15)

• Remove tracing Symbols in MachineCode objects. (Brian Shirai)
  We need to trace Symbols for collecting unused ones, but we don't do that now
  and we can do it with the upcoming reference counting mechanism.
• Updated gems_list.txt. (Brian Shirai)
• Coalesce condition blocks so GCC 5 can understand. (Brian Shirai)

Version 3.26 (2016-04-11)

• Fixed rand() for degenerative empty range (fengb)
• Fix float ranges where diff of 0 (fengb)
• Fixed edge case where small BigDecimal ranges were erroring (fengb)
• AUTHORS vanity (fengb)
• Adds Numeric#step keyword arguments specs. (Filipe Dias)
  The implementation moves the specs that applies to all modes
  (positional arguments, keyword arguments and mixed arguments) to a
  shared spec file.
  The specific code is maintained on the main Numeric#step spec file.
• Implements keyword arguments on Numeric#step. (Filipe Dias)
• Move get_args method to a helper file. (Filipe Dias)
• Removes unneeded parenthesis from an if. (Filipe Dias)
• Switch from be_kind_of to be_an_instance_of. (Filipe Dias)
• Removes specs that only test implementation details. (Filipe Dias)
• First take at the Numeric#step spec reorganization. (Filipe Dias)
• Avoid false positive due to type conversions on Numeric types. (Filipe Dias)
• Restructure step as string specs (Filipe Dias)
• Adds more specs and fix a spec text. (Filipe Dias)
• Use value instead of self. (Filipe Dias)
  When one the params is a float, the results are floats.
• Replace Float::INFINITY value by infinity_value helper. (Filipe Dias)
• Remove ruby_bug guards (Filipe Dias)
• Apply another approach to share the specs for different argument types. (Filipe Dias)
• Adds an extra test to the keywords argument style. (Filipe Dias)
• Improve shared spec comment. (Filipe Dias)
• Improve test description to avoid misinterpretation. (Filipe Dias)
• Removed using BigDecimal in rand specs. (Brian Shirai)
• Fixed issues from merging #3182. (Brian Shirai)
• A proc call can use an implicit block. Fixes #3202. (Brian Shirai)
• Removed runtime use of CompiledCode#literals. (Brian Shirai)
• Fixed BytecodeVerifier for CompiledCode#literals change. (Brian Shirai)
• Primitive invokers aren't managed objects. (Brian Shirai)
• Updated gems. (Brian Shirai)
• Updated specs for insn changes. (Brian Shirai)
• Support push_float pseudo insn. (Brian Shirai)
  We should replace push_literal with specific instructions like push_string,
  push_symbol, push_float.
• Create call site and constant cache lists. (Brian Shirai)
• Added a few more machine metrics. (Brian Shirai)
• Untrusted status is a synonym of tainted. (Brian Shirai)
• Disable OnStack used for spawn. (Brian Shirai)
• Some cleanup internalizing CompiledCode. (Brian Shirai)
• Revert "Disable OnStack used for spawn." (Brian Shirai)
  This reverts commit a932b2329cfc8cab5cd2815badc92eeb04bc9817.

Until we replace this mechanism, we're going to lock operations.

• Added locking to LinkedList operations. (Brian Shirai)
  Until we remove this mechanism, we need to lock operations because somewhere
  around subprocess creation wires are getting crossed, as seen in the linked
  list assertion that randomly shows up on Travis.

Version 3.25 (2016-04-06)

• Add keyword arguments support for zsuper (Ahmad Sherif)
  Fixes #3363
• Add a failing JIT spec for zsuper keyword arguments support (Ahmad Sherif)
• Use sha256 for our homebrew formula (Jason Yeo)
• Fixed a couple things from the keywords patch merge. (Brian Shirai)
• Updated Melbourne version. (Brian Shirai)

Version 3.24 (2016-04-05)

• Array#new_range fills unassigned slots with nil. Fixes #3634. (Brian Shirai)
  This method needs to be replaced with a Mirror method so it is not polluting
  the Array namespace.
• Actually commit fixes for #3634. (Brian Shirai)

Version 3.23 (2016-04-04)

• Moved jit_primitives.cpp to jit/ directory. (Brian Shirai)
• Removed CallCustom. (Brian Shirai)
  CallCustom was added to provide a mechanism for binding a call site that was
  independent of Ruby method resolution semantics.

The instruction set is being improved to, among other things, decouple method
or function resolution, caching, and invocation. This will provide arbitrary
semantics for finding the code to run, caching it, and invoking it.

• Fixed custom call site dispatch. (Brian Shirai)
  This abstruse mechanism will be cleaned up with the call site and inline cache
  rewrite.
• String#dup returns copy when no modification made. Fixes #3633. (Brian Shirai)

Version 3.22 (2016-03-31)

• minor refactoring of @mode handling (Chuck Remes)
  Doing this to ease the merging of the codedb-ffi-io branch
  later on. While fixing some code in rubysl-socket it was noted
  that it touched the @mode variable directly. To simplify
  compatibility (forward and backward) with that gem, it makes
  sense to move this @mode handling to its own methods.
• Updated gems_list.txt. (Brian Shirai)
• Updated rubygems to 2.6.2 (Brian Shirai)
  RubyGems 2.6.2 installed

=== 2.6.2 / 2016-03-12

Bug fixes:

• Fix wrong version of gem activation for bin stub. Pull request #1527 by
  Aaron Patterson.
• Speed up gem activation failures. Pull request #1539 by Aaron Patterson.
• Fix platform sorting in the resolver. Pull request #1542 by Samuel E.
  Giddins.
• Ensure we unlock the monitor even if try_activate throws. Pull request
  #1538 by Charles Oliver Nutter.

=== 2.6.1 / 2016-02-28

Bug fixes:

• Ensure default_path and home are set for paths. Pull request #1513
  by Aaron Patterson.
• Restore but deprecate support for Array values on Gem.paths=. Pull
  request #1514 by Aaron Patterson.
• Fix invalid gem file preventing gem install from working. Pull request
  #1499 by Luis Sagastume.

=== 2.6.0 / 2016-02-26

Minor enhancements:

• RubyGems now defaults the gem push to the gem's "allowed_push_host"
  metadata setting. Pull request #1486 by Josh Lane.
• Update bundled Molinillo to 0.4.3. Pull request #1493 by Samuel E. Giddins.
• Add version option to gem open command. Pull request #1483 by Hrvoje
  Šimić.
• Feature/add silent flag. Pull request #1455 by Luis Sagastume.
• Allow specifying gem requirements via env variables. Pull request #1472
  by Samuel E. Giddins.

Bug fixes:

• RubyGems now stores gem push credentials under the host you signed-in for.
  Pull request #1485 by Josh Lane.
• Move coding location to first line. Pull request #1471 by SHIBATA
  Hiroshi.
• [PathSupport] Handle a regexp path separator. Pull request #1469 by
  Samuel E. Giddins.
• Clean up the PathSupport object. Pull request #1094 by Aaron Patterson.
• Join with File::PATH_SEPARATOR in Gem.use_paths. Pull request #1476 by
  Samuel E. Giddins.
• Handle when the gem home and gem path arent set in the config file. Pull
  request #1478 by Samuel E. Giddins.
• Terminate TimeoutHandler. Pull request #1479 by Nobuyoshi Nakada.
• Remove redundant cache. Pull request #1482 by Eileen M. Uchitelle.
• Freeze Gem::Version@segments instance variable. Pull request #1487 by
  Ben Dean.
• Gem cleanup is trying to uninstall gems outside GEM_HOME and reporting
  an error after it tries. Pull request #1353 by Luis Sagastume.
• Avoid duplicated sources. Pull request #1489 by Luis Sagastume.
• Better description for quiet flag. Pull request #1491 by Luis Sagastume.
• Raise error if find_by_name returns with nil. Pull request #1494 by
  Zoltán Hegedüs.
• Find_files only from loaded_gems when using gemdeps. Pull request #1277
  by Michal Papis.

=== 2.5.2 / 2016-01-31

Bug fixes:

• Fix memoization of Gem::Version#prerelease? Pull request #1125 by Matijs van
  Zuijlen.
• Handle trailing colons in GEM_PATH, by Damien Robert.
• Improve the Gemfile gemspec method, fixing #1204 and #1033. Pull request
  #1276 by Michael Papis.
• Warn only once when a gemspec license is invalid. Pull request #1414 by Samuel
  E. Giddins.
• Check for exact constants before using them, fixing Ruby bug #11940. Pull
  request #1438 by Nobuyoshi Nakada.
• Fix building C extensions on Ruby 1.9.x on Windows. Pull request #1453 by Marie
  Markwell.
• Handle symlinks containing ".." correctly. Pull request #1457 by Samuel E.
  Giddins.

Minor enhancements:

• Add --no-rc flag, which skips loading .gemrc. Pull request #1329 by Luis
  Sagastume.
• Allow basic auth to be excluded from allowed_push_host. By Josh Lane.
• Add gem list --exact, which finds gems by string match instead of regex. Pull
  request #1344 by Luis Sagastume.
• Suggest alternatives when gem license is unknown. Pull request #1443 by Samuel
  E. Giddins.
• Print a useful error if a binstub expects a newer version of a gem than is
  installed. Pull request #1407 by Samuel E. Giddins.
• Allow the (supported) s3:// scheme to be used with --source. Pull request
  #1416 by Dave Adams.
• Add --[no-]post-install-message to install and update. Pull request #1162
  by Josef Šimánek.
• Add --host option to yank, providing symmetry with pull. Pull request
  #1361 by Mike Virata-Stone.
• Update bundled Molinillo to 0.4.1. Pull request #1452 by Samuel E. Giddins.
• Allow calling build without '.gemspec'. Pull request #1454 by Stephen
  Blackstone.
• Add support for source option on gems in Gemfile. Pull request #1355 by
  Michael Papis.
• Function correctly when string literals are frozen on Ruby 2.3. Pull request
  #1408 by Samuel E. Giddins.

=== 2.5.1 / 2015-12-10

Bug fixes:

• Ensure platform sorting only uses strings. Affected binary installs on Windows.
  Issue #1369 reported by Ryan Atball (among others).
  Pull request #1375 by Samuel E. Giddins.
• Revert PR #1332. Unable to reproduce, and nil should be impossible.
• Gem::Specification#to_fullpath now returns .rb extensions when such a file
  exists. Pull request #1114 by y-yagi.
• RubyGems now handles Net::HTTPFatalError instead of crashing. Pull
  request #1314 by Samuel E. Giddins.
• Updated bundled Molinillo to 0.4.0. Pull request #1322, #1396 by Samuel E.
  Giddins.
• Improved performance of spec loading by reducing likelihood of loading the
  complete specification. Pull request #1373 by Aaron Patterson.
• Improved caching of requirable files Pull request #1377 by Aaron Patterson.
• Fixed activation of gems with development dependencies. Pull request #1388
  by Samuel E. Giddins.
• RubyGems now uses the same Molinillo vendoring strategy as Bundler. Pull
  request #1397 by Samuel E. Giddins.
• Fixed documentation of Gem::Requirement.parse. Pull request #1398 by
  Juanito Fatas.
• RubyGems no longer warns when a prerelease gem has prerelease dependencies.
  Pull request #1399 by Samuel E. Giddins.
• Fixed Gem::Version documentation example. Pull request #1401 by Guilherme
  Goettems Schneider.
• Updated documentation links to https://. Pull request #1404 by Suriyaa
  Kudo.
• Fixed double word typo. Pull request #1411 by Jake Worth.

• Don't trigger docker from this repo. (Brian Shirai)
  The docker builds are triggered from the Ubuntu 12.04 and 14.04 builds in
  the rubinius-build repo.
• Show what files were built on Heroku build. (Brian Shirai)
• Some Arguments tweaks. (Brian Shirai)
• Fixed issues with concurrent marking. (Brian Shirai)
  As noted in one of the comments in this commit, there is a serious issue with
  partially initialized data when we have a concurrent marking thread running.
  When a Tuple is created, but the fields are not initialized to nil, they may
  contain random data.

When a value is stored into a managed object, we run a write barrier. This bit
of code serves two functions. First, it "remembers" the object being stored in
case the object it is being stored into is a mature object and the object
being stored is a young object. When the young collector runs, those
"remembered" objects are part of the roots for the young region being
collected. Second, if the object being stored into hasn't been traced yet, we
trace it, and we add the object being stored to the stack of objects to trace.

If the Tuple fields aren't initialized, we'll hit a garbage value when we try
to trace it. If we don't run the write barrier when we assign values, we have
the chance of losing one of those references. An alternative to "doubly
initializing" the Tuple instance is to run two loops. One that assigns values
and one that runs the write barrier on the entries. It should be apparent that
we haven't really saved anything by using this purported "optimization" of
creating the Tuple uninitialized (dirty).

This is a good lesson in optimizing. The best optimization is not running any
code at all, rather than making running code faster, if that is an option. It
usually will give greater return to rework code in a way that significant code
can be eliminated vs "optimized". In this case, we should get rid of Array and
Tuple in the middle of stuff like calling methods.

• Add verbose logging to curl S3 uploading. (Brian Shirai)
• Use correct name for heroku S3 path. (Brian Shirai)
• A bit more CallFrame cleanup. (Brian Shirai)
  We don't have a constructor for CallFrame so it's not always clear which
  fields are initialized. In this case, VM::call_frame_ is NULL when the VM
  instance is created, so calling VM::push_call_frame sets previous to NULL when
  pushing the new frame. This is fine, but brittle.

Ultimately, CallFrame needs to be split into separate frame types for managed
code, FFI, JIT, and native methods (ie C-API), and constructors should be
defined for every type.

• Removed deprecated CompiledMethod and StaticScope. (Brian Shirai)
  Also adds deprecation for CallCustom.
• Don't start Metrics if not requested. (Brian Shirai)
  Eventually, we'll add an API to start this on demand via the Console.
• Decouple GC::Profiler from Metrics a bit. (Brian Shirai)
  Ultimately, the very simplistic utility of GC::Profiler isn't useful and
  Rubinius::Metrics should be used directly instead. We may remove support for
  GC::Profiler in the future. For now, using it requires enabling Rubinius
  Metrics.

Version 3.21 (2016-03-29)

• Set valid_encoding_ to nil if a String has invalid encoding and an invalid String is appended to it (Ahmad Sherif)
  Fixes #3631
• Add a spec for adding two invalid strings together that results in a valid one (Ahmad Sherif)
• Avoid leaking orphaned VM instances. (Brian Shirai)
  When starting a Thread, there is a point where resources are created but an
  exception could be raised that would result in the resources not getting
  reclaimed. At the moment, this is the VM instance. This will be refactored
  soon, but the same caution will always apply to creating Thread instances.
• Reworked concurrent mark thread. (Brian Shirai)
  The primary reason to use a concurrent marking strategy is to reduce the time
  during which the mutator threads are suspended while marking all reachable
  objects.

However, not running the GC synchronously when a memory threshold is reached
(eg when the Immix region has exhausted available chunks) means that heap
growth or spill over to another region (eg the Large Object Space) is
essential.

The growth is undesirable (because right now there is no compaction and growth
will continue unbounded) and the spill is especially undesirable because the
LOS collector is much less efficient than the Immix collector.

Since the marker thread is essentially racing the mutator threads, under high
allocation rates, the marker would be perpetually behind and a lot of growth
or spill would occur.

Eventually, we'll implement compaction, which will mitigate heap growth. But
that doesn't solve all the problems. To address these issues, we adhere to the
following constraints:

1. We don't defer collection. When the first memory threshold is reached, we
   perform synchronous GC and then create the concurrent marker thread.
2. We respect memory thresholds. We revert to a synchronous collection cycle
   when the concurrent marker cannot keep up with the mutator. Basically, this
   means finishing the GC cycle whenever the threshold is hit.
3. The concurrent marker restarts its work immediately after finishing a GC
   cycle instead of waiting for memory thresholds to be breached. The concurrent
   marker thread then sleeps for random intervals waiting for the mutators to
   produce more objects to scan.

• Added stack protection for loading CompiledCode object. (Brian Shirai)
• Added indicator to -v for concurrent GC enabled. (Brian Shirai)
• Improved bytecode verification failure messages. (Brian Shirai)
• Partially mitigate allocation spills with concurrent marker. (Brian Shirai)
  See the commit message for edd398c79c998eb05ed595a49cd1cbbc7664e8c1.
• Added specific header bit for Large memory region. (Brian Shirai)
• Added GC cycle to object header. (Brian Shirai)
  This is a temporary mechanism to help identify when objects are being created.
  It will be removed when the memory regions are reworked.
• Finish running finalizers before halting the machine. (Brian Shirai)
  During the halting process, when running finalizers, since finalizers may be
  Ruby objects and may run Ruby methods, we need to ensure the system is still
  fully operational.

During the finalizer finish process, no new finalizers may be created.

• Converted // slot annotation to attr_accessor. (Brian Shirai)
  Instead of duplicating the slot definition with the attr_{accessor, reader,
  writer} annotation, we redefine the macros to define the slots. This works for
  all but two cases, which are exceptional, and we define attr_field to define
  the accessors without defining the slot.
• Revert "Finish running finalizers before halting the machine." (Brian Shirai)
  This reverts commit 7d071f0cfe85d2fee6964b9292947470fbc8e40a.
• Standardized use of accessors. (Brian Shirai)
  There are two types of instance variables used in the C++ code:

1. Variables that reference managed objects and which the GC needs to know
   about to properly trace the object graph. We call these "slots".
2. Variables that reference native types (eg int, double, etc) that the GC
   cannot trace (the GC would misunderstand numbers for memory addresses, for
   example).

Previously, we treated these to types quite differently. We used the '// slot'
notation when declaring the first type so that we could automatically generate
code to process the objects. The second type was usually somewhat consistent
but also ad hoc in many places.

Now we mostly use two macros (attr_accessor for the first type, and attr_field
for the second type) that both define the variables and define setters and
getters for them. There are still some places where this needs to be cleaned
up.

One reason that we need to be very careful about the setters for the first
type of variable (the managed object references) is that when the concurrent
GC is running, we need to know when an object reference is stored into an
object that may have already been processed by the marker. If we don't see
this, that object may be considered unreachable by the GC even though it's
being referenced. This results in the equivalent to a use-after-free bug in a
language with manually managed memory.

Consistently using the managed object reference accessors means that we can
layer other behavior on the access functions. For example, if we tag objects
with an identifier for the thread that created them, we can log or prevent
mutation access from a different thread.

• Fixed setting FSEvent handle on Linux. (Brian Shirai)
• Properly guard managed objects on stack while loading code. (Brian Shirai)
• Deploy Docker Hub update. (Brian Shirai)
• Removed newlines from base64 digest. (Brian Shirai)
• A bit of write_barrier cleanup. (Brian Shirai)

Version 3.20 (2016-03-25)

• Fixed setting large object metrics. (Brian Shirai)
• Use GC-safe allocation path in string_dup insn. (Brian Shirai)
• Fixed stop-the-world mechanism. (Brian Shirai)
• Removed GCToken. (Brian Shirai)
  This was a well-intentioned idea but not practical or useful.

The idea was to have the compiler help check where in call paths a
garbage-collection cycle could run. Unfortnately, adding this in as an
after-thought resulted in all the places where GCTokens are created from thin
air deep in some call path. It didn't change the fact that GC could happen
pretty much anywhere.

In a managed runtime, either GC can happen everywhere or it should only happen
at a very small number of extremely well-defined points. The middle ground of
"it can happen at all these places" is an invitation for a low budget horror
movie, dismembered objects strewn throughout the code.

Along with the rework of the stop-the-world mechanism, the removal of GCToken
and restricting the invocation of a GC cycle to a single well-defined method
call in a few well-defined locations, and finally, making all allocation paths
GC-safe (ie GC will NOT run when allocating an object), Rubinius will have much
better defined GC behavior.

The GC safe allocation path is important for cases like the string_dup
instruction, where a young GC cycle could run when allocating the dup and the
original String (eg a literal String in a method) is in the young generation
and moved. Since the original String is on the C stack and not in a GC root
object, the dup fails when copying the contents of the original String. It's
better to make allocation GC-safe than to accept the performance cost of the GC
root in these sorts of cases. Also, that case is only one well-defined instance
of the issue. There are more complicated ones.

• Reworked allocation. (Brian Shirai)
  These changes introduce a couple things:

1. All allocation paths are GC-safe.

What that means is that when requesting a new object be created, the request
will be fulfilled unless the system (or process limits prevent it) without
GC running. In other words, there are two possible results of allocating an
object: 1) a new object, or 2) an exception because no more memory is
available to the process.

In either case, from the point the object is requested until that request
returns (or the return is bypassed by the exception unwind), the GC will not
run.

There is a trade-off here between running the GC at the instant that some
threshold is breached (eg the eden space is exhausted) and loosening some
requirements that must be maintained for a generational, moving garbage
collector (ie every object reference must be known to the GC at the time the
GC runs). Since we run GC on method entry and loop back branches, there is no
reasonable scenario in which deferring GC until allocation has completed will
result in unwanted object graph thresholds being breached pathologically (eg
an execution path where allocation can grow unbounded).

1. All objects are allocated from the various heaps uninitialized and a
   protocol is established to call an initialization routine on the objects.

The initialization routine is T::initialize(State* state, T* obj), where T is
the type of object being allocated. The method is a static method of the class
of the object. This breaks with the protocol that Ruby uses where new is a
module method and initialize is an instance method. The primary reason for
choosing a static (ie C++ class) is to avoid an instance method operating on
an incompletely initialized object.

One purpose of this initialization protocol is to eliminate or reduce the
double initialization that we were doing (ie setting all fields to nil and
then initializing them to other default values). The main initialization
method shown above may be an empty body, in which case the compiler will elide
it anyway and there's no overhead to the protocol. In that case, another
initialization method should be called on the newly created object. Since the
allocation method is templated and if the initialization method is visible (ie
in the header file), the compiler should be able to elide remaining double
initialization in most contexts.

• Fixed VM tests. (Brian Shirai)
• Fixed triggering GC. (Brian Shirai)
• Fixed some class creation. (Brian Shirai)
• Improved logging of Thread creation, fork, exec, spawn, backtick. (Brian Shirai)
• BasicObject::BasicObject::BasicObject::BasicObject::BasicObject (Brian Shirai)
• Delay tracking VM objects until Thread is running. (Brian Shirai)
  In the case of Thread.new, the OS thread will never run because a
  ThreadError exception is raised when no block is passed. If we track the VM
  object that would ultimately contain the reference to the OS thread, we either
  need a way to remove the VM object when eg Thread.new raises an exception or
  we will leak these objects. Instead of tracking and then untracking the VM
  object, we create the object untracked and track it if the OS thread starts
  executing.
• Added missing vm/alloc.hpp to git. (Brian Shirai)
• Added missing vm/thread_phase.hpp. (Brian Shirai)
• Fixes to build on Trusty. (Brian Shirai)
• Switch to unmanaged in FSEvent on Linux. (Brian Shirai)
• Fixed guarding references when calling methods from the VM. (Brian Shirai)
• Properly dup CompiledCode so call sites aren't shared. (Brian Shirai)
• Properly guard JIT specs. (Brian Shirai)
• Rework thread checkpointing and add deadlock logging. (Brian Shirai)
• Reworked when GC is invoked. (Brian Shirai)
• Set thread to unmanaged when making syscall. (Brian Shirai)
• Expand $PID in Metrics filename. (Brian Shirai)
• Improve triggering GC. (Brian Shirai)
• Add timer to new stop-the-world mechanism. (Brian Shirai)
• Added counters for checkpoints and stops. (Brian Shirai)
• Re-introduce checkpoint on block execution. (Brian Shirai)
• Fixed VM tests for collect flag in allocator. (Brian Shirai)
• Threads are pinned (mature). Run write barrier. (Brian Shirai)
• Immix sets collect flag. (Brian Shirai)
• Pulled check outside of loop. (Brian Shirai)
• Fixed VM tests. (Brian Shirai)
• Defer to Immix marker at checkpoints. (Brian Shirai)
• Satisfy gcc 4.8.4. (Brian Shirai)
• Fixed race when iterating thread list. (Brian Shirai)
• Start STW timer before trying to lock. (Brian Shirai)
• Fixed processing mark stack with possible exit condition. (Brian Shirai)
• Reworked ThreadNexus. (Brian Shirai)
• Set thread phase to waiting before locking. (Brian Shirai)
• Let pending young collection interrupt concurrent marker. (Brian Shirai)
• Added metrics on system bytes allocated & freed. (Brian Shirai)
• Reworked triggering GC. (Brian Shirai)
• Run write barrier in missing cases. (Brian Shirai)
• Removed BakerGC. (Brian Shirai)
• Introduce SleepPhase. (Brian Shirai)
  Thread semantics are ad hoc in Ruby so we make a best effort to mimic them
  where possible. The behavior of process exit when one or more threads are
  suspended in a sleep state is not well-defined. We assume that no sleeping
  thread should block the process from exiting. We introduce a specific "sleep
  phase" as one state a thread may be in. We then ignore sleeping threads when
  executing a process exit.

Unfortunately, this is more complex than it appears on its face. While
executing a process exit, we are essentially racing any sleeping threads that
may wake up and attempt to access resources that are being destroyed (something
like one of those scenes from Inception with the buildings crumbling around the
participants). We cannot waking thread proceed once process exit has started,
so we permanently lock a mutex that every waking thread must acquire before
progressing.

Ultimately, these lock resources will need to be in the program's data segment,
so they are static memory, not dynamically allocated, as they are now.

• Properly check for write errors in metrics FileEmitter. (Brian Shirai)
• Re-enable write barrier for concurrent marker. (Brian Shirai)
• Fixed CodeDB to use new allocation API. (Brian Shirai)
• Disable concurrent marker temporarily. (Brian Shirai)
• Moved vm/gc to vm/memory. (Brian Shirai)
• Moved Immix region code into vm/memory. (Brian Shirai)
• Moved memory+gc classes to 'namespace memory'. (Brian Shirai)
• Fixed FSEvent finalizer call. (Brian Shirai)
• Renamed ObjectMemory to Memory. (Brian Shirai)
  The Memory class will consolidate all aspects of managed memory in the
  Rubinius machine, not just 'Object' memory. There is a counterpart of
  Memory, as SystemMemory, to manage requesting memory from the underlying
  system (most likely the OS).
• Moved vm/ to machine/. (Brian Shirai)
  The abbreviation 'vm', usually meaning 'virtual machine', is badly overloaded
  and even inconsistent now in the code base (eg with class VM, etc). So, renaming
  the vm/ directory to machine/ and consistently using Rubinius [Mm]achine for
  both the high-level concept of the thing that encompasses the managed runtime
  (ie bytecode execution, memory management, system interface, JIT infrastructure and
  native code generation) and the code that implements it.
• Fixed namespaced references to Address. (Brian Shirai)
• Fixed triggering full collection. (Brian Shirai)
• More ObjectMemory, Memory rename cleanup. (Brian Shirai)
• Added collection logging option. (Brian Shirai)
• Removed Heap remnant of young semi-space. (Brian Shirai)
• Added malloc, calloc, realloc metrics for C-API. (Brian Shirai)
• Removed legacy reference. (Brian Shirai)
• Removed debugging. (Brian Shirai)
• Ignore all yielding threads on halt. (Brian Shirai)
• Reworked triggering mature region collection. (Brian Shirai)
• Trigger Docker Hub builds from Linux sub-builds. (Brian Shirai)
• Check if feature is already loaded when require returns false in Autoload#resolve (Ahmad Sherif)
  This solves the issue mentioned in 01a7c2f9.
• Add a spec for autoloading a constant that was already loaded by another thread (Ahmad Sherif)
  An explanation of the issue can be found in 01a7c2f9.
• Updated gems_list.txt. (Brian Shirai)
• Quarantine Thread#value spec using Thread#kill. (Brian Shirai)
  It's unclear what caused this to start failing, more debugging needed.

The vm()->thread_state()->raise_reason() == cThreadKill except when
vm_thread_state primitive is called from the Thread#run ensure clause.

• Revert "Updated gems_list.txt." (Brian Shirai)
  This reverts commit 1eb57bdc157e965bf212588886ea73775823c81c.

For some reason, these updates appear to be causing the failure of the
spec quarantined in b903c1f1989233f95d1d329eef53cd30a266ad91.

• Revert "Quarantine Thread#value spec using Thread#kill." (Brian Shirai)
  This reverts commit b903c1f1989233f95d1d329eef53cd30a266ad91.

See cfd672a5373e2e16a97b43f01692fe28c8a9043a

• Updated gems_list.txt. (Brian Shirai)
• Hack in new Immix allocator policy. (Brian Shirai)
  This hack introduces a heap growth policy into the allocator. Ultimately,
  the policy needs to define the allocator, or the allocator should be given
  an external policy to interact with. The existing Trigger thing may have
  been intended to do this but doesn't provide interaction (it's one-way).

The goal right now is to stabilize heap growth so that concurrent marking
can be re-introduced, then the young gen can be re-added.

• Set ENV in Docker images to UTF-8. (Brian Shirai)
• Re-enable concurrent mark thread. (Brian Shirai)
• Fixed synchronizing threads. (Brian Shirai)
• Fixed allocating GCData for concurrent marker. (Brian Shirai)
  This GCData structure needs to be removed and STATE properly passed through
  the garbage collection methods.
• Fix new_spec.rb typo. (Red54)
• Use keyword args in IO::{read,write}_nonblock instead of hash handling (Ahmad Sherif)
• Reworked tracking CallFrames. (Brian Shirai)
  CallFrame invariants must be preserved under the following states:

1. calling / returning from managed methods;
2. calling / returning from native methods;
3. calling / returning from native functions;
4. calling / returning from JIT functions;
5. running a Fiber;
6. unwinding the stack due to C++ exception handling;
7. unwinding the stack by longjmp();
8. before any managed code runs in a Thread; and
9. after all managed code has run in a Thread.

CallFrame invariants are:

Assume a vector of references to CallFrame instances exists
(VM::call_frames_), where n=VM::call_frames_index_ is the total number of
CallFrame instances and VM::call_frame_ refers to VM::call_frames_[n-1], and
VM::call_frame->previous refers to VM::call_frames_[n-2], etc.

1. VM::call_frames_[0] is the oldest managed frame in a Thread;
2. For all i=0...VM::call_frames_index_, VM::call_frams_[i] has 0+ live
   references to objects.
3. VM::call_frames_[VM::call_frames_index_-1] is the newest managed frame;
4. For all i=0...VM::call_frames_index_, VM::call_frames_[i+1] follows
   VM::call_frames_[i], also stated as lifetime(VM::call_frames_[i]) bounds
   lifetime(VM::call_frames_[i+1]) where lifetime(cf) returns a tuple (start,
   end) of times during which cf has live references, and for cf[i] "start_i"
   < "start_i+1" and "end_i" > "end_i+1".

• Used larger stack size for finalizer thread. (Brian Shirai)
• Avoid operating on (really) dead Threads. (Brian Shirai)
  The issue here is that Thread instances may be retained by other objects (eg
  Enumerator) and when the Thread instance itself is finalized, the order of
  finalization is non-deterministic (ie there is no Ruby API to impose an
  ordering on finalization), so a Thread instance may have had its memory for
  VM* cleaned up, and the other object referring to it may call methods on it
  when that other object is being finalized.

So, we avoid operating on really dead Threads, where a Thread's lifetime
looks something like this:

1. Memory for the Thread allocated, but the Thread is not running as a
   separate thread of execution.
2. The Thread is running.
3. The Thread's separate thread of execution has exited, so it is put in a
   "zombie" state, but all the memory for the Thread (except it's execution
   stack) is retained.
4. The Thread itself is still allocated (ie because the Thread is in a
   finalization list so its managed memory hasn't been recycled, or it's just
   been finalized) but the Thread isn't reachable by any live objects.
5. The Thread has been finalized, so it's VM* memory is deallocated, but the
   managed memory for the Thread itself hasn't been reclaimed.
6. The Thread's managed memory is no longer allocated and any reference to the
   Thread would be an "access after free" memory violation (but not necessarily
   one that would trigger a memory fault in the CPU because the region of memory
   it inhabited may still be allocated to the running program).

• Fixed assumption of Symbol table size. (Brian Shirai)
  There is no guarantee that executing some Ruby code will only create one
  new Symbol instance. Since we lazily load code with the CodeDB, we could
  be executing code at any time in any thread, for instance.
• Some fixes for Fiber. (Brian Shirai)
• More fixes for Fiber. (Brian Shirai)
• Use signed values for backtrace frames to skip. (Brian Shirai)
• Removed obsolete -X19 cruft from MSpec. (Brian Shirai)
• Run GC after native methods (C-ext functions). (Brian Shirai)
• Fixed generating backtraces. (Brian Shirai)
• Fixed finding first backtrace frame. (Brian Shirai)
• Temporarily default concurrent marker to off. (Brian Shirai)
• Fixed Symbol.all_symbols spec. (Brian Shirai)
• Fixed error attempting to wake a dead Thread. (Brian Shirai)
• Fixed BlockEnvironment::of_sender. (Brian Shirai)
• Quarantine day light savings time dependent spec. (Brian Shirai)
• Disable the JIT while running specs. (Brian Shirai)
• Fix an rb_time_timespec_new spec (Ahmad Sherif)
  For time zones with daylight saving time in effect, Time.now has a
  DST offset, while the extension function returns a time object in
  standard time offset.
• Removed remaining CallFrame passing. (Brian Shirai)
• Removed unneeded GC inhibitors. (Brian Shirai)
• Fixed invoking the GC. (Brian Shirai)
• Fixed setting String::num_bytes_ to Fixnum. (Brian Shirai)
• Reworked starting and operating on Threads. (Brian Shirai)
• Switched fork/exec lock to SpinLock. (Brian Shirai)
  Since a SpinLock is a simple integer on which CAS operations are performed,
  there is no way to go afoul of 'ownership' during fork(). This appears to
  solve a spordic issue where the child was not able to reset the fork_exec_lock_
  inherited from the parent process.
• Updated JIT for removed CallFrame* passing. (Brian Shirai)
• Fixed updating PID for logger. (Brian Shirai)
• Fixed setting Thread management state. (Brian Shirai)
  Before returning from Thread.new (or any similar methods), we ensure that
  all the state for tracking Thread instances and any related state are
  completely initialized. This prevents a case where the process calls fork()
  immediately after creating a Thread and the Thread's state is only partially
  initialized before the fork() call completes.
• Cleaned up creating VM instances. (Brian Shirai)
• Initialize NativeMethodEnvironment* to NULL. (Brian Shirai)
• Fixed shift negative value warnings on clang 3.7. Closes #3535. (Brian Shirai)
  This is a mess. See https://github.com/bonzini/qemu/commit/0f087e8e822a00fdf4ec39b443ebf51a631e0adc
• More JIT fixes from removing passing CallFrame. (Brian Shirai)
• Disable JIT inlining by default temporarily. (Brian Shirai)
• Fixed argument arity for LLVM call. (Brian Shirai)
• Re-init logger lock after fork. (Brian Shirai)
• Revert "Re-init logger lock after fork." (Brian Shirai)
  This reverts commit 17f6450b4e0377a87f01fa79b9142c8a261e485f.
• Logging while forking considered extremely dangerous. (Brian Shirai)
• Guard against NULL being added to finalization list. (Brian Shirai)
• Better integrate logger facility. (Brian Shirai)
  Basically, almost everything that is in util/ should not be. These major
  components need to be well-integrated with the rest of Rubinius. As in the
  previous case of Immix and the present case of the logger here, that means
  things like taking STATE, VM, etc as parameters and interfacing with things
  like process locks and process phases around fork/exec, etc.
• Some cleanup creating Location objects. (Brian Shirai)
• Ensure we don't use negative skip values for backtraces. (Brian Shirai)
• Ensure the CallFrame in NULL before Mirror::Thread#finish. (Brian Shirai)
• Temporarily disable JIT on Travis. (Brian Shirai)
• Removed CallFrame checks for constant arguments. (Brian Shirai)
• Added backtrace metrics. (Brian Shirai)
• Completely disable the JIT. (Brian Shirai)
• Removed mark stack debugging. (Brian Shirai)
• Restructured layout of JIT files. (Brian Shirai)

Version 3.19 (2016-02-27)

• Switch back to deploy from OSX build. (Brian Shirai)
• Fixed variable so Heroku binary gets uploaded. (Brian Shirai)
• Open core library CodeDB read-only. (Brian Shirai)
  The CodeDB open method needs to be extended to accept an argument for the mode
  to open the CodeDB, allowing for read, write, or read+write before being able
  to use a CodeDB for the runtime compiler cache. For now, we only need to read
  the core library.
• Fixed formatting for releases.yml. (Brian Shirai)

Version 3.18 (2016-02-27)

• Added deploy for Heroku. (Brian Shirai)
• Added deploy triggers for releases. (Brian Shirai)
• Log the CodeDB loaded on boot. (Brian Shirai)
• Switched to deploying from linux build. (Brian Shirai)

Version 3.17 (2016-02-26)

• Only trigger rubinius-build on linux. (Brian Shirai)
• Fixed displaying -Xhelp. (Brian Shirai)
• Show exception loading CodeDB instead of abort. (Brian Shirai)
• Added fallback if codedb.core.path doesn't exist. (Brian Shirai)

Version 3.16 (2016-02-25)

• Omit [ skip ci ] from GitHub release notes. (Brian Shirai)
  Odd formatting necessary to avoid getting stripped for release notes.
• Fix configure script to enable C++11 regardless of LLVM version. (Joe Eli McIlvain)
  The CodeDB work added C++11 usage into the VM source itself,
  but C++11 support was only enabled for LLVM >= 3.5,
  failing for users with lower supported LLVM versions.

Resolves #3622.

• Consider an autoload resolved if #resolve didn't return nil in Autoload#call (Ahmad Sherif)
  This fixes cases of autoload "errors" mentioned by @robin850 in
  https://github.com/rubinius/rubinius/issues/2934#issuecomment-76391260
  and https://gist.github.com/robin850/3eeaed2538f50a9887c2

This is an explanation of the issue:
We already have A::B been autoloaded by the main thread. When c.rb (see
any of the previous links) is being autoloaded in another thread, class
A::B is being opened using Rubinius.open_class_under (through
Rubinius.open_class).
Since module A has an Autoload entry for B in its constant_table,
open_class_under tries to call #call on this Autload object, which returns nil
because #resolve returns false (CodeLoader.require returns false
if a feature is already been loaded).
With nil returned, open_class_under decided to create a new Class object
for B, which means the autoload entry it already had for :C is lost,
resulting in constant A::B::C not being found.

• Revert "Consider an autoload resolved if #resolve didn't return nil in Autoload#call" (Ahmad Sherif)
  CodeLoader.require returning false doesn't necessarily mean the feature
  got loaded.

This reverts commit 01a7c2f9b91a6edf5637c6dbf0d79f4e59b560b3.

• Only build binaries for a specific Ubuntu version. (Brian Shirai)
• Use dist version for docker deploy. (Brian Shirai)
• Decouple linking for C-exts from clang/gcc. (Brian Shirai)
• Updated Dockerfile for Ubuntu to include compiler. (Brian Shirai)
• Fix a condition in utilities::logger::append_newline (Ahmad Sherif)
  The previous condition assumes enough space to append an extra newline
  followed by \0. If we already have a full message buffer, appending would
  overflow and the \0 would corrupt some adjacent variable. If this
  adjacent variable happens to be the guard from the calling function,
  it would be corrupted and fails to unlock its lock, causing other
  logging components to stuck forever waiting for that lock.
• Use a clearer condition in utilities::logger::append_newline (Ahmad Sherif)
  Credits to @brixen, follow-up on 0b4b712.
• Fixed setting release date when building from tarball. (Brian Shirai)
• Trigger rubinius-build on deploy. (Brian Shirai)
• Use a loop instead of recursion when processing a regex group (Ahmad Sherif)
  It can blow up the stack if too many characters are inside the group.

Version 3.15 (2016-02-19)

• Added start of Rubinius::CodeDB. (Brian Shirai)
• Generate first cut of CodeDB for kernel. (Brian Shirai)
  This all needs to be properly extracted into a compiler facility.
• Handle m_id in create_block instruction. (Brian Shirai)
• Added CodeDB::open and ::load. (Brian Shirai)
• Added -Xcodedb.kernel.path, codedb.cache.path. (Brian Shirai)
• Added signature to CodeDB. (Brian Shirai)
• Added running CodeDB initialize. (Brian Shirai)
• Added m_id to CodeDB contents. (Brian Shirai)
• Wired method_id into MethodTable. (Brian Shirai)
• Fixed tagging custom call sites. (Brian Shirai)
• Fixed rendering ConstantTable contents. (Brian Shirai)
• Simplify alpha const_missing method. (Brian Shirai)
• Boot kernel from CodeDB. (Brian Shirai)
• Fixed store_my_field to consider frozen status. (Brian Shirai)
• Fixed String#replace. (Brian Shirai)
  The store_my_field bug hid this bug.
• Start merging kernel/ into a single directory. (Brian Shirai)
• Finished merging kernel/ into a single directory. (Brian Shirai)
  Kernel does not yet boot. Some dependencies still need to be resolved.
• Spec Enumerable#sort_by when #map does not return an array (Alastair Pharo)
  The basic example for this is a lazy enumerable. In this case, #map
  returns another lazy enumerable, and this breaks #sort_by
• Fix for Enumerable#sort_by when #map does not return an array (Alastair Pharo)
• Updated rubinius-code gems. (Brian Shirai)
• Updated paths for rubinius-code gems. (Brian Shirai)
• Wrapped/cleaned up README.md (Yorick Peterse)
• Added RubyGems license files (Yorick Peterse)
• Added udis86 license file (Yorick Peterse)
• Added winpthreads license (Yorick Peterse)
• Added explicit license file for zlib (Yorick Peterse)
• Clarified what is covered by what license (Yorick Peterse)
  Fixes #3590
• Fix building kernel. (Brian Shirai)
• More kernel build cleanup. (Brian Shirai)
• Load kernel from a single file. (Brian Shirai)
• Cleaned up load_order.txt and building kernel. (Brian Shirai)
• Removed kernel.rake to simplify merging codedb. (Brian Shirai)
• Fixed building flattened kernel for CodeDB. (Brian Shirai)
• Reorganized kernel to improve loading order. (Brian Shirai)
  These are the desired phases for booting Rubinius:

1. boot the VM itself with the ability to load and execute bytecode;
2. create the bootstrap methods and functions to be able to define
   class/module and methods;
3. load the kernel code, only defining class/module and methods;
4. run all 'init' / setup code for the kernel, defining initial runtime data
   structures and constant values;
5. create the Loader instance and parse command line options;
6. run user code.

• Removed unneeded require for build_config. (Brian Shirai)
• Updated Melbourne to 3.1. (Brian Shirai)
• Fix a couple failing specs. (Brian Shirai)
• Renamed kernel/ to core/. (Brian Shirai)
• Fixed order of overwriting ffi_function_missing. (Brian Shirai)
• Fixed changing method visibility. (Brian Shirai)
• Some kernel -> core remnants cleanup. (Brian Shirai)
• Fixed filtering core library frames from backtrace. (Brian Shirai)
• Fixed Module#define_method. (Brian Shirai)
• Moved CodeDB to core/. (Brian Shirai)
• Fixed aliased core methods having same hash. (Brian Shirai)
• Fixed setting @exception on frozen Thread. (Brian Shirai)
• Fixed JIT loading CompiledCode from method_id. (Brian Shirai)
• Fixed rubinius-compiler gem version. (Brian Shirai)
• Fixed paths and cleaned up var warnings. (Brian Shirai)
• Try moving to Trusty and clang, llvm 3.5 on Travis. (Brian Shirai)
• Update packages on Trusty first. (Brian Shirai)
• Fixed configure command. (Brian Shirai)
• Install libedit-dev on Travis. (Brian Shirai)
• Fixed installing. (Brian Shirai)
• Moved ARGF.read encoding specs to shared spec file (Yorick Peterse)
• ARGF.read should use ASCII 8BIT, not US_ASCII (Yorick Peterse)
• Added specs for ARGF.read_nonblock (Yorick Peterse)
• Added ARGF.read_nonblock (Yorick Peterse)
  Fixes #3594
• Added local variable methods to Binding (Yorick Peterse)
  This adds the following methods:
• Binding#local_variable_set
• Binding#local_variable_get
• Binding#local_variable_defined?

Fixes #2992
Closes #3372

• Fix Module#define_method (Benny Klotz)
  When defining a method through a proc which gets created out of a method
  which is defined in a C-ext, meth.ruby_method.executable is a instance of
  Rubinius::NativeCode and not Rubinius::CompiledCode which does not
  respond to #scope.

This is used for example in pg gem:
https://github.com/ged/ruby-pg/blob/bb4693e811f9348f202835e701e6509d15685b0a/lib/pg/connection.rb#L187

• implement Proc#for_define_method (Benny Klotz)
• implement Method#for_define_method, add second argument klass to for_define_method which is needed by Method and UnboundMethod (Benny Klotz)
• implement UnboundMethod#for_define_method (Benny Klotz)
• raise TypeError if meth does not respond to :for_define_method (Benny Klotz)
• cleanup Method#for_define_method and UnboundMethod#for_define_method, delegate responsibility further to executables (Benny Klotz)
• implement Executable#scope, retrieving proper code part is responsibility of Method,UnboundMethod #for_define_method, add 3rd arg callabale_proc to Method,UnboundMethod #for_define_method (Benny Klotz)
• use Method,UnboundMethod #for_define_method in Proc#for_define_method (Benny Klotz)
• Proc#for_define_method get the scope through the newly created BlockEnvironment::AsMethod (Benny Klotz)
• add example which specs behavior of Proc#for_define_method when procs @ruby_method is set (Benny Klotz)
• don't use single letter variable names (Benny Klotz)
• BlockEnvironment::AsMethod#scope should return the scope of block_env (Benny Klotz)
• Implement Proc#for_define_method when @ruby_method is nil like in the old impl to ensure the same behavior (Benny Klotz)
• Add a spec for rb_define_class_under when given a mismatched superclass (Ahmad Sherif)
• Add rb_define_class_id_under to the C API (Ahmad Sherif)
  Closes #3613
• Add specs for rb_define_class_id_under (Ahmad Sherif)
• Add rb_time_timespec_new to the C API (Ahmad Sherif)
• Add specs for rb_time_timespec_new (Ahmad Sherif)
• Added NameError#receiver (Yorick Peterse)
  MRI seems to handle this within C and doesn't define any way of setting
  the receiver from Ruby. As a result of this we'll just use a keyword
  argument.

Fixes #3607

• Added String#-@ and String#+@ (Yorick Peterse)
  Fixes #3608
• Fixed NameError#receiver for BasicObject instances (Yorick Peterse)
• ObjectSpace._id2ref raises for invalid ID values (Yorick Peterse)
  Fixes #3504
• Updated list of Gems to install (Yorick Peterse)
  In particular this includes rubysl-stringio 2.1.0
• Use ascii_only_p() instead of ascii_only_ (Ahmad Sherif)
  ascii_only_ does not usually have a correct value, so we ascii_only_p()
  to make sure it does.

Related to #3531

• Optimize String::byte_index for ASCII-only strings when passed an index (Ahmad Sherif)
  Related to #3531
• Add specs for Mirror::String#byte_index when passed index greater than string's length (Ahmad Sherif)
• Consider valid encoding if a String passes ascii_only_p() (Ahmad Sherif)
  Related to #3531
• Add issue template (jc00ke)
  Seen at https://github.com/dear-github/dear-github/issues/125
  [skip ci]
• Make repro section more prominent & detailed (jc00ke)
• Expanded the issue template (Yorick Peterse)
• Updated rubysl-pathname to 2.3 (Yorick Peterse)
• Update rubinius-melbourne to 3.3 (Ahmad Sherif)
  Closes #3600

Version 3.14 (2016-01-28)

• Add failing specs for slice_* when iterator method is changed (Jason Yeo)
• Add another failing specs for zsuper with keyword arguments (Ahmad Sherif)
• Fix Array#product behavior when given a block (Ahmad Sherif)
  Fixes #3587
• Add a spec covering Array#product returning self when given a block (Ahmad Sherif)
• Reword spec description (Jason Yeo)
• Fix issue in slice_(after|before) when iterator method yields more than one value (Jason Yeo)
• Remove spec as slice_when does not have issues with iterators yielding > 2 values (Jason Yeo)
• Fix count when enumerable yields multiple values (Jason Yeo)
• Use describe, rephrase spec description (Jason Yeo)
• Use rubinius-ast-2.4. (Brian Shirai)
• Use the new path of rubinius-ast gem in kernel.rake (Ahmad Sherif)

Version 3.13 (2016-01-25)

• bump RUBY_VERSION to 2.2.2, rack 2.0.0.alpha requires ruby >= 2.2.2 (Benny Klotz)

Version 3.12 (2016-01-22)

• Update tags/branches before untagging (Yorick Peterse)
• Clear buffer passed to ARGF.read before appending to it (Ahmad Sherif)
• Add a spec covering clearing output buffer of ARGF.read (Ahmad Sherif)
• Implement ARGF.readpartial (Ahmad Sherif)
• Add specs for ARGF.readpartial (Ahmad Sherif)
• Allow IO#{read,write}_nonblock to take an exception: false option (Ahmad Sherif)
• Add specs for IO#{read,write}_nonblock accepting exception option (Ahmad Sherif)
• Updated installed Rake version (Yorick Peterse)
• Updated list of rubysl Gems to install (Yorick Peterse)
• Added failing specs for zsuper with rest kwargs (Yorick Peterse)
• Fix Kernel#rand when given a Float exclusive range. (Joe Eli McIlvain)

Version 3.11 (2016-01-21)

• Implement Hash#{>, >=, <, <=} (Ahmad Sherif)
• Add specs for Hash comparison operators (Ahmad Sherif)
• Only build Ubuntu 12.04 Docker image for now. (Brian Shirai)
• Add specs for chunk_while (Jason Yeo)
• Implement chunk_while (Jason Yeo)
• Remove chunk_while tags (Jason Yeo)
• Change error message (Jason Yeo)
• block.call->yield (Jason Yeo)
• Remove initial state from slice_before (Jason Yeo)
• Remove initial state from chunk (Jason Yeo)
• Use a better error message (Jason Yeo)
• add failing NameError#receiver spec (Benny Klotz)
• add failing spec for String.new with optional encoding argument (Benny Klotz)
• Implement String.new encoding optional argument (Benny Klotz)
• Fetch existing tags before adding a new one (Yorick Peterse)

Version 3.10 (2016-01-17)

• Eliminate some duplication from Enumerator::Lazy#grep (Ahmad Sherif)
• Implement Enumerator::Lazy#grep_v (Ahmad Sherif)
• Add specs for Enumerator::Lazy#grep_v (Ahmad Sherif)
• Updated Dockerfile for 15.10 to 3.9. (Brian Shirai)
• Updated Dockerfile for 14.04 to 3.9. (Brian Shirai)
• Implement File.mkfifo (Ahmad Sherif)
• Add specs for File.mkfifo (Ahmad Sherif)
• Updated location of Dockerfiles. (Brian Shirai)
• Moved Dockerfiles to rubinius/docker repository. (Brian Shirai)
• Fix a typo in Enumerator::Lazy specs (Ahmad Sherif)
• Implement Hash#fetch_values (Ahmad Sherif)
• Add specs for Hash#fetch_values (Ahmad Sherif)
• Fixed some 64bit assumptions in specs. Closes #3560. (Brian Shirai)

Version 3.9 (2016-01-16)

• Use Type.object_equal in Binding.self_context (Yorick Peterse)
  Normally I'd oppose these kind of changes in favour of fixing Gems doing
  this. However, since this is literally the only thing preventing
  GitLab from booting at the moment this change ensures I don't get
  blocked for days while waiting for a response from the Teaspoon
  maintainers.

This fixes #3570

• Updated Dockerfile for 15.10 to 3.8. (Brian Shirai)
• Updated Dockerfile for 14.04 to 3.8. (Brian Shirai)
• Cleaned up styling of Array#== (Yorick Peterse)
  Variables such as "md" and "od" are super confusing.
• Make Kernel#loop returns StopIteration#result when stopped by the exception (Ahmad Sherif)
• Add a spec for Kernel#loop returning StopIteration#result (Ahmad Sherif)
• Try to not use RVM on Travis. (Brian Shirai)
• Make Comparable#== no longer rescues exceptions (Ahmad Sherif)
• Update Comparable#== specs to reflect it does not rescues exceptions anymore (Ahmad Sherif)
• Eliminate some duplication from Enumerable#grep (Ahmad Sherif)
• Implement Enumerable#grep_v (Ahmad Sherif)
• Add specs for Enumerable#grep_v (Ahmad Sherif)
• Add specs for #dig with no arguments (Nikola Nenkov)
• Make #dig raise ArgumentError when invoked with no arguments (Nikola Nenkov)
• Fixed C++ exception being raised in rb_dbl2big. (Brian Shirai)