| Age | Commit message (Collapse) | Author |
|
The kw_splat flag is whether the original call passes keyword or not.
Some types of methods (e.g., bmethod and sym_proc) drops the
information. This change tries to propagate the flag to the final
callee, as far as I can.
|
|
|
|
Looks like we're getting WB misses during stressful GC on startup. I am
investigating.
|
|
Give me a break.
|
|
I guess those AST node were actually used for something, so we'd better
not touch them. Instead this commit just puts the tmpbuffer inside a
different internal struct so that we can mark them.
|
|
|
|
|
|
DSTR nodes are allocated in to the "markable" bucket where ARRAY nodes
are not. Switching buckets can cause errors during GC.
|
|
This commit adds two buckets for allocating NODE structs, then allocates
"markable" NODE objects from one bucket. The reason to do this is so
when the AST mark function scans nodes for VALUE objects to mark, we
only scan NODE objects that we know to reference VALUE objects. If we
*did not* divide the objects, then the mark function spends too much
time scanning objects that don't contain any references.
|
|
Now we can reach the ID table buffer from the id table itself, so when
SCOPE nodes are marked we can keep the buffers alive. This eliminates
the need for the "mark array" during normal parse / compile (IOW *not*
Ripper).
|
|
This way we don't need to add the tmpbufs to a Ruby array for marking
|
|
This patch changes the AST mark function so that it will walk through
nodes in the NODE buffer marking Ruby objects rather than using a mark
array to guarantee liveness. The reason I want to do this is so that
when compaction happens on major GCs, node objects will have their
references pinned (or possibly we can update them correctly).
|
|
|
|
This is broken at least since 2.5 (I didn't check earlier versions).
It resulted in failure in test_ast.rb when the tests were added before
the parser change.
Basically, in remove_duplicate_keys, if the node is modified, set
the location information to the previous location information. The
removal of keys should not affect the location in the code.
Notes:
Merged: https://github.com/ruby/ruby/pull/2428
|
|
Previously, **{} was removed by the parser:
```
$ ruby --dump=parse -e '{**{}}'
@ NODE_SCOPE (line: 1, location: (1,0)-(1,6))
+- nd_tbl: (empty)
+- nd_args:
| (null node)
+- nd_body:
@ NODE_HASH (line: 1, location: (1,0)-(1,6))*
+- nd_brace: 1 (hash literal)
+- nd_head:
(null node)
```
Since it was removed by the parser, the compiler did not know
about it, and `m(**{})` was therefore treated as `m()`.
This modifies the parser to not remove the `**{}`. A simple
approach for this is fairly simple by just removing a few
lines from the parser, but that would cause two hash
allocations every time it was used. The approach taken here
modifies both the parser and the compiler, and results in `**{}`
not allocating any hashes in the usual case.
The basic idea is we use a literal node in the parser containing
a frozen empty hash literal. In the compiler, we recognize when
that is used, and if it is the only keyword present, we just
push it onto the VM stack (no creation of a new hash or merging
of keywords). If it is the first keyword present, we push a
new empty hash onto the VM stack, so that later keywords can
merge into it. If it is not the first keyword present, we can
ignore it, since the there is no reason to merge an empty hash
into the existing hash.
Example instructions for `m(**{})`
Before (note ARGS_SIMPLE):
```
== disasm: #<ISeq:<main>@-e:1 (1,0)-(1,7)> (catch: FALSE)
0000 putself ( 1)[Li]
0001 opt_send_without_block <callinfo!mid:m, argc:0, FCALL|ARGS_SIMPLE>, <callcache>
0004 leave
```
After (note putobject and KW_SPLAT):
```
== disasm: #<ISeq:<main>@-e:1 (1,0)-(1,7)> (catch: FALSE)
0000 putself ( 1)[Li]
0001 putobject {}
0003 opt_send_without_block <callinfo!mid:m, argc:1, FCALL|KW_SPLAT>, <callcache>
0006 leave
```
Example instructions for `m(**h, **{})`
Before and After (no change):
```
== disasm: #<ISeq:<main>@-e:1 (1,0)-(1,12)> (catch: FALSE)
0000 putself ( 1)[Li]
0001 putspecialobject 1
0003 newhash 0
0005 putself
0006 opt_send_without_block <callinfo!mid:h, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>
0009 opt_send_without_block <callinfo!mid:core#hash_merge_kwd, argc:2, ARGS_SIMPLE>, <callcache>
0012 opt_send_without_block <callinfo!mid:m, argc:1, FCALL|KW_SPLAT>, <callcache>
0015 leave
```
Example instructions for `m(**{}, **h)`
Before:
```
== disasm: #<ISeq:<main>@-e:1 (1,0)-(1,12)> (catch: FALSE)
0000 putself ( 1)[Li]
0001 putspecialobject 1
0003 newhash 0
0005 putself
0006 opt_send_without_block <callinfo!mid:h, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>
0009 opt_send_without_block <callinfo!mid:core#hash_merge_kwd, argc:2, ARGS_SIMPLE>, <callcache>
0012 opt_send_without_block <callinfo!mid:m, argc:1, FCALL|KW_SPLAT>, <callcache>
0015 leave
```
After (basically the same except for the addition of swap):
```
== disasm: #<ISeq:<main>@-e:1 (1,0)-(1,12)> (catch: FALSE)
0000 putself ( 1)[Li]
0001 newhash 0
0003 putspecialobject 1
0005 swap
0006 putself
0007 opt_send_without_block <callinfo!mid:h, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>
0010 opt_send_without_block <callinfo!mid:core#hash_merge_kwd, argc:2, ARGS_SIMPLE>, <callcache>
0013 opt_send_without_block <callinfo!mid:m, argc:1, FCALL|KW_SPLAT>, <callcache>
0016 leave
```
Notes:
Merged: https://github.com/ruby/ruby/pull/2428
|
|
This must be definitely removed after we collect the stack traces :-)
http://ci.rvm.jp/results/trunk-mjit@silicon-docker/2245710
|
|
Seems FreeBSD already supported `CLOCK_PROCESS_CPUTIME_ID`.
That added by https://reviews.freebsd.org/rS239347 and the doc was updated
by https://reviews.freebsd.org/rS315694.
I confirmed `CLOCK_PROCESS_CPUTIME_ID` constant exists in 9.3.0 branch.
https://github.com/freebsd/freebsd/blob/release/9.3.0/sys/sys/time.h#L269
Notes:
Merged: https://github.com/ruby/ruby/pull/2429
|
|
[Feature #15868]
|
|
In order to check whether a path is absolute or not in a portable way.
[Feature #15868]
|
|
https://github.com/rubygems/rubygems/commit/d4fc383497
|
|
https://github.com/rubygems/rubygems/commit/95c1f4e179
|
|
surrounded by a single space.
https://github.com/rubygems/rubygems/commit/eaa38ebeb1
|
|
https://github.com/rubygems/rubygems/commit/f5972338e0
|
|
https://github.com/rubygems/rubygems/commit/d1bb122651
|
|
is specified
https://github.com/rubygems/rubygems/commit/547947bbf0
|
|
https://github.com/rubygems/rubygems/commit/c8913e37a7
|
|
name specified
https://github.com/rubygems/rubygems/commit/38c72fd145
|
|
https://github.com/rubygems/rubygems/commit/ab186266b7
|
|
https://github.com/rubygems/rubygems/commit/dc70c5a192
|
|
https://github.com/rubygems/rubygems/commit/4ba4ffebbe
|
|
https://github.com/rubygems/rubygems/commit/a16eacd650
|
|
Instead, display an informative message saying that uninstallation of
specific versions is being skipped because of being default gems.
https://github.com/rubygems/rubygems/commit/b44845aa1d
|
|
Otherwise it detects duplicate methods here, because it doesn't see that
we are reopening the class in two different places.
https://github.com/rubygems/rubygems/commit/ae3fb47f5f
|
|
instance
https://github.com/rubygems/rubygems/commit/9a401646e1
|
|
https://github.com/rubygems/rubygems/commit/fc224e9717
|
|
https://github.com/ruby/ruby/runs/212727409#step:11:67
```
invalid option: -j5
```
|
|
|
|
Some coverage improvements.
|
|
Git is not for direct access to a remote repository.
Most of its operations need a local clone.
|
|
This changeset is to suppress clang's -Wimplicit-int-float-conversion
warning.
In 64 bit signed long and IEEE 754 double combination (== almost
everyone these days), LONG_MAX is 9,223,372,036,854,775,807. This
value is _not_ exactly representable by double. The nearest value
that a double can represnt is 9,223,372,036,854,775,808. It is one
greater than LONG_MAX. Let's call this value the "x".
The expression `LONG_MAX < yi` is a long versus double comparison.
According to ISO/IEC 9899:1999 Section 6.3.1.8 (that defines the
"usual rithmetic conversions"), The long value must first be casted
into double. Because FLT_ROUNDS is typically 1 ("round to the
nearest" mode), the conversion yields the "x" value shown above. So
the comparison is in fact `x < yi`.
This comparison is false for yi == x situation, i.e. yi is still
bigger than LONG_MAX. On such situation the `yn = (long)yi;`
statement that appear several lines below renders underfined
behaviour, as per ISO/IEC 9899:1999 Section 6.3.1.3.
To remedy, we just change the comparison from `<` to `<=` so that
yi == x situation can properly be handled.
|
|
Requested by ko1. Also, because now that this function is internal
use only, why not just directly use struct rb_call_cache to purge
the ZALLOC.
|
|
Ko1 plans to implement Guild. That can interface the caching
mechanism introduced here. To prevent future breakage we would
better avoid rolling our own code here. Instead use the existing
vm_search_method() which would be modified by him.
This commit deletes some asserions, but they are in fact checked
inside of vm_search_method().
|
|
|
|
|
|
|
|
|
|
Why not cache the method entry at each caller site. The void**
is in fact a method entry, but this struct is hidden from ruby.h
so intentionally left opaque.
Notes:
Merged: https://github.com/ruby/ruby/pull/1981
|
|
|
|
|
|
|