rubinius

Version 3.48 (2016-07-20)

• Updated deprecations for Ruby 2.2. (Brian Shirai)
• Added Exception#cause. Closes #3680. (Brian Shirai)
• Added start of DataHeader and Trie. (Brian Shirai)
• Renamed ConstantScope to LexicalScope. (Brian Shirai)
  Originally, this was called StaticScope, which was pretty accurate. It was
  renamed ConstantScope to make it more obvious that it was intimately related
  to 'constant' lookup in Ruby.

However, constants are odd things in Ruby: their values are neither constant
nor is their lookup restricted to one scope. Instead, their values may be
reassigned and their lookup starts with the lexical scope but continues with
the inheritance chain.

With the additional of functions in Rubinius bound to lexical scope, it is
reasonable to refocus this object on its actual role: to represent a lexical
scope.

• Updated compiler version. (Brian Shirai)
• Avoid setting Exception#cause to itself. (Brian Shirai)
• move initialization of lineno to more central location (Chuck Remes)

Version 3.47 (2016-07-15)

• Improved HAMT Hash. (Brian Shirai)
  The base "table" has been replaced by a regular Trie. Rubinius has deprecated
  support for 32-bit and that support is being removed, so the branching factor
  is currently 62 (actually 60 = 6 * 10), but that will be extended to 64 when
• instructions are added for computing with non-mananged objects (ie not
  being limited to Fixnum); and 2. managed objects with non-managed fields are
  able to be processed by managed code instructions.

A linear scan list is still used for hash values that collide along (6 * 10 =
60 bits), but this could be enhanced to be a binary/red-black/etc tree
instead.

• Removed 32-bit platform support. (Brian Shirai)
• Removed GCC support. (Brian Shirai)
• Updated parser gem versions. (Brian Shirai)
• Updated deprecations. (Brian Shirai)

Version 3.46 (2016-07-12)

• Use HAMT for Hash. (Brian Shirai)
• use rubysl-socket-2.1.2 gem (Chuck Remes)

Version 3.45 (2016-07-10)

• Updated Gemfile.lock. (Brian Shirai)
• Codedb ffi io (#3619) (Chuck Remes)
• add basic support for additional IO functions
• add back dup2 function definition
• add convenience methods for errno handling
• add O_CLOEXEC to list for File IO
• add a few more functions like ftruncate to the list
• hack away and rejigger things to get IO booting using mostly FFI calls
• make some fixes to pass more specs
• passes most read specs
• add spec for negative IO#pos when 'unget'ing at start of stream
• more fixes to pass ungetc/ungetbyte/pos/read specs; all pass
• fix #getc to handle encodings properly; passes chars_spec
• fix read_to_separator to handle skipping properly
• specs for requesting a negative-sized pointer which causes SEGV
• return NULL for a MemoryPointer.new with a negative size
• add basic support for additional IO functions
• add back dup2 function definition
• add convenience methods for errno handling
• add O_CLOEXEC to list for File IO
• add a few more functions like ftruncate to the list
• hack away and rejigger things to get IO booting using mostly FFI calls
• make some fixes to pass more specs
• passes most read specs
• add spec for negative IO#pos when 'unget'ing at start of stream
• more fixes to pass ungetc/ungetbyte/pos/read specs; all pass
• fix #getc to handle encodings properly; passes chars_spec
• fix read_to_separator to handle skipping properly
• specs for requesting a negative-sized pointer which causes SEGV
• return NULL for a MemoryPointer.new with a negative size
• raise IOError on malloc failure; force returned strings to binary
• force strings to binary for handling #gets with separators and limits; remove debug prints
• remove debug prints again - ps i hate git
• cleanup var use to make specs happy
• fix initialize specs
• remove some commented out and dead code
• switch from C++-based #seek to FFI seek
• redefine STDIN/STDOUT/STDERR to use new IO obj
• switch to using FFI-bound #write command
• include sync as part of fields to move to new IO obj
• mark rubinius as non-compliant for buffering writes; impl detail anyway
• to swap in new IO we need it to happen early enough in the load order before STDIN/etc are used
• need to redefine STDIN/etc and /etc when we swap in new IO object
• begin refactoring IO internals to make support and expansion simpler hopefully
• simplify by taking advantage of existing class method
• add a convenience method for testing call failure
• add #pipe function
• continue refactoring to support pipes and reopening FDs
• baby steps toward making #dup work
• use #descriptor accessor instead of using ivar directly
• make #ensure_ methods public; buffered read should return nil when EOF
• fix error message to use proper local var
• fix #new_pipe so handle encodings correctly
• set encodings for 'left hand side' pipes
• fix #dup specs and add a debugging method
• fix #eof specs
• fix #getbyte spec
• fix several IO#reopen_path bugs particularly improper Errno usage
• use a FFI convenience method for checking call failure
• add spec to test EOF behavior with IO#reopen
• fix IO#reopen to handle EOF correctly
• fix some eof specs with just one to go
• fix setting EOF when seeking
• make any seek on a Pipe raise Errno::ESPIPE
• fix buffer issues when reading with separators and limits; fix sysread
• Multiple fixes...
• Fixed the #seek inheritance hierarchy mostly by no longer
  conflating #seek and #sysseek as the same thing.
• Rename PipeFileDescriptor to FIFOFileDescriptor since it
  can also be used for special character files.
• Fix #gets so the peek ahead for multi-byte characters is
  properly respected; refill the buffer if we don't have enough
  bytes for peek ahead.
• Fix important error in #new_open_fd which was using the wrong
  flag on an FD. When using fcntl on an FD, it is important to use
  the FD_* flags. Was using O_CLOEXEC instead of FD_CLOEXEC and as
  a result all child processes were hanging when their read pipe
  was closed.
• Handle EPIPE in #write correctly. Also raise an error if we
  get an error instead of ignoring it.
• provide initial but broken C++ to Ruby conversion for IO.select
• Fixed FDSet to link.

This is a complex part of Rubinius and FFI where we need some primitive
code to interact with libc macros.

• converted until/end into begin/end until which fixed 4 specs
• add logic to load and detect posix_fadvise constants and enable feature detection
• add with_feature detection to skip these specs on platforms without posix_fadvise
• convert usage of posix_fadvise from C++ to Ruby code
• add select function signature; may need to change when we learn more about implementation
• continue fixup of IO.select; handle coercion and choosing max FD
• generate and save a string defining the struct timeval as a FFI struct
• add gettimeofday function for FFI access
• add FDSet::to_set to return FDSET for use by select
• finish fleshing out select support code; unfortunately SEGVs
• fix function signature for posix function #select
• fix returning pointer to descriptor_set
• pull FD_SETSIZE directly from the headers
• fix discovery of highest numbered FD; select still SEGVs
• return pointer to fd_set as a FFI pointer so we can use it from Ruby
• pass FFI Pointer to select; fixes SEGV but still does not work correctly
• fix SEGV by correctly getting the address of the data member
• fix #collect_set_fds; kind of works now
• Passes all but one select spec which is related to thread sleeping

Fixed +timeout+ handling so that a nil timeout is respected.
Prior to this we were allocating timeval structs every time and
it turns out that an empty struct and a nil value are not
equivalent in behavior.

Took the opportunity to refactor and DRY up some code that
validated IO.select arguments.

• modify this ugly hack a little to put struct in proper namespace
• add helper methods for raising EAGAIN and EAGAINWaitWritable
• disable the C++ version of #readpartial
• fix readpartial and read_nonblock specs; add new behavior for read_nonblock
• disable the C++ code for write_nonblock
• write the code to support write_nonblock and clean up some style issues
• comment out all primitives that are no longer in use
• stub out a call to #pos for 2 specs
• when reopening a FD flush buffer and seek to other FDs location; fix typo
• Support File#truncate and File#ftruncate correctly

Turns out that #truncate needed to be a class method, so I moved
it to a class method of FileDescriptor.

Also added support for creating a DirectoryFileDescriptor. It
merely inherits from FileDescriptor now. We will see if it needs
any new behavior or if default behavior needs to be curtailed.

• fix bug where kernel/common/io.rb was not set to nil after #foreach call
• fix bug in spec where incorrect args were passed to test #gets with limit

Tricky one to find. The original spec used #gets(1) to read one
char. Unfortunately, this arg format ends up setting a separator
to $/ so the logic ends up calling
EachReader#read_to_separator_with_limit instead of
EachReader#read_to_limit. By passing nil, as in #gets(nil, 1),
then we force the code paths to call read_to_limit.

• fix handling of multi-byte chars when reading with char limits

This fixes several specs shared by gets, foreach, and readline.
The EachReader class needs a good refactoring at this point
but for now I just want to commit working code.

• refactor IO::EachReader, dry it up, and improve code docs
• rescue ESPIPE from seek in #reopen when reopening a Pipe FD
• fix spec to properly handle the expected returns from #readlines
• move stdin/out/err redefinition under Rubinius::IOUtility namespace to avoid collisions
• fix indentation
• remove superfluous todo comments and dead/commented-out code
• fix indentation
• verify that non-blocking writes DO NOT BLOCK when a system buffer is full
• when a write returns EAGAIN or EINTR test to see if in non-blocking mode

Also took the opportunity to refactor fcntl F_GETFL and F_SETFL

• fix misuage of F_GETFL with F_GETFD
• first attempt at getting C-API updated to use Ruby obj over C++ obj
• fix several CAPI specs by correctly getting descriptor
• rename set_blocking method to clear_nonblock which makes more sense to me
• toggle the current thread sleep state when potentially blocking on read or select
• modify exception message to match MRI test expectations
• handle case where user calls IO.allocate and close
• allow multiple successive IO#close calls without error
• second attempt at fixing io=IO.allocate; io.close
• third try is the charm for IO.allocate; io.close
• multiple calls of close, close_read, and close_write should no longer raise IOError
• no longer raise IOError on multiple calls to close, close_read, or close_write
• refactor descriptor testing to make it cleaner
• remove duplicate check of ::read return value
• verify #read raises IOError when read interrupted by another thread closing socket
• always verify file is open after a read operation
• spec limit 0 behavior for each_lines for MRI 2.3 compatibility
• support raising ArgumentError given limit 0 for each_lines
• begin work on supporting Socket
• use rb_funcall properly; fixes SEGVs
• fix typo in private method name
• define method to raise EAGAINWaitWritable
• raise EAGAINWaitWritable when nonblocking write would block
• rescue exceptions when #find_type fails in @enclosing_module

This is really weird. The code calls #find_type in the scope
of the enclosing_module, but there could be a conflict with
that method name, numbers of args it takes, its purpose, etc.
So a failure here should be rescued and allow the followup
code to call #find_type on the FFI class.

This was discovered when the ffi-io branch failed to build
a native extension. The mkmf.rb gem was doing some logging
during the build which caused some code in IO::Select to
call IO::Select.class_eval on code to instantiate the
Timeval_t struct class. Creating a struct calls #find_type
but it was calling it from the scope of mkmf.rb which had
its own (completely different!) method named #find_type
defined. It threw an ArgumentError because the arity didn't
match, but it lead me to this logic error and fix.

• only allow seeking on 'file' file descriptors and not on fifo or other

During a call to IO.reopen a file descriptor was dup2'ed. Its
ftype changed from "file" to "fifo" and as we know a fifo cannot
seek. So we were blowing up when trying to set the offset ivar.
By only allowing seek on "file" FDs, we'll avoid the bug.

• remove spec for an IO implementation detail that no longer holds

As far as I can tell, there is no #buffer_empty? public method on
the IO class. We had one to test this behavior. Gone!

• remove unused and unnecessary public method
• remove temp spec file that was accidently committed earlier"
• emulate blocking read behavior using #read_nonblock

We had a failing spec where a thread blocked on read was
supposed to raise IOError when another thread closed
the IO. However, it didn't work. Turns out that the
low-level system read function blocks forever so the
closed IO/file descriptor didn't raise as expected.

The original C code got around this OS behavior by setting
special flags and sending signals to the blocked thread
to wake it up. This mechanism was only exposed to the
bytecode VM and wasn't available to the Ruby runtime so
I had to go this other direction. It's less than ideal
but if the long-term plan is to utilize libuv for
Rubinius IO then this is a good enough fix.

• change IO.setup to set fd accessor; fixes socket setup

I don't really like this solution very much. Ideally the
Socket classes would set @fd directly in their #initialize
methods via a call to FileDescriptor.choose_type(fd). Having
a +fd+ accessor on the IO class was intended only for
debugging purposes.

Let's go with this patch for now. If the larger refactoring
of the IO class to use a private IO::FileDescriptor class
is accepted then we can go back and change the Socket methods
to conform better and remove this accessor.

• replace calls to C++ IO obj with Ruby IO obj
• remove dead and commented-out code as part of cleanup
• spec out #ttyname behavior in Ruby
• add #ttyname function to FFI
• convert IO#ttyname from C++ to Ruby
• use Regexp to handle forward slash escaping in spec
• re-enable partial support for IO finalizer and autoclose

The IO finalizer is tricky since it also has to detect possible
modifications from C API calls. There will likely need to be
some rework done on the C API code itself to make this easier
to manage from the Ruby side since we are trying to get as much
as possible out of C/C++.

• A couple fixes for finding constants.
• Fixed accessing Stat in IO::FileDescriptor.
• make sure proper encoding set when using #read_nonblock
• first try to add finalizer support for C-extensions
• improve variable name
• if we fclose a FD then do not call close on it too
• use Ruby-based IO functions instead of C++ object
• remove unnecessary IO calls
• remove test file for dead C code
• remove dead C code for IO classes
• remove dead code
• make socket C funcs call ruby code from C; first try
• Fixed defining GC stubs for IO class.
• use calling frame when given else look it up
• Cleanup from stw branch merge.
• Revert "use Ruby-based IO functions instead of C++ object"

This reverts commit ca755090dec70fa54ed43fbcc1585c24ff6c5522.

Re-introduced IO::open_with_cloexec to clean up this.

• Removed test_io.hpp incorrectly merged.
• Fixed IO::FileDescriptor#finalizer definition.
• Switched fork/exec lock to SpinLock.

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.

• Properly assign rio_stream GC root.
• Use built-in finalizer protocol for IO-related objects.
• use files instead of pipes to test finalizers
• move fd instance alloc to IO.setup
• fix method signature; remove debug print
• call method on self via send

Before the code was looking up 'self' by getting the current
call frame and pulling self from it. This was returning a
different object than expected. So now we just call #send
against the current object; this works consistently.

• cast unsigned vals back to signed to fix compiler warnings
• modify order of operations via parens to satisfy compiler
• hack to prevent closing rio twice
• Removed .tap generating structs.
• Removed double finalization bandaid.

We need to ensure this is fixed now.

• Re-added Rubinius define_finalizer extension.
• Fixed finalizer spec to clean up temporary.
• ignore NotImplementedError for #fadvise on platforms that do not support that call
• bump ruby compatibility to 2.3.0
• rename spec file so ci run matches 2.3.0 ruby compat
• verify that infinitely looping subprocesses can be force closed
• remove special case EPIPE error handling so all write errors bubble up
• clarify intent of spec
• make sure we test for new transcoding options
• prepare to handle passing more encoding options in IO.open/File.open
• stub in an attempt at hooking up newline transcoders
• stub in attempt at accessing transcoders
• fix regex so it matches newline transcoders
• Revert "stub in attempt at accessing transcoders"

This reverts commit 6455dc7590bbf9b0fb904846b115bb9cefb3ca01.

• Revert "stub in an attempt at hooking up newline transcoders"

This reverts commit 39d255f5b72eadcce34f0deb2e83cd3c7254254c.

• Revert "make sure we test for new transcoding options"

This reverts commit 679a247a3a932d3b22d8d20082b2026ea2b52cfa.

• fix encoding_options handling to pass specs
• Guard calling fclose() on NULL rio-f.

Version 3.44 (2016-07-10)

• Fix by @wahjava for sem_open call on FreeBSD. Closes #3677. (Brian Shirai)
• Updated parser gems. (Brian Shirai)
• Bump Ruby version to 2.3.1. (Brian Shirai)

Version 3.43 (2016-07-01)

• Distinguish Data and typed Data. (Brian Shirai)
• Fix GCC issue. (Brian Shirai)
• Ensure Console listener thread exits. (Brian Shirai)
• Assume this is not NULL. Closes #3675. (Brian Shirai)
• Raise exceptions instead of abort() for interpreter errors. (Brian Shirai)
• Raise DeadlockError instead of abort(). (Brian Shirai)
• Added {i,d}registers for {Compiled,Machine}Code. (Brian Shirai)
• Reworked inline caches. (Brian Shirai)
  Under concurrent update, we need to preserve the coherence of the multiple
  values is the InlineCache object. In other words, no thread should be able to
  see values in a single InlineCache object that represent a partial update of
  the inline cache.

To meet this constraint, we pre-allocate the number of InlineCache slots
specified at process invocation for every CallSite object. Those slots point
to individual InlineCache objects as the call site is executed and the type
profile changes. The pointers are swapped atomically, and if the atomic swap
succeeds, the previous cache is retained in a 'dead list' until the next
garbage collection cycle. If the update fails, the updated cache is discarded
and the update is attempted again.

Nothing should retain the InlineCache pointers outside the CallSite object.
During execution of the CallSite, the InlineCache pointer should be on the
execution stack, so swapping the pointers should not impact code that is
already-in-progress. At a garbage collection checkpoint, no interpreter will
be in-progress, so deleting the replaced InlineCache objects should be safe.

Version 3.42 (2016-06-26)

• Raise FiberError if pthread resources is unavailable. (Brian Shirai)
• Don't set os_thread to creating pthread_self. (Brian Shirai)
• Added {Thread, Fiber}.count. (Brian Shirai)
• Reworked locking around fork(). (Brian Shirai)
• Tweak ordering for releasing ThreadNexus lock. (Brian Shirai)
• Retry execvp on EAGAIN. (Brian Shirai)
• Tweak ThreadNexus unlock, fork_unlock. (Brian Shirai)
• Use non-blocking lock for managed transition & checkpointing. (Brian Shirai)
• Process Fiber finalizer. (Brian Shirai)
  We do not yet dispose of unreachable but not-yet-completed Fibers.
• Added Fiber#dispose and auto-cleanup of Fiber. (Brian Shirai)
  A Fiber is composed of both managed (ie object memory) resources and unmanaged
  (ie pthread) resources. When a Fiber completes normally, the unmanaged
  resources can be reclaimed simply.

When a Fiber that has not completed normally goes out of 'scope' (ie is no
longer reachable from any reachable object), the garbage collector cannot
simply reclaim the managed resources allocated to the Fiber because the Fiber
composes native resources (ie the pthread instance). In this case, the Fiber's
pthread invoke function needs to be forced to exit so that the pthread
instance can be reclaimed.

Version 3.41 (2016-06-20)

• Updated mkmf thinks this file should exist. (Brian Shirai)
• Updated mkmf version. (Brian Shirai)
• Slightly relax logger semaphore threshold. (Brian Shirai)
  Rather than possibly deadlocking, we reset the logger semaphore if it appears
  to be in a bad state. This means it's possible that incorrect interleaving
  could occur in the log file. We accept this tradeoff for not deadlocking a
  process.

We attempt to make the threshold high enough to avoid spurious failures but
not high enough to lock up a process too long because a Thread may write to
the log when the process is trying to checkpoint for eg garbage collection.

• Fibers are always enabled. Removed configure option. (Brian Shirai)
• Removed Fiber custom stack switching. (Brian Shirai)
• A bit of Enumerator cleanup. (Brian Shirai)
• Specs for Thread#thread_variable{s, _get, _set, _key?}. (Brian Shirai)
• Added new Fiber implementation. (Brian Shirai)
  Each Fiber is composed of a native machine thread and set of synchronization
  primitives that effectively serializes the concurrency of the associated
  Thread instance and all Fiber peers (Fibers associated with the same Thread).
• Fixed Thread, Fiber locals. (Brian Shirai)
• Fixed propagating exceptions from fibers to the thread. (Brian Shirai)
• Fixed VM tests. (Brian Shirai)
• Simplify Fiber. (Brian Shirai)
• Fixed interrupting Thread with active Fiber. (Brian Shirai)
• A couple Thread, Fiber spec fixes. (Brian Shirai)
• Fixed passing arguments with Fiber.yield, Fiber#resume. (Brian Shirai)
• Reference current Fiber from Thread. (Brian Shirai)
• Fixed Thread#kill. (Brian Shirai)
• Clean up Fiber debris in VariableScope. (Brian Shirai)
• Fixed Thread#raise. (Brian Shirai)
• Clean up after some Fiber specs. (Brian Shirai)
• Added specs for Thread.fiber_list, Fiber.list, Fiber.main. (Brian Shirai)
• Added Thread.fiber_list, Fiber.list, Fiber.main. (Brian Shirai)
• Cleaned up spec tags for Thread, Fiber. (Brian Shirai)
• Store all locked objects in the Thread. (Brian Shirai)
• Reworked Fiber transitions. (Brian Shirai)
• Added Fiber#transfer spec, cleaned up Fiber#resume spec. (Brian Shirai)
• Fixed passing Fiber values. (Brian Shirai)
• Fixed Enumerator::Generator naming. (Brian Shirai)
• Only process Threads for locked objects. (Brian Shirai)
  There is still more cruft here to clean up.
• Fixed race checking fiber status. (Brian Shirai)
• Label Threads, Fibers, & MachineThreads in VM backtrace. (Brian Shirai)
• Fixed race in Thread.fiber_list spec. (Brian Shirai)
• Fixed race starting Fiber. (Brian Shirai)
• Fixed deadlock with managed phase and Fiber switching. (Brian Shirai)
• Block GC while creating Thread/Fiber structures. (Brian Shirai)

Version 3.40 (2016-06-12)

• Fixed concurrent process access to FileLogger. (Brian Shirai)
• Fixed compressing rotated logs. (Brian Shirai)
• Added regex configuration type and converted log filters. (Brian Shirai)
• Fixed const type. (Brian Shirai)
• Fixed -Xhelp variable type for Regexp. (Brian Shirai)
• Fixed deadlock adding finalizer. (Brian Shirai)
• Updated gems. (Brian Shirai)

Version 3.39 (2016-06-09)

• Added config option to filter source location. (Brian Shirai)
  Threads, Fibers, and subprocess commands, like spawn, fork, backtick and exec,
  log the source code location that invoked them. This location can now be
  filtered based on a configuration option.

The default is to filter the Ruby core library location. But when a utility
library is used, the location will always show the same utility library source
code. Adding a custom filter that excludes the library locations allows the
client source code location to be logged instead.

The following configuration options designate the source filters:

-Xmachine.thread.log.filter (default '^core/.$')
-Xmachine.fiber.log.filter (default '^core/.$')
-Xsystem.log.filter (default '^core/.*$')

The filter must match the entire source code line to exclude it. The first
non-matching source code line will be logged.

The filter expression uses the C++ regex facility and ECMAScript syntax.

• Added logging for config options. (Brian Shirai)
  The configuration options can come from five different locations:
  1. The file $HOME/.rbxconfig if $HOME is defined.
  2. The file .rbxconfig in the current working directory.
  3. The RBXOPT environment variable.
  4. The command line options.
  5. The default values.

This may cause ambiguity about what configuration options are in effect when a
process runs. The -Xsystem.log.config (default: yes) option prints the
configuration options that were parsed to the log file.

Version 3.38 (2016-06-09)

• Fixed explicit mutex unlock straggler. (Brian Shirai)
  This got left in when I was trying to get the mutex to properly unlock across
  fork() calls in both parent and child process.

• Fixed specs to properly wait for child processes. (Brian Shirai)

• Fixed waiting for failed spawn, backtick children. (Brian Shirai)

• Added config for logging Thread, Fiber events. (Brian Shirai)
  The follow configuration options control whether to log lifetime events (eg create, exit)
  for Thread and Fiber, and whether to log finalizer activity.

  -Xmachine.thread.log.lifetime (default true)
  -Xmachine.thread.log.finalizer (default false)
  -Xmachine.fiber.log.lifetime (default true)
  -Xmachine.fiber.log.finalizer (default false)

• Recreate logger instance after fork(). (Brian Shirai)
  During a fork() event, it's possible for another thread to be writing to the
  logger and the logger mutex to be in an unknown state in the child. So, we
  recreate the logger post fork() in the child. This also simplifies ensuring
  that eg the PID stamp is correct.

• Added config option for logging process lifetime events. (Brian Shirai)
  During the process lifetime, various events like spawn, fork, exec, etc may be
  logged. The following option allows turning off those events;

  -Xsystem.log.lifetime

This may be useful to filter information from the logs when running
particularly noisy processes that do a lot of subprocess activity. The default
state, however, is to log these events because they can be extremely helpful
when debugging issue.

• Fixed finalizer deadlock. (Brian Shirai)
  The finalizer thread is now running as unmanaged phase while doing list
  manipulations and the transition to managed phase is done by the individual
  finalizer object depending on whether it is a managed or unmanaged finalizer.
• Initialize logger lock. (Brian Shirai)
• Don't block during spawn or backtick. (Brian Shirai)
• Preserve ThreadNexus phase_flag state. (Brian Shirai)
  The ThreadNexus::phase_flag is part of the thread synchronization mechanism
  and additionally used to put the system into a sort of 'singled-threaded mode'
  that can run arbitrary code. In order to preserve this, we have to know that
  when we 'acquired' the lock whether the lock was already held by us. If it
  was, we don't want to release it.
• Don't block when locking finalizer list mutex. (Brian Shirai)
• Use spinlock_mutex for InlineCache updates. (Brian Shirai)

Version 3.37 (2016-06-06)

• Enable ccache for faster builds (#3660) (Omer Katz)
• Enable ccache for faster builds.
• Print cache statistics and install with 2 jobs
• Enable bundler cache as well.
• Install ccache on OSX as well.
• Export CC and CXX manually in order to use ccache.
• Cache bundler manually since in C++ environments travis doesn't recognise the bundler directive.
• Workaround ccache bug with clang

See http://petereisentraut.blogspot.co.il/2011/05/ccache-and-clang.html

• export different ccache path for OSX.
• Fix syntax error.
• Use ruby 2.2.0.
• Another fix for ccache with clang and install ruby 2.2.0 from rvm.
• Print cache statistics for debugging.
• Improved logger locking. (Brian Shirai)
  The logger is a low-level mechanism that should not depend on sophisticated
  Rubinius code, but still needs synchronization to produce intelligible results
  when any thread at any time may log some activity.

We switch to a custom spinlock mutex implemented with C++11 features
(unfortunate that C++11 didn't think it was essential to provide such a mutex
but it's trivial to create).

Since the process may log something at any time from any thread, running
managed or unmanaged, even while fork'ing, we always reset the state of the
lock after fork().

• Don't copy dead Fiber stack to heap. (Brian Shirai)
  Either status_ is wrong and the Fiber isn't dead, in which case we run the risk of
  losing its stack, or we should ignore the copy_to_heap.

• Use sequentially consistent memory order for spinlock_mutex. (Brian Shirai)

• Cleaned up passing STATE to logger. (Brian Shirai)
  The logging facility is intentially highly decoupled from Rubinius so that it
  can be used through the entire process lifetime without depending on
  structures that need to be constructed and destructed. The STATE dependency
  was added to try to synchronize logging across fork() calls, but that wasn't a
  good architecture choice.

• Only reset the logger lock in the fork child. (Brian Shirai)

• Test if Travis failure is Fiber-related. (Brian Shirai)

• Added debug logging for Data, Fiber finalize. (Brian Shirai)

• Revert "Test if Travis failure is Fiber-related." (Brian Shirai)
  This reverts commit 9f644d75e2662624f8787fa0a3916b10a80c283d.

• Switched Data, Fiber to normal logging. (Brian Shirai)

• Another Travis test. (Brian Shirai)

• Improved logging message format. (Brian Shirai)
  Generally, log messages for non-exceptional events should follow the format:

  object: operation: details

For example: 'process: fork: child: <PID, ...'

For exceptional events, the format should be:

: object: details

• Added Thread#source, improved Thread#inspect. (Brian Shirai)
• Improved Fiber attributes and logging. (Brian Shirai)
  Fiber#source returns the non-core library source code line where the Fiber
  was created. Fiber#thread_name returns the name of the Thread that created the
  Fiber. Fiber#fiber_id returns a unique ID for the Fiber instance.

The Rubinius log includes entries for the Fiber create and exit events.

• Hold finalizer lock when signaling. (Brian Shirai)
• Increase Enumerator Fiber stack size. (Brian Shirai)
• Revert "Enable ccache for faster builds (#3660)" (Brian Shirai)
  This reverts commit 06a4629e01a42e3712e8333a4353a87faee500fa.
• Revert "Another Travis test." (Brian Shirai)
  This reverts commit a0a7287d1bee69013edfede1e9783d06e55963d2.

Version 3.36 (2016-06-05)

• Moved CallSite finalization to CompiledCode. (Brian Shirai)
• Ensure GC.start is synchronized. (Brian Shirai)
• Re-added Rubinius define_finalizer extension. (Brian Shirai)
• Fixed removing a finalizer. (Brian Shirai)

Version 3.35 (2016-06-04)

• Added ObjectSpace.define_finalizer specs. (Brian Shirai)
• Reworked running finalizers. (Brian Shirai)
• add reminder to push after tagging new release (Chuck Remes)

Version 3.34 (2016-06-02)

• Adjust stack size in Thread, Fiber specs. (Brian Shirai)
• Reworked ThreadNexus. (Brian Shirai)
  While halting the process, all threads except for the thread processing the
  halt request must be paused. Additionally, any threads transitioning from
  sleep or from unmanaged code must also pause.

Also, at every moment that a thread is possibly running managed code, it must
have the proper thread phase state, or it could modify code concurrently with
the garbage collector in a way that leads to corrupt objects or references
that are no longer valid.

• Slightly relax memory ordering for ThreadNexus::Phase. (Brian Shirai)
  This ordering is slightly relaxed from the default std::memory_order_seq_cst
  but may not have any impact on typical x86 hardware.
• Eliminate extra halt lock. (Brian Shirai)
  Since the phase_lock is recursive, and we always need to acquire the lock
  when transitioning to managed phase, the halting thread can just holt this
  lock unconditionally while halting. That thread will then be able to run
  stop-the-world garbage collection with the normal process which acquires and
  releases the phase lock. This eliminates the second halt lock.
• Convert ThreadNexus stop flag to atomic. (Brian Shirai)
• Convert ThreadNexus threads lock to C++11. (Brian Shirai)
• Fixed Dockerfile update script. (Brian Shirai)
• Replaced ThreadNexus recursive mutex with atomic flag. (Brian Shirai)
  Recursive mutex under C++11 plays very badly with fork(), apparently. But we
  must be able to do stuff like run garbage collection and Ruby code during
  shutdown because we process Ruby finalizers, which may run pretty much
  arbitrary Ruby code.

Hence, we need a mechanism to hold all threads except the halting thread but
also allow that thread to run arbitrary managed code, one function of which is
running the garbage collection code, which needs to stop the world for some
things, which relies on the ThreadNexus synchronization code, and on and on.

So we use an atomic variable that holds the thread's id and if the variable
already has a thread's id, that thread is the one who set it, and hence can
proceed confident that no other thread is running.

• Properly wait for failed process status for #spawn, #. (Brian Shirai) If #spawn or # fail, the PID of the subprocess isn't passed back, so it
  cannot be properly reaped by the OS with a Process.waitpid call. So we have to
  do that in the VM.
• Add deprecation notice for 32-bit and GCC. (Brian Shirai)
• Reset logger lock on fork. (Brian Shirai)
  When calling fork(), we hold all running threads to keep them in known states
  across the call to fork().

In the child process, the only thread that persists is the thread that called
fork(). If another thread was about to write to the logger and got suspended
before unlocking the logger mutex, the mutex will be locked in the child and
will block any other thread that tries to lock it. The thread in the parent
that would have unlocked the lock won't exist in the child.

An alternative would be for the thread calling fork to hold all the relevant
locks before calling fork(), and then unlocking them all after fork() in the
child. Functionally, that wouldn't be any different and would impose
additional costs before the fork().

All code needs to be audited for any locks that could be held across a fork()
call and all those should be re-init'd in the child.

• Improved logging of subprocess creation. (Brian Shirai)
  The log will now reliably include the non-core method that invoked the spawn,
  backtick, fork, or exec command. This will point to the application code or
  rubygems code, rather than the Rubinius core library. The location in the app
  code is much more useful typically than the location in the Rubinius core
  library code.

Version 3.33 (2016-05-23)

• Allow per-Thread, per-Fiber stack sizing. (Brian Shirai)

Thread.new, Thread.start, Thread.fork, and Fiber.new all take an optional
keyword argument of the form: 'stack_size: Fixnum', where Fixnum includes
objects that respond to #to_int. The keyword argument, if present, sets the
size of the Thread's or Fiber's stack size. If the argument is not present or
is zero, the default stack size, configured with -Xmachine.thread.stack_size
and -Xmachine.fiber.stack_size are used instead.

Added configuration for machine.thread.stack_size to set the default size of
Thread stacks. Also moved fiber.stack_size configuration under machine
section.

Also added configuration for machine.stack_cushion to set the size in bytes of
the cushion to leave at the stack end when checking for stack usage. This is
necessary because we check the stack usage before calling a method. The method
may use quite a bit of stack but we can't know this beforehand (hand-wavy
"can't" here). If we are near the end but not yet at the end, we could easily
exhaust the stack after calling the method and then segfault.

• Fixed substitution regexp for versioned gcc/g++/clang/clang++. (Brian Shirai)
• Improved -Xhelp rendering. (Brian Shirai)
• Updated help output and cleaned up some deprecated scripts. (Brian Shirai)

Version 3.32 (2016-05-23)

• Fixed substituting RbConfig::CONFIG for cc, c++, cpp. (Brian Shirai)
• Use local symlinks to provide cc, c++ on PATH. (Brian Shirai)
• Build debug C-ext's if Rubinius is a debug build. (Brian Shirai)
• Archive runtime/core every successful Travis build. (Brian Shirai)
• Some configuration cleanup. (Brian Shirai)
• Added new JIT thread. (Brian Shirai)
• Renamed InternalThread to MachineThread. (Brian Shirai)
  This naming is consistent with the refactorings toward Machine being the main
  entity for executing managed code and properly contrasts with future
  refactoring to make ManagedThread the counterpart for managed code execution.
• Start to rework the last remnants of the legacy JIT. (Brian Shirai)
• Fixed stack depth checking with Fiber. (Brian Shirai)
• Added Fiber created, destroyed metrics. (Brian Shirai)

Version 3.31 (2016-05-16)

• Removed rbxti. (Brian Shirai)

• Removed instrumenting profiler. (Brian Shirai)

• Fixed merge from master. (Brian Shirai)

• Removed Ubuntu 12.04 from binary builds. (Brian Shirai)

• Updated profiler gems versions. (Brian Shirai)

• Updated to Bundler 1.12.3. (Brian Shirai)

• Simply track MachineCode execution. (Brian Shirai)

• Removed remnants of rbxti. (Brian Shirai)

• Removed VMJIT, added profile interval to checkpoint. (Brian Shirai)

• Added simple, per-thread, random interval sampling. (Brian Shirai)
  This is mostly a temporary experiment that will likely be replaced with a
  calling-context tree or similar structure and a separate profiler thread.

• Added profile metrics. (Brian Shirai)

• Don't block GC on profiler interval. (Brian Shirai)

• Added more profiler functionality. (Brian Shirai)
  Use -Xsystem.profiler.target= to set the output path for the profiler
  report. The path can optionally contain the text $PID where desired and the
  process ID will be substituted. Quoting the option may be necessary to prevent
  the shell from expanding $PID prematurely. For example:

  rbx -Xsystem.profiler.target='path/to/profiler_report-$PID.txt'

The fully qualified name is implemented yet because it requires an additional
data structure to properly track the components, so only the bare method name
is displayed.

• Added config for enabling profiler in subprocesses. (Brian Shirai)
• Short circuit earlier if code is already tracked by profiler. (Brian Shirai)
• Fixed profile output to use full code description. (Brian Shirai)
• Fixed VM.backtrace API. (Brian Shirai)
  Code in the wild is using the old version of this, so we'll support it until
  we can effectively update old users.
• Try yet again to secure Gitter channel info. (Brian Shirai)
• Fixed VM.backtrace. (Brian Shirai)
• Added profiler report interval. (Brian Shirai)
• Cleanup up JSON generation in diagnostics. (Brian Shirai)
• Shuffled Profiler code. (Brian Shirai)
• Added JSON output for profiler via diagnostics. (Brian Shirai)

Version 3.30 (2016-05-06)

• 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)
• Set ENV in Docker images to UTF-8. (Brian Shirai)
• Fix new_spec.rb typo. (Red54)
• Use keyword args in IO::{read,write}_nonblock instead of hash handling (Ahmad Sherif)
• 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)
• Begin support for LLVM 3.6+. (Brian Shirai)
• 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)
• 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.
• A fresh start... (Brian Shirai)
• Cleaned up more JIT code. (Brian Shirai)
• Added include for RapidJSON. (Brian Shirai)
• Added RapidJSON. (Brian Shirai)
  https://github.com/miloyip/rapidjson c02d52ad56595dc70b38daf46b5f315d3a7115fa
• Added -Xsystem.diagnostics.target. (Brian Shirai)
  This specifies the location to send diagnostics data.
• Removed SystemDiagnostics object. (Brian Shirai)
  Instead of a single data object that collects all system diagnostics, this is
  the first step of using a single mechanism to emit diagnostics from a variety
  of system components, without coupling them.
• Added Diagnostics thread. (Brian Shirai)
• Fixed setting internal thread size. (Brian Shirai)
  On FreeBSD, setting the stack to 4096 bytes for threads like the Console
  Listener was not sufficient. This resulted in a SEGV while booting Rubinius,
  which happens before the signal handler has been set up, so nothing is shown
  in the logs. This also causes Rubinius to abort while trying to build
  Melbourne, leaving Rubinius in a very difficult to debug configuration.
• Added diagnostics emitter. (Brian Shirai)
• Specs for Proc#arity. The current specs cover lambdas twice. (Nathan Currier)
• Fix Proc#arity. (Nathan Currier)
• Cleaned up old Diagnostics logging. (Brian Shirai)
• Create some diagnostics reporting indirection. (Brian Shirai)
• Updated gems_list.txt. (Brian Shirai)
• A bit more diagnostics cleanup. (Brian Shirai)
• Cast cast cast your bits gently for GCC. Closes #3652. (Brian Shirai)
• Leading gcc carefully by the hand. (Brian Shirai)
• Ssssssssssize_t GCC. (Brian Shirai)
• Fixed syntax error in .travis.yml. (Brian Shirai)
• Updated version of coverage gems. (Brian Shirai)

Version 3.29 (2016-04-30)

• Added CallSite#reset. (Brian Shirai)
  This will enable resetting all the CallSites in a process to a known state to
  be able to eg using CallSite data for computing code coverage.
• Added missing CallSite#reset spec file. (Brian Shirai)
• Spec for a block local assigned in a nested scope before initialization. (Nathan Currier)
• Spec for not capturing a local variable in place of a block argument. (Nathan Currier)
• Reworked checking stack overflow. (Brian Shirai)
• Updated rubinius-ast version. (Brian Shirai)
• Added header file for getrlimit(). (Brian Shirai)
• Refactor zsuper instruction to handle arguments correctly (Ahmad Sherif)
  Fixes #3643
• Add a spec for zsuper passing splat and keyword arguments together (Ahmad Sherif)
• Cleaned up checking for interrupted thread. (Brian Shirai)