Move allocation out of _Utils_compare (improving performance)

[Skinney]

In my work on a new Dict implementation, I discovered that one of the functions being called the most is _Utils_compare. By moving the object allocation out of the function (pre-allocating) we can improve performance of the function.

In my benchmark, Dict.get goes from a mean runtime of ~30ns per call (for a Dict of 100 key-value pairs) to ~26ns. If my math is correct (it rarely is) that is a 13% performance increase.

I also tried the following, but it did not offer better performance and is more code:

var lt = { $: 'LT' };
var eq = { $: 'EQ' };
var gt = { $: 'GT' };

var _Utils_compare = F2(function(x, y)
{
    var ord = _Utils_cmp(x, y);
    return ord < 0 ? lt : ord > 0 ? gt : eq;
});

(The actual benchmarks were performed by modifying a 0.18 compiled output by hand. Even though the code looks slightly different in this 0.19-branch, I don't see why the results would be any different).

[process-bot]

Thanks for the pull request! Make sure it satisfies this checklist. My human colleagues will appreciate it!

Here is what to expect next, and if anyone wants to comment, keep these things in mind.

[process-bot]

Thanks for the pull request! Make sure it satisfies this checklist. My human colleagues will appreciate it!

Here is what to expect next, and if anyone wants to comment, keep these things in mind.

[evancz]

I think it would be best to refer to elm_lang$core$Basics$LT such that it gets minified better. This also means the runtime representation can be chosen by the compiler more easily.

I'll keep this open as a reminder of this change, but there are a few unknown things that make it hard to make a change at this exact moment.

[evancz]

I think it would be best to refer to elm_lang$core$Basics$LT such that it gets minified better. This also means the runtime representation can be chosen by the compiler more easily.

I'll keep this open as a reminder of this change, but there are a few unknown things that make it hard to make a change at this exact moment.

[justinmimbs]

Regarding the idea of using primitives at runtime to represent argument-less union types: I hand-modified the JS output of Robin's Dict.LLRB.get function to use cmp instead of compare, and it saw a 77% increase in ops/sec in Chrome (using dicts of 100 elements with ints as keys).

i.e. from

var _p16 = A2(_elm_lang$core$Basics$compare, targetKey, _p15._1);
switch (_p16.ctor) {
    case 'LT':

to

var _p16 = _elm_lang$core$Native_Utils.cmp(targetKey, _p15._1);
switch (_p16) {
    case -1:

[justinmimbs]

Regarding the idea of using primitives at runtime to represent argument-less union types: I hand-modified the JS output of Robin's Dict.LLRB.get function to use cmp instead of compare, and it saw a 77% increase in ops/sec in Chrome (using dicts of 100 elements with ints as keys).

i.e. from

var _p16 = A2(_elm_lang$core$Basics$compare, targetKey, _p15._1);
switch (_p16.ctor) {
    case 'LT':

to

var _p16 = _elm_lang$core$Native_Utils.cmp(targetKey, _p15._1);
switch (_p16) {
    case -1:

[evancz]

The final version looks like this: https://github.com/elm-lang/core/blob/master/src/Elm/Kernel/Utils.js#L127-L131

There are bunches of inlining tricks we can do to avoid allocations, but the compiler infrastructure is not sophisticated enough to do them right now. So it's not that I don't think of them; it's that they cannot be done without a great deal of infrastructure work to get type information on all expressions. That is something I have my eye on as well.

[evancz]

The final version looks like this: https://github.com/elm-lang/core/blob/master/src/Elm/Kernel/Utils.js#L127-L131

There are bunches of inlining tricks we can do to avoid allocations, but the compiler infrastructure is not sophisticated enough to do them right now. So it's not that I don't think of them; it's that they cannot be done without a great deal of infrastructure work to get type information on all expressions. That is something I have my eye on as well.