Release 4.10

Version 4.10 (2019-12-29)

• Implement Fixnum#+, Fixnum#- with instructions. (Brian Shirai)
• Added register insns for binary operands. (Brian Shirai)
• Replaced more Fixnum primitives with bytecode. (Brian Shirai)
• Fixed loading IRB files. (Brian Shirai)

Release 4.9

Version 4.9 (2019-12-28)

• Fixed AtomicReference#compare_and_set for tagged nil. Closes #3827. (Brian Shirai)

Release 4.8

Version 4.8 (2019-12-14)

• Fetch stdlib cache. (Brian Shirai)
  This is the first step of removing rubygems dependency to build
  Rubinius.

• Fetch codetools cache. (Brian Shirai)

• Eliminate bootstrap gems. (Brian Shirai)
  Another step in removing Ruby as a build dependency.

• Removed more cruft. (Brian Shirai)

• Added codetools, stdlib cache to package. (Brian Shirai)

Release 4.7

Version 4.7 (2019-12-01)

• Ruby 2.5: Implement String#delete_prefix (Christian Bruckmayer)
  and String#delete_prefix!

See https://bugs.ruby-lang.org/issues/12694

• Add specs for String#delete_prefix (Christian Bruckmayer)
  https://bugs.ruby-lang.org/issues/12694

Copy & paste from Ruby specs

• Note about openssl (Jon Rowe)
• Note about openssl (Jon Rowe)
• Fixed some JIT issues building with LLVM 9.0. (Brian Shirai)
• Renamed MachineJIT to MachineCompiler. (Brian Shirai)
• Added C-API for updating openssl C-ext. (Brian Shirai)

Release 4.6

Version 4.6 (2019-09-07)

• Add a stub of NetBSD support (Kamil Rytarowski)

• Support Ruby version 10.0. 🦄 🌈 🐈 (Brian Shirai)

• Teach the specs about the future. 🎉 (Brian Shirai)

• Added Regexp#match?. (Brian Shirai)

• Implement Array#append and Array#prepend (Christian Bruckmayer)
  Introduced in Ruby 2.5
  See https://bugs.ruby-lang.org/issues/12746

• Implement specs for Array#prepend and Array#append (Christian Bruckmayer)
  See https://bugs.ruby-lang.org/issues/12746

• Removed some obsolete ruby_version_is guards. (Brian Shirai)
  The Rubinius specs only specify the currently supported behavior so no
  version guards are necessary.

• Support 'configue && make install'. (Brian Shirai)

Release 4.5

Version 4.5 (2019-07-13)

• Ignore return value of ftruncate. (Brian Shirai)

Release 4.4

Version 4.4 (2019-07-12)

• Fixed storing literals in new interpreter. (Brian Shirai)
• Fixed unwind in new interpreter. (Brian Shirai)
• Fixed break in new interpreter. (Brian Shirai)
• Temporary fix for IP to line in new interpreter. (Brian Shirai)
• Enable experimental interpreter for CI. (Brian Shirai)
• Updated gems_list.txt. (Brian Shirai)
• Added stubs for remaining instruction specs. (Brian Shirai)
• Retire insns/interp machine tests. (Brian Shirai)
  Since starting on the new interpreter and instruction set, WebAssembly has
  been officially adopted by all major browser vendors and has become a
  legitimate implementation target.

To facilitate transitioning to multiple VM targets, the instruction set needs
to be specified in a format that is target-independent. The spec/instructions
specs are a reasonable intermediate target, but are also a step towards a
language-neutral textual asm format and assembler that will provide complete
targe independence.

• Removed old interpreter. (Brian Shirai)

• fixed zsuper instruction for keyword arguments and arguments placeholder (Andrew Aladjev)

• improved specs for super arguments (Andrew Aladjev)

• Added boot time stats. (Brian Shirai)

• Added argument to ret instruction. (Brian Shirai)
  This sets space to add return value type caching and nil values tagged
  to method ids.

• Improved CodeDB loading metrics. (Brian Shirai)

• Updated daedalus. (Brian Shirai)
  This will generate the instruction and interpreter files with debug info.

• Removed unwind label. (Brian Shirai)
  The unwind label was an attempt to move the unwind state from runtime to
  compile time. Due to nested unwind blocks, this needs more work.

• Updated libsodium to 1.0.14. (Brian Shirai)

• Added start of CompiledCode#code_id. (Brian Shirai)
  This id is a cryptographic hash of the CompiledCode object that can be
  used by the CodeDB to uniquely identify this object. The code_id can be
  used to lazily load CompiledCode objects when they are going to be run.

• Added CompiledCode#stamp_id. (Brian Shirai)

• Updated rubinius-bridge gem. (Brian Shirai)
  This adds CompiledCode#code_id when compiling under MRI.

• Updated gems. (Brian Shirai)

• Switch to code_id for runtime/core. (Brian Shirai)

• Lazily load core methods from CodeDB. (Brian Shirai)

• Cleaned JIT gen cruft. (Brian Shirai)

• Add rubygems and bytecode compiler to CodeDB. (Brian Shirai)

• Updated AST gem. (Brian Shirai)

• More work on CodeDB being the general compilation cache. (Brian Shirai)

• Load files from CodeDB if they exist. (Brian Shirai)

• Load compiler from CodeDB. (Brian Shirai)

• Add lambda version of logger functions. (Brian Shirai)
  This enables deferring potentially costly operations because of
  call-by-value that would not be needed if the log level is below the
  level of the logging call.

• Add logging to CodeDB. (Brian Shirai)

• Slightly better loading from CodeDB. (Brian Shirai)

• Start migrating from runtime/ to CodeDB. (Brian Shirai)

• Build and use CodeDB for library code. (Brian Shirai)

• Remove library from default $LOAD_PATH. (Brian Shirai)

• Add missing push_file insn files. (Brian Shirai)

• Copy non-Ruby files to CodeDB source. (Brian Shirai)
  This is mostly for RubyGems but it's conceivable other library code may
  have supporting files.

• Improved build C-exts for Ruby library. (Brian Shirai)

• Don't overwrite CodeDB cache with nothing. (Brian Shirai)

• Remove Converter path caching cruft. (Brian Shirai)
  The cache mechanism was quite blunt and was not even in use. It can be
  replaced with something that works better, but no reason to have the
  unused code in the repo.

• Add deprecations for Rubinius::{RUNTIME, CORE}_PATH. (Brian Shirai)

• Don't segv the process if CodeDB is missing, corrupt. (Brian Shirai)

• Added archdir, removed thens. (Brian Shirai)

• Use fittest fixture in Enumerable#each_entry spec (Kenichi Kamiya)

• Fix Enumerable#each_entry with no yield arguments (Kenichi Kamiya)

• Remove an outdated tag (Kenichi Kamiya)

1. This spec was tagged in #3581.
2. Fixed via 8b7d91b

• Add a spec to ensure Enumerator#peek_values identity (Kenichi Kamiya)
• Fix Enumerator#peek_values identity for multiple arguments (Kenichi Kamiya)
• Add a spec for Enumerator#peek with special yielding (Kenichi Kamiya)
• Tagged a failling spec (Kenichi Kamiya)
• Added more measurement diagnostics. (Brian Shirai)
• Add profiler minimum sample config for reporting. (Brian Shirai)
• Fix inline cache. Closes #3783. (Brian Shirai)
• Add seq number & nodename to diagnostics JSON. (Brian Shirai)
• Use better supported time rendering. (Brian Shirai)
• Add thread name & ID to diagnostics. (Brian Shirai)
• Add new object header. (Brian Shirai)
  The new header and extended header provide several capabilities:

1. All header assignments are concurrency safe (ie devoid of
   pathological data races in read+update+write and write+write scenarios);
2. Enables two kinds of managed objects: object-oriented ones (ie
   instances of a class) and data-oriented ones (ie instances of a type);
3. Allows for asserting the "ownership" of managed objects based on the
   thread_id signature;
4. Allows for moving objects by designating the location of an object as
   a pointer "forwarding" to the new location of the object;
5. Allows for pinning a managed object so that its location cannot be
   changed;
6. Allows for "visiting" an object by tracing the objects it references
   independently from the garbage collector's tracing of objects so that
   a subgraph of the object graph can be traced in a way that
   interleaves with the activity of the garbage collector marking
   visited objects;
7. Allows for retaining objects based on a count of references to that
   object instead of only by reachability (ie the transitive closure
   over the object graph);
8. Allows for extending the header to consume more than a single machine
   word (assumes 64-bit architecture);
9. Allows for assigning a unique ID to an object that is bounded by the
   range of a Fixnum value by using an extended header;
10. Enables storing a fixed-point memory address that indirectly
    references the managed object to provide opaque object references
    for the C-API;
11. Allows for locking an object by the thread owning the object, or
    expanding the locking mechanism to a system-dependent mutex;
12. Enables type-specific bits of information in the header.

• Add object_id and C-API handle to new header. (Brian Shirai)
• Replaced C macro approach to MemoryHeader. (Brian Shirai)
• Added more MemoryHeader operations. (Brian Shirai)
• Fixed variable reference. (Brian Shirai)
• Fixed setting referenced count. (Brian Shirai)
• Fixed MemoryHeader::get_object_id. (Brian Shirai)
• Fixed MemoryHeader::get_handle. (Brian Shirai)
• Added MemoryHeader locking. (Brian Shirai)
• Try to use LLVM 5.0 on Travis Linux. (Brian Shirai)
• Try forcing libc++ on Travis. (Brian Shirai)
• Try installing libc++ on Travis. (Brian Shirai)
• Of course I'd want libc++ without the ABI FFS. (Brian Shirai)
• Fixed lock test. (Brian Shirai)
• temp fix for cleaning up after gems with C-exts (Chuck Remes)
• Remove legacy test-unit and preinstall test-unit gem. (Brian Shirai)
• Use LLVM 5.0 for building binaries for Linux. (Brian Shirai)
• Revert to non-libc++. (Brian Shirai)
• Remove memory header lock test temporarily. (Brian Shirai)
• Fixed disabling VM test. (Brian Shirai)
• Switch to new MemoryHeader. (Brian Shirai)
• Add mutex header. (Brian Shirai)
• Cache Fiber's last value. (Brian Shirai)
  In the Rubinius implementation, every Fiber is actually a separate
  pthread that is coordinated by the owning Thread object. Passing values
  from and to the Fiber is mediated by the Thread.

Behind both a Thread and a Fiber is a data structure for various
information that supports the functioning of the Thread or Fiber. When
the underlying pthread function terminates, it sets sets that structure
to a "zombie" status so that its resources can eventually be released.
In doing so, it removes the reference to the Thread object associated
with the Fiber, so we need to cache the last value in the Fiber itself.

• Fix isinf/isnan namespace issue on GNU stdlib. (Brian Shirai)
• In README and README.md, refer to rubinius-book/getting_rubinius.html for more detailed information about building from source. (Jack Desert)
• Don't set object reference to NULL. (Brian Shirai)
• Hide some more core library methods. (Brian Shirai)
• Reset logger lock after fork(). (Brian Shirai)
• Build Travis macOS binary with llvm6. (Brian Shirai)
• Update rbconfig to use CFLAGS includes. Related to #3671. (Brian Shirai)
  See also eventmachine/eventmachine#722

Thanks to @sodabrew and @saizai for figuring out what was happening.

• Populate INCFLAGS rather than CFLAGS at configure time (Aaron Stone)

• Update configure to use incflags. (Brian Shirai)

• Update rbconfig to use incflags. (Brian Shirai)

• Add NULL check to reference_p predicate. (Brian Shirai)

• Load paths with trailing separator. Fixes #3797. (Brian Shirai)

• Align frozen object's error message with MRI. (Jun Aruga)

• Normalize RUBY_T_xxx definitions with MRI. (Brian Shirai)
  Taken from github.com/ruby/ruby commit 4b1fbbe92a758416294c3f336bb8e22bab3f1ff0

• Fixed marking finalizer of ManagedFinalizer. (Brian Shirai)

• Replace Mac OS X with macOS (Yee)

• Replace OSX with macOS (Yee)

• Introduce start of new checkpoint mechanism. (Brian Shirai)
  When the THCA attempts to allocate a new region, it will use try_lock
  and if acquiring the mutex fails, it will check if collection is pending
  and if so, set the checkpoint flag.

• Verify goto_past bytecode properly. (Brian Shirai)

• Use goto_past. (Brian Shirai)

• Add some JIT config options. (Brian Shirai)

• Start new JIT work. (Brian Shirai)
  The new JIT will do the majority of non-machine-code specific work ...

Release 4.3

Version 4.3 (2019-06-23)

• Add specs and verification for new instructions. (Brian Shirai)

• Add more support for tagged nil. (Brian Shirai)
  And fixed other stuff.

• Fixed more locking issues. (Brian Shirai)

• Added push_tagged_nil instruction. (Brian Shirai)

• Fix nil checks. (Brian Shirai)

• More fixed nil checks. (Brian Shirai)

• Tag nil on return if untagged. (Brian Shirai)
  When nil values are created outside the instruction set (managed code),
  for example, in the C-API, the untagged nil value will be tagged with
  the code ID when the value is returned to managed code.

• Clean up some MemoryHeader ToDos. (Brian Shirai)

• Better exception message for NoMethodError on nil. (Brian Shirai)
  The current type coercion protocol, which is modeled on MRI C functions,
  calls and rescues many NoMethodError on nil exceptions, so this is
  optionally enabled until those mechanisms can be improved.

• Added exception logging. (Brian Shirai)
  Initially, this logs exceptions raised from managed code.

Release 4.2

Version 4.2 (2019-06-11)

• Some write barrier cleanup. (Brian Shirai)

• Add --log-concurrent-update and --raise-concurrent-update. (Brian Shirai)
  The first compile-time option will log (level warn) when an object
  created by one thread is updated by a different thread. The second
  compile-time option will raise an exception. The options can be used
  together or separately.

• Added ConcurrentUpdateError. (Brian Shirai)
  Also standardized exception handling into MachineException::guard.

• Added '-Xmachine.concurrent.update.{log, raise}' options. (Brian Shirai)

• Pass Object** to MemoryVisitor functions. (Brian Shirai)
  This will enable Object#become and other useful capabilities.

• Hold logger lock during fork(). (Brian Shirai)
  A thread that does not stop for fork() because it's not mutating memory
  may still use the logger, which causes the logger lock to be in an
  indeterminate state across a fork() call, possibly resulting in the lock
  being locked in the child. By explicitly holding the lock, we can safely
  unlock it in the child and the lock is in a determinate state.

• Added Object#become. (Brian Shirai)
  This is not complete yet, but works for variables.

• Fixed write_barrier. (Brian Shirai)

• Make MemoryVisitor recursive. (Brian Shirai)

• Make Collector recursive. (Brian Shirai)

• Rework location of checkpoints. (Brian Shirai)

• Remove call frame return value. (Brian Shirai)
  This was added to save a transient root while the collector ran, but
  it's not needed with the new method of checkpointing in the ret
  instruction and loop back branches.

• Added Thread-local Heap Container & Allocator. (Brian Shirai)

• Allocate using THCA. (Brian Shirai)

• Rework checkpoint. (Brian Shirai)

• Limit size of object allocated by THCA. (Brian Shirai)

• Clean up timestamp files generated by Makefile (ljulliar)

• Simplify check_stop. (Brian Shirai)
  With main collection always running on a dedicated thread, there is no
  need for each thread to check whether they may have to run the collector
  when stop is set.

• Add function table to LexicalScope. (Brian Shirai)

• Define functions. (Brian Shirai)

• Rework checking stack overrun. (Brian Shirai)

• Added r_load_{0,1,nil,false,true} and goto_{past,future. (Brian Shirai)
  The goto_past instruction is a backward branch, which allows explicitly
  enabling or disabling looping constructs.

• Added call instruction variants. (Brian Shirai)
  The call_send instruction looks for a function and falls back to
  dispatching a method. This will replace the send_stack instruction that
  is used for implicit self sends in code that could have functions.

The call instruction only looks for a function.

The call_0 instruction is for 0-arity functions.

The send_vcall instruction will be modified to look for functions.

• Fixed a couple deadlocks. (Brian Shirai)

Release 4.1

Version 4.1 (2019-05-27)

• Preserve C-API handle references for several GC cycles. (Brian Shirai)
  In the MRI C-API, there are no explicit 'retain', 'release' operations.
  When a managed object is created in Rubinius, a static (ie non-moving)
  pointer is returned. The pointer is a MemoryHandle object that
  references the managed memory object.

When a GC cycle occurs, if nothing has marked the managed memory object
as reachable, the MemoryHeader object would be released and the managed
memory object's space reclaimed.

The problem with this is that any time the C-API calls back into the VM,
a GC cycle may occur. The following code illustrates this:

VALUE c_func(VALUE a, VALUE b) {
VALUE new_obj = c_api_create_obj(a, b);

/* Many C-API functions are implemented as wrappers for Ruby code,
 * so this call may result in a GC operation and 'new_obj' will not
 * be referenced anywhere, causing the GC to assume it is
 * unreachable, and therefore garbage.
 */
other_c_api_func(new_obj);

return new_obj;

}

To address this, we track how many GC cycles have occurred while the
object is not marked. To make this slighty more robust (ie not retain
true garbage for too long), we could use a flag that the MemoryHandle
has just been created and only retain it for several cycles if it has
just been created.

• Add ability to search mark stack for pointers. (Brian Shirai)

• Start moving to a dedicated collector thread. (Brian Shirai)

• Rename CollectorThread to Collector. (Brian Shirai)
  Also move GCInhibit from Memory to Collector::Inhibit.

• More Collector cleanup. (Brian Shirai)

• Invoke GC using a new mechanism. (Brian Shirai)
  Nothing about GC has changed, but the sequence to invoke it uses the new
  mechanism being built.

• Actually run the collector on the collector worker thread. (Brian Shirai)

• Move more GC to Collector. (Brian Shirai)

• GC cleanup round 1. (Brian Shirai)

• More moving to the Collector. (Brian Shirai)

• Introduce Heap, MainHeap, MemoryTracer. (Brian Shirai)

• Start replacing saw_object with trace_object. (Brian Shirai)

• Detangle some GC function names. (Brian Shirai)

• Move to new MemoryTracer. (Brian Shirai)

• Remove legacy GC code. (Brian Shirai)

• Fix resetting Immix allocator after collection. (Brian Shirai)

• Clean up a bit more old GC related code. (Brian Shirai)

• Removed Address. (Brian Shirai)
  The Address construct was interesting, but it obscured the memory
  address alignment and added another (incompatible with MemoryHeader,
  DataHeader, ObjectHeader) concept that complicated interacting with
  Immix when there is no reason for Immix to be special.

• Remove collect flag and directly request collection. (Brian Shirai)

• Move pinned capability to only third region. (Brian Shirai)

• Split MemoryHandles from References. (Brian Shirai)

• Pass address of object into collector. (Brian Shirai)