The Rubinius Language Platform
MPL-2.0 License
Bot releases are hidden (Show)
Published by brixen almost 9 years ago
Version 3.8 (2016-01-15)
Published by brixen almost 9 years ago
Version 3.7 (2016-01-13)
Published by brixen almost 9 years ago
Version 3.6 (2016-01-12)
Published by brixen almost 9 years ago
Version 3.5 (2016-01-10)
Published by brixen almost 9 years ago
Version 3.4 (2016-01-09)
Published by brixen almost 9 years ago
Version 3.3 (2016-01-08)
Published by brixen almost 9 years ago
Version 3.2 (2016-01-04)
Published by brixen almost 9 years ago
Version 3.1 (2016-01-04)
The main process thread (the one the OS creates when the process is first
created) now boots the system and spawns a thread to start running Ruby code.
The main thread goes on to process signals and halting the process. This is
the only thread that processes halt code.
When the process forks, a new thread is created to process signals and
halting. In the future, fork() and exec() will be disallowed on all internal
threads and only allowed on threads running Ruby code.
Process.exit
from the thread completesProcess.exit
in the main thread. That's not how actual threadsRubinius makes internal operaions thread safe but generally does not make any
thread safety guarantees for common Ruby objects like Array or Hash instances.
It's perfectly possible to "corrupt" an Array by concurrently modifying it
without synchronization.
ThreadGroup presents an interesting case, however, because it is arguably a
system structure. The API of ThreadGroup is minimal, consisting of these
methods: add, enclose, enclosed?, list.
Of these, only add presents a thread safety issue from the perspective of a
potentially "corrupted" structure (ie the list of Threads in the group). It's
possible for one Thread to enclose the group and another to get 'false' when
calling #enclosed? "after" the other Thread called #enclose. That's not a case
we are concerned with. The case of calling #add (which will implicitly also
remove the Thread from another group if it is a member) should probably be
thread safe.
For this reason, we add synchronization around adding (and removing) a Thread
from a ThreadGroup.
Float#negative?
to Float#signbit?
(Robin Dupret)Numeric#negative?
method. Rubinius implementsHowever, signbit
's behavior can't match MRI Float#negative?
's one
since the former operates on the sign while the latter operates on the
value (see http://git.io/vm1fg).
class.name
See https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/stat.2.html
and https://github.com/ruby/ruby/blob/fc7711ff17cde31aec0e2c1d29faca264b49da6b/file.c#L829 for reference.
The method is about 2 times slower than the MRI implementation though.
Benchmark: http://git.io/vmhpf.
Add some other cases for #super_method specs (Robin Dupret)
Based on commit ruby/ruby@b4981594.
Mark nil/true/false as frozen (Yorick Peterse)
Interesting enough MRI still lets you define methods on these objects
even when they're frozen. For example, this works just fine:
def nil.foo
end
nil.foo
Add a String#split spec with 0 limit (Kenichi Kamiya)
Fix String#split with 0 limit. Fixes #3474 (Kenichi Kamiya)
Fix Range#bsearch for matching end value in find-minimum mode (Kenichi Kamiya)
Fixes #3458
Add a C-API "rb_hash_clear" (Kenichi Kamiya)
Log class names for invalid ivars_ references (Yorick Peterse)
This makes it a bit easier to see what kind of objects we're dealing
with when this occurs.
Fixed typ in the OnStack class (Yorick Peterse)
Fix correction to documentation for OnStack class. (Joe Eli McIlvain)
Specify superclass
in respect to prepend
(Ben Lovell)
This was unspecified/recently merged to ruby/rubyspec. Rubinius does
the Right Thing ™️
Clean up log output of serial_debug/ic_debug (Yorick Peterse)
Output is now sent to STDERR (to make it easier to redirect) and the
actual debug messages have been trimmed a bit.
Expand $PID in Metrics filename. (Brian Shirai)
Contributing notes on version managers/releases (Yorick Peterse)
Changed "of the issue" to "if the issue" (Yorick Peterse)
Fixes to assist building Rubinius under Alpine Linux (with musl). (Nathan Sullivan)
Not 100% building yet, but these cover some outstanding issues
Remove converting to negative fd (Benny Klotz)
Convert a fd to -(fd + 1) if its a Fixnum seems wrong.
Negative fds's are mostly invalid.
add spec for Process.spawn redirecting STDERR to child STDOUT (Benny Klotz)
remove obsolete assignment (Benny Klotz)
change => to is (Benny Klotz)
allow nil,true,false to be modified when frozen (Chuck Remes)
Check if struct stat has nanosecond resolution. (Andre Richter)
Check for st_atim, st_mtim, st_ctim, etc. in struct stat (sys/stat.h)
Add nanosecond support for Stat::[amc]time (Andre Richter)
Spec: Check microsecond resolution for File#utime (Andre Richter)
Implement microsecond resolution for File#utime (Andre Richter)
File#utime: Don't check for usec resolution on Darwin (Andre Richter)
Add specs for unicode_normalize (Jason Yeo)
Add spec for unicode_normalize! (Jason Yeo)
Add specs for exceptions (Jason Yeo)
Add specs for unicode_normalized? (Jason Yeo)
Add a note about where I took the unicode examples (Jason Yeo)
Add tags for unicode_normalize (Jason Yeo)
Remove :each (Jason Yeo)
Wrap lines to < 80 chars (Jason Yeo)
Added MPL-2.0. (Brian Shirai)
Try adding Dockerfiles for ubuntu 14.04, 15.10. (Brian Shirai)
Clarify copyright entity for license. (Brian Shirai)
Simplify, just one Dockerfile for now. (Brian Shirai)
Revert "Simplify, just one Dockerfile for now." (Brian Shirai)
This reverts commit de7a8a1007d29700f4a1af8a0dac52de41f33f2c.
Imported https://github.com/rubinius/rubinius-docker/pull/1. (Brian Shirai)
Added whitespace to break up the steps and added gems/bin to PATH.
Add BSD text to license. (Brian Shirai)
Break up old/new license & clarify what we use (Yorick Peterse)
Published by brixen almost 9 years ago
Version 3.0 (2016-01-01)
Published by brixen almost 9 years ago
Version 2.71828182 (2015-12-28)
Published by brixen almost 9 years ago
Version 2.11 (2015-12-28)
Published by brixen almost 9 years ago
Version 2.10 (2015-12-26)
Published by brixen almost 9 years ago
Version 2.9 (2015-12-25)
¯(ツ)/¯
Published by brixen almost 9 years ago
Version 2.8 (2015-12-23)
Published by brixen almost 9 years ago
Version 2.6 (2015-12-06)
Published by brixen almost 9 years ago
Version 2.7 (2015-12-20)
Published by brixen over 9 years ago
Version 2.5.8 (2015-07-14)
News:
Array#flatten compatibility when calling #to_a on elements is improved.
Fixed checking the return value of malloc() in case allocation fails.
The C++ abort, bug, warn methods use the logger facility.
Internal locking is improved.
Rubinius::Metrics performance counters are now only counters and not gauges
because counters preserve their characteristics under sampling.
Parsing of configuration options containing a '.' is improved.
Rubinius::Metrics FileEmitter writes performance counters to a specified
file every -Xsystem.metrics.interval milliseconds.
BasicObject#equal? is used for Symbol#==.
The young generation garbage collector size and lifetime auto-tuning is
removed. The size can be set with -Xgc.young_bytes, which defaults to 40mb.
The lifetime can be set with -Xgc.young_lifetime, which defaults to 2.
Comparable#== uses a recursion guard instead of rescuing SystemStackError.
Marshal#load compatibility is improved for an instance of a Hash that has
been extended.
Configuration options are available for -Xsystem.log.limit,
-Xsystem.log.access and -Xsystem.log.archives. This provides native log
rotation by Rubinius that does not depend on signals. Use of signals for key
functionality in a runtime like Rubinius is problematic because the running
Ruby program could trap those signals and interfere with the system.
The option -Xsystem.log.limit sets a limit in bytes on the size of the log
file.
The option -Xsystem.log.archives sets a limit on the number of archives that
are retained. The active log file is zipped and the files are rotated up to
the limit, resulting in, for example, rbx-user.log, rbx-user.log.1.Z, etc.
The option -Xsystem.log.access sets the access permissions on the log file.
Rubinius::Diagnostics are added. The diagnostics provide state-oriented
logging, in contrast to the Rubinius::Metrics, which provide monotonic
counters on various aspects of work performed by the program. The
diagnostics are emitted in summary form to the log file at regular
intervals, but only if the values have updated since the last time they were
emitted, so they do not consume much log space.
Threads are immediately removed from the internal list of threads when the
thread function completes. The Thread object preserves all other state as
long as it is reachable in the object graph. The process memory for the
Thread is recovered by a finalizer function when the Thread object is no
longer reachable.
System halt is reworked to prevent race conditions on cleaning up resources
when the process is halting. The halt code is no longer run by any Ruby
thread executing, but instead is run on the dedicated thread that processes
signals.
Bundler is updated to 1.10.5.
Changelog:
Published by brixen over 9 years ago
Version 1.4.11 (2015-07-14)
News:
Configuration options are available for -Xsystem.log.limit and
-Xsystem.log.archives. This provides native log rotation by Rubinius that
does not depend on signals. Use of signals for key functionality in a
runtime like Rubinius is problematic because the running Ruby program could
trap those signals and interfere with the system.
The option -Xsystem.log.limit sets a limit in bytes on the size of the log
file.
The option -Xsystem.log.archives sets a limit on the number of archives that
are retained. The active log file is zipped and the files are rotated up to
the limit, resulting in, for example, rbx-user.log, rbx-user.log.1.Z, etc.
Rubinius::Diagnostics are added. The diagnostics provide state-oriented
logging, in contrast to the Rubinius::Metrics, which provide monotonic
counters on various aspects of work performed by the program. The
diagnostics are emitted in summary form to the log file at regular
intervals, but only if the values have updated since the last time they were
emitted, so they do not consume much log space.
Threads are immediately removed from the internal list of threads when the
thread function completes. The Thread object preserves all other state as
long as it is reachable in the object graph. The process memory for the
Thread is recovered by a finalizer function when the Thread object is no
longer reachable.
System halt is reworked to prevent race conditions on cleaning up resources
when the process is halting. The halt code is no longer run by any Ruby
thread executing, but instead is run on the dedicated thread that processes
signals.
Changelog:
Published by brixen over 9 years ago
Version 1.4.10 (2015-06-26)
News:
Changelog:
Published by brixen over 9 years ago
Version 1.4.9 (2015-06-16)
News:
Changelog: