Maybe you don't need Rust and WASM to speed up your JS

Re:Maybe you don't need Rust and WASM to speed up your JS by vanderZwan on Monday February 19, 2018 @05:07PM (#16416144)

> monomorphisation trick

Here's a crazy thing I recently learned: apparently monomorphism isn't just "object with identical keys", apparently (at least in Chrome), the order in which you declare those keys matters. According to this presentation from 2015[0], adjusting the following lines in the Octane/Splaytree benchmark so that node.left and node.right are always assigned in the same order resulted in 15% better performance:

    var node = new SplayTree.Node(key, value);
    if (key > this.root_.key) {
      node.left = this.root_;
      node.right = this.root_.right;
      ...
    } else {
      node.right = this.root_;
      node.left = this.root_.left;
      ...
    }

Now, I assume that this out-of-order thing was actually done on purpose, to benchmark how the JIT handles code like this. Further evidence for that is that the SplayTree constructor[1] does not feature a left and right key either:

    SplayTree.Node = function(key, value) {
      this.key = key;
      this.value = value;
    };

Still, I wouldn't be surprised if it was common for real-life code to accidentally have objects that should have the same hidden class end up with different ones because of this.

[0] http://mp.binaervarianz.de/fse2015_slides.pdf

[1] https://github.com/chromium/octane/blob/master/splay.js#L390

[ Parent | on HN ]

Re:Maybe you don't need Rust and WASM to speed up your JS by ridiculous_fish on Monday February 19, 2018 @05:32PM (#16416293)

Yes, this is because the JS spec requires that object keys are iterated in insertion order (with a bizarre exception for arrays).

[ Parent | on HN ]

Re:Maybe you don't need Rust and WASM to speed up your JS by vanderZwan on Monday February 19, 2018 @06:55PM (#16416759)

Ah, I guess that explains it. Although that does not require the engine to have under-the-hood layout respect that, does it? They could just as easily choose to keep the memory layout in the same order.

Although I suppose you're already required to have two separate hidden classes to distinguish these two kinds of objects anyway.

> with a bizarre exception for arrays

Wow, you weren't joking with how bizarre this gets:

    var a = {};
    var b = {};
    a.a = 0;
    a.b = 1;
    a[0] = 0;
    a[1] = 1;
    b.b = 1;
    b.a = 0;
    b[1] = 1;
    b[0] = 0;
    Object.keys(a); // Array [ "0", "1", "a", "b" ]
    Object.keys(b); // Array [ "0", "1", "b", "a" ]

PS: Thanks for making a great shell :)

[ Parent | on HN ]

Re:Maybe you don't need Rust and WASM to speed up your JS by sayrer on Monday February 19, 2018 @08:42PM (#16417237)

Prior to Chrome's release, browsers preserved insertion order for numeric keys as well (but this was not in the ES3 spec).

Chrome/V8's team found they could get substantial performance improvements by diverging from the de facto standard, without too much of a cost to web compatibility.

[ Parent | on HN ]

Re:Maybe you don't need Rust and WASM to speed up your JS by deathanatos on Tuesday February 20, 2018 @12:55AM (#16418148)

TIL. For those like me for which this is new, this was apparently a change in the ES 2015 / ES 6 version of the standard.

See: https://stackoverflow.com/questions/5525795/does-javascript-...

The order is only sometimes guaranteed, of course, because JavaScript. (But critically, for this discussion, it is important that it is sometimes guaranteed, because it forces that information to be stored by the VM.)

[ Parent | on HN ]

Re:Maybe you don't need Rust and WASM to speed up your JS by vanderZwan on Tuesday February 20, 2018 @06:58AM (#16419688)

I feel so justified in adding this guard in my compression pre-processor[0] code, even though I never had a bug without it:

    // the keys of an object
    export function keysOf(obj) {
      let keys = Object.keys(obj);
      keys.sort();
      return oneOf(keys);
    }

Context: the rest of the code takes an object representing a schema, and creates two functions. One that can turn any object fitting that schema into an array, with positions indicating which key they originally belonged to, and another one that can reverse the process.

Could this also explain why I have no consistent order of properties when viewing state with the Redux dev-tools? Instead of Object.assign I use my own simplified merge code[1]. Maybe if I also make that use a sorted set of keys, the devtools will become more consistent in their presentation (and it might result in more consistent hidden classes too).

[0] https://github.com/linnarsson-lab/loom-viewer/blob/master/cl...

[1] https://github.com/linnarsson-lab/loom-viewer/blob/master/cl...

[ Parent | on HN ]

Re:Maybe you don't need Rust and WASM to speed up your JS by pdpi on Tuesday February 20, 2018 @08:53AM (#16420276)

Wait what? Since when? That wasn’t the case at all 5 or 6 years ago (I got bitten in the arse by Rhino not implementing it that way)

[ Parent | on HN ]

Re:Maybe you don't need Rust and WASM to speed up your JS by epmatsw on Tuesday February 20, 2018 @10:33AM (#16421073)

Most browsers already did, and some (not all) of the ES2015 stuff requires property ordering. Probably easier to just keep everything ordered since it could be needed by those methods.

[ Parent | on HN ]