add spec for Time#utc_offset for Rational offsets
Time utc_offset can be Rational
Merge pull request #1714 from dubek/time_with_rational_offest_for_19

Time accepts a Rational offset
Remove unused macro: USE_JUMP_TABLE
Remove trailing white spaces
Use inspected major and minor for easier investigation
Define ALLOCA_STACKVARIABLES like ALLOCA_CALLFRAME
Removed pre-installed gem source directories.
Added pre-installed gems as .gem files.
Installed pre-installed gems with rubygems. Fixes #1712
Install pre-installed gems after installing rbx.
Add Float#<=> spec when argument is not a Float
Fix Float#<=> spec. Fixes #1718
Improve concurrent performance by cache locality

There is a bottle neck in SharedState::check_gc_p. It is called from all Ruby
threads and always writes to memory. That invalidates CPU cache and thus,
everything is slowed down.

Actually writing isn't always necessary in this case. It is only when the GC
flag is set. And that situation is unlikely.

This commit removes the bottle neck by avoiding writing. Then, each CPU core
runs at their full speed, not hampered by slow memory fetching due to cache
invalidation.

check_gc_p is heavily called under concurrently-executed tight loops (happen
sometime in the real word, are excised often by people interested in Rubinius's
promised concurrency)

After this commit, each concurrent thread executes a specially synthesized test
code as roughly fast as a single thread. This doesn't indicate that Rubinius
executes Ruby code purely proportional to the number of CPU cores. However it
does that Rubinius runs its core vm and has a potential to run Ruby code at the
speed.

Hello true concurrency :)

I measured performance as follows.

BEFORE THIS COMMIT:
1 thread:
 #<Thread:0x1c id=3 run>: 1.677862 seconds for looping 100000000 times
 #<Thread:0x1c id=3 run>: 1.681874 seconds for looping 100000000 times
 #<Thread:0x1c id=3 run>: 1.682204 seconds for looping 100000000 times
 #<Thread:0x1c id=3 run>: 1.672264 seconds for looping 100000000 times

2 threads:
 #<Thread:0x1c id=4 run>: 4.340247 seconds for looping 100000000 times
 #<Thread:0x24 id=3 run>: 4.443239 seconds for looping 100000000 times
 #<Thread:0x1c id=4 run>: 4.338425 seconds for looping 100000000 times
 #<Thread:0x24 id=3 run>: 4.465941 seconds for looping 100000000 times

AFTER THIS COMMIT:
1 thread:
 #<Thread:0x10 id=3 run>: 1.645313 seconds for looping 100000000 times
 #<Thread:0x10 id=3 run>: 1.640116 seconds for looping 100000000 times
 #<Thread:0x10 id=3 run>: 1.641852 seconds for looping 100000000 times
 #<Thread:0x10 id=3 run>: 1.647724 seconds for looping 100000000 times

2 threads:
 #<Thread:0x10 id=4 run>: 1.764503 seconds for looping 100000000 times
 #<Thread:0x18 id=3 run>: 1.697629 seconds for looping 100000000 times
 #<Thread:0x10 id=4 run>: 1.715689 seconds for looping 100000000 times
 #<Thread:0x10 id=4 run>: 1.702426 seconds for looping 100000000 times

TEST CODE:
loop_count = 100_000_000
threads = 2
threads.times.collect do
  Thread.new do
    loop do
      time = Time.now
      i = loop_count
      i -= 1 until i.zero?
      puts "#{Thread.current}: #{Time.now - time} seconds for looping " +
           "#{loop_count} times"
    end
  end
end.each(&:join)
Merge pull request #1719 from carlosgaldino/float-comparison

Float comparison
Merge pull request #1715 from caiquanqing/master

Fix an issue that Marshal cannot unmarshal from an IO stream in 1.9 mode