"Tearing off" a method is extremely slow

[DartBot]

This issue was originally filed by rice@google.com

---

The following code times two operations:

1. call a closure that calls a method 'tearOff' on a particular object
2. call a closure that returns a closure representing the object's 'tearOff' method, then call that closure

On my machine (Mac Pro, OS X 10.5.8) the second approach is about 1700 times slower in the VM.

class Test {
  Test();
  void tearOff() {}
}

class Benchmark {
  Test test;
  Function closure1;
  Function closure2;

  Benchmark();

  void run() {
    test = new Test();
    closure1 = () => test.tearOff();
    closure2 = () => test.tearOff;

    for (int iter = 0; iter < 10; iter++) {
      bench();
    }
  }
  
  void bench() {
    Stopwatch w1 = new Stopwatch();
    w1.start();
    for (int i = 0; i < 10000; i++) {
      closure1();
    }
    w1.stop;
    double t1 = w1.elapsedInUs() / 10000;
    
    Stopwatch w2 = new Stopwatch();
    w2.start();
    for (int i = 0; i < 10000; i++) {
      closure2()();
    }
    w2.stop;
    double t2 = w2.elapsedInUs() / 10000;

    print("$t1 $t2 ${t2 / t1}");
  }
}

void main() {
  new Benchmark().run();
}

[rakudrama]

The first loop contains one function call per iteration.
The second loop contains two function calls and the allocation of a closure (the tear-off) per iteration.
I measure a ~320x hit for the extra call and allocation - that seems high (r1815, Goobuntu)
I measure a ~45x hit on Frog.
But the loops are not doing comparable work so it is hard to interpret these results.

To make the loops comparable, closure1 should also return a closure:

    closure1 = () => () => test.tearOff();
    ...
      closure1()()

With this change I measure 180x hit. So creating tear-offs really is terribly slow.
(Frog is 1.6x, so Frog's tear-off creation is slower than a hand written closure too, but not disastrously so.)

Another interesting comparison is to make the loops comparable the other way:

    closure2 = test.tearOff;
    ...
      closure2();

This creates a tear-off once and calls it many times.
With this I get that the VM is at 0.6x, i.e. nearly twice as fast. Calling a tear-off is great.
(OTOH, Frog's tear-offs are about 4x slower to call, but that can be reduced easily to ~ 1.2x)

---

cc @jmesserly.

[whesse]

cc @peter-ahe-google.

[rakudrama]

Issue #583 contains more details of a suggestion for Frog.
I suggest we track VM in the issue and Frog in Issue #583.

[iposva-google]

Added this to the Later milestone.

[peter-ahe-google]

I'm not sure if this is still a problem. However, if it is, would it be possible to add an option to help us find performance problems related to this?

[mraleph]

Fixed by r17261

---

Set owner to @mraleph.
Added Fixed label.