mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
d45a013a1a
Prior to this changeset, majority of inline cache mishits resulted
into the same method entry when rb_callable_method_entry() resolves
a method search. Let's not call the function at the first place on
such situations.
In doing so we extend the struct rb_call_cache from 44 bytes (in
case of 64 bit machine) to 64 bytes, and fill the gap with
secondary class serial(s). Call cache's class serials now behavies
as a LRU cache.
Calculating -------------------------------------
ours 2.7 2.6
vm2_poly_same_method 2.339M 1.744M 1.369M i/s - 6.000M times in 2.565086s 3.441329s 4.381386s
Comparison:
vm2_poly_same_method
ours: 2339103.0 i/s
2.7: 1743512.3 i/s - 1.34x slower
2.6: 1369429.8 i/s - 1.71x slower
96 lines
3.1 KiB
Ruby
96 lines
3.1 KiB
Ruby
#! /your/favourite/path/to/ruby
|
|
# -*- Ruby -*-
|
|
# -*- frozen_string_literal: true; -*-
|
|
# -*- warn_indent: true; -*-
|
|
#
|
|
# Copyright (c) 2017 Urabe, Shyouhei. All rights reserved.
|
|
#
|
|
# This file is a part of the programming language Ruby. Permission is hereby
|
|
# granted, to either redistribute and/or modify this file, provided that the
|
|
# conditions mentioned in the file COPYING are met. Consult the file for
|
|
# details.
|
|
|
|
require_relative '../helpers/scanner'
|
|
require_relative './vm_opts_h'
|
|
|
|
json = []
|
|
scanner = RubyVM::Scanner.new '../../../insns.def'
|
|
path = scanner.__FILE__
|
|
grammar = %r'
|
|
(?<comment> /[*] [^*]* [*]+ (?: [^*/] [^*]* [*]+ )* / ){0}
|
|
(?<keyword> typedef | extern | static | auto | register |
|
|
struct | union | enum ){0}
|
|
(?<C> (?: \g<block> | [^{}]+ )* ){0}
|
|
(?<block> \{ \g<ws>* \g<C> \g<ws>* \} ){0}
|
|
(?<ws> \g<comment> | \s ){0}
|
|
(?<ident> [_a-zA-Z] [0-9_a-zA-Z]* ){0}
|
|
(?<type> (?: \g<keyword> \g<ws>+ )* \g<ident> ){0}
|
|
(?<arg> \g<type> \g<ws>+ \g<ident> | \.\.\. ){0}
|
|
(?<argv> (?# empty ) |
|
|
void |
|
|
\g<arg> (?: \g<ws>* , \g<ws>* \g<arg> \g<ws>* )* ){0}
|
|
(?<pragma> \g<ws>* // \s* attr \g<ws>+
|
|
(?<pragma:type> \g<type> ) \g<ws>+
|
|
(?<pragma:name> \g<ident> ) \g<ws>*
|
|
= \g<ws>*
|
|
(?<pragma:expr> .+?; ) \g<ws>* ){0}
|
|
(?<insn> DEFINE_INSN(_IF\((?<insn:if>\w+)\))? \g<ws>+
|
|
(?<insn:name> \g<ident> ) \g<ws>*
|
|
[(] \g<ws>* (?<insn:opes> \g<argv> ) \g<ws>* [)] \g<ws>*
|
|
[(] \g<ws>* (?<insn:pops> \g<argv> ) \g<ws>* [)] \g<ws>*
|
|
[(] \g<ws>* (?<insn:rets> \g<argv> ) \g<ws>* [)] \g<ws>* ){0}
|
|
'x
|
|
|
|
until scanner.eos? do
|
|
next if scanner.scan(/\G#{grammar}\g<ws>+/o)
|
|
split = lambda {|v|
|
|
case v when /\Avoid\z/ then
|
|
[]
|
|
else
|
|
v.split(/, */)
|
|
end
|
|
}
|
|
|
|
l1 = scanner.scan!(/\G#{grammar}\g<insn>/o)
|
|
name = scanner["insn:name"]
|
|
opt = scanner["insn:if"]
|
|
ope = split.(scanner["insn:opes"])
|
|
pop = split.(scanner["insn:pops"])
|
|
ret = split.(scanner["insn:rets"])
|
|
|
|
attrs = []
|
|
while l2 = scanner.scan(/\G#{grammar}\g<pragma>/o) do
|
|
attrs << {
|
|
location: [path, l2],
|
|
name: scanner["pragma:name"],
|
|
type: scanner["pragma:type"],
|
|
expr: scanner["pragma:expr"],
|
|
}
|
|
end
|
|
|
|
l3 = scanner.scan!(/\G#{grammar}\g<block>/o)
|
|
if opt.nil? || RubyVM::VmOptsH[opt]
|
|
json << {
|
|
name: name,
|
|
location: [path, l1],
|
|
signature: {
|
|
name: name,
|
|
ope: ope,
|
|
pop: pop,
|
|
ret: ret,
|
|
},
|
|
attributes: attrs,
|
|
expr: {
|
|
location: [path, l3],
|
|
expr: scanner["block"],
|
|
},
|
|
}
|
|
end
|
|
end
|
|
|
|
RubyVM::InsnsDef = json
|
|
|
|
if __FILE__ == $0 then
|
|
require 'json'
|
|
JSON.dump RubyVM::InsnsDef, STDOUT
|
|
end
|