VM Propagate receiver type from calls to unique selectors in AOT compilation.

VM Propagate receiver type from calls to unique selectors in AOT compilation.

If there is no override of noSuchMethod in any class, we can
propagate the receiver type downwards from calls that call a unique
selector.

This speeds up dart2js by around 3%, a particle simulation benchmark by around 10%.

BUG=
R=rmacnak@google.com

Committed: https://github.com/dart-lang/sdk/commit/e25461c1519cb323f182ec4373f159c9bf7909c4

[Florian Schneider, 2016-10-11 18:06:19]

fschneider@google.com changed reviewers:
+ rmacnak@google.com

[rmacnak, 2016-10-11 19:53:58]

lgtm w/test


class A {
  foo() => "foo";
  bar() => "A";
}

class B {
  noSuchMethod(invocation) => "nsm";
  bar() => "B";
}

confuse(x) {
  try {
    throw x;
  } catch (e) {
    return e;
  }
  return null;
}

main() {
  var a = confuse(new A());
  Expect.equals("foo", a.foo());
  Expect.equals("A", a.bar());

  var b = confuse(new B());
  Expect.equals("nsm", b.foo());
  Expect.equals("B", b.bar());  // Don't propagate type A to b.
}

https://codereview.chromium.org/2412653002/diff/1/runtime/vm/precompiler.cc
File runtime/vm/precompiler.cc (right):

https://codereview.chromium.org/2412653002/diff/1/runtime/vm/precompiler.cc#n...
runtime/vm/precompiler.cc:1498: // Locate all entries with one function only,
and whose owner is neither
Update comment

[Florian Schneider, 2016-10-11 20:13:54]

Added test

https://codereview.chromium.org/2412653002/diff/1/runtime/vm/precompiler.cc
File runtime/vm/precompiler.cc (right):

https://codereview.chromium.org/2412653002/diff/1/runtime/vm/precompiler.cc#n...
runtime/vm/precompiler.cc:1498: // Locate all entries with one function only,
and whose owner is neither
On 2016/10/11 19:53:58, rmacnak wrote:
> Update comment

Done.

[Florian Schneider, 2016-10-11 20:17:52]

Description was changed from

==========
VM Propagate receiver type from calls to unique selectors in AOT compilation.

If there is no override of noSuchMethod in any class, we can
propagate the receiver type downwards from calls that call a unique
selector.

This speeds up dart2js by around 3%, a particle simulation benchmark by around
10%.

BUG=
==========

to

==========
VM Propagate receiver type from calls to unique selectors in AOT compilation.

If there is no override of noSuchMethod in any class, we can
propagate the receiver type downwards from calls that call a unique
selector.

This speeds up dart2js by around 3%, a particle simulation benchmark by around
10%.

BUG=
R=rmacnak@google.com

Committed:
https://github.com/dart-lang/sdk/commit/e25461c1519cb323f182ec4373f159c9bf7909c4
==========

[Florian Schneider, 2016-10-11 20:17:53]

Committed patchset #2 (id:20001) manually as
e25461c1519cb323f182ec4373f159c9bf7909c4 (presubmit successful).

[Vyacheslav Egorov (Google), 2016-11-15 20:48:47]

vegorov@google.com changed reviewers:
+ vegorov@google.com

[Vyacheslav Egorov (Google), 2016-11-15 20:48:48]

This optimization is not safe in it's current form because it does not take LICM
into account (remember that we had to disable/revert similar downwards type
propagation from branches). Here is a crashing test:

class A {
  uniqueSelector() {

  }

  final uniqueField = 10;
}

foofoo(obj) {
    var res = 0;
    for (var i = 0; i < 2; i++) {
      obj.uniqueSelector();
      res += obj.uniqueField;  // this load will be hoisted out of the loop
    }
    return res;
}

var foofoo_ = foofoo;

main () {
  foofoo_(new A());
  foofoo_(0);
}

[Florian Schneider, 2016-11-15 22:08:12]

On 2016/11/15 20:48:48, Vyacheslav Egorov (Google) wrote:
> This optimization is not safe in it's current form because it does not take
LICM
> into account (remember that we had to disable/revert similar downwards type
> propagation from branches). Here is a crashing test:
> 
> class A {
>   uniqueSelector() {
> 
>   }
> 
>   final uniqueField = 10;
> }
> 
> foofoo(obj) {
>     var res = 0;
>     for (var i = 0; i < 2; i++) {
>       obj.uniqueSelector();
>       res += obj.uniqueField;  // this load will be hoisted out of the loop
>     }
>     return res;
> }
> 
> var foofoo_ = foofoo;
> 
> main () {
>   foofoo_(new A());
>   foofoo_(0);
> }

Thanks for catching this! We used to insert redefinitions to prevent LICM. I
think this works here as well, if we replace all uses of the receiver dominated
by the unique call by uses of the redefinition.