7 ms·

The Path to Parallel JavaScript

• PinnBrain 12y ago
  Oh no, will this become an ego thing? Parallelism must lie somewhere near abstraction as a premature optimization. Computers are hard, even single threaded.
• bhouston 12y ago
  This is really important work!
• Zikes 12y ago
  I would love to see a channel primitive similar to Golang's. They really seem to have hit the nail on the head with that one.
  • jeremiep 12y ago
    Clojure's core.async library works wonders in ClojureScript giving you channel primitives and coroutines. I've never tried using them across web workers however.
  • noelwelsh 12y ago
    The CSP model is very nice, but I don't think that what this proposal is aiming for. CSP is more about concurrency, while the post makes it clear they are looking at parallelism. This is more addressing "things that appear to be single threaded but run faster" like image analysis, for instance.
    • nkozyra 12y ago
      They're obviously separate concepts, but tangentially related. Even in Go you'll learn that sometimes introducing multithreading to a concurrent application will actually reduce your performance due to reconciliation of context-switching within the application. Javascript already has its own inherent concurrency, obviously, but it's not outlandish to say that introducing a goroutine/coroutine concept would be a lot more elegant and manageable.
  • coding4all 12y ago
    Clojure and ClojureScript have core.async which does a great/better job https://github.com/clojure/core.async/blob/master/examples/walkthrough.clj#L89 https://github.com/clojure/core.async/blob/master/examples/w... There's also a video if you care to watch https://www.youtube.com/watch?v=enwIIGzhahw https://www.youtube.com/watch?v=enwIIGzhahw
• leeoniya 12y ago
  i have always wanted Canvas as well as read-only array buffers (for things like map-reduce image analysis) to be accessible in web workers.
• amelius 12y ago
  Great developments, since, imho, we really need multi-threading to make decent user-interfaces (ones without hick-ups due to blocking of the cpu-resource). I think what we need is immutable data-structures to be shareable between threads. This approach should also allow structural sharing between threads, allowing for efficient and safe data structures. Also, I could see a use for a mechanism where a thread creates a data-structure, then marks it as read-only, such that it can become shared.
  • coderzach 12y ago
    Anecdotally, I've found that most performance hick-ups don't come from computation blocking the ui, but from rendering one part of the ui blocking every other part from rendering. The solution to that being parallel or async paint/layout, which is something I never hear mentioned (probably because it's a really hard problem).
    • Joe8Bit 12y ago
      Servo is actually in the process of implementing a parallel layout engine[1][2] 1: http://en.wikipedia.org/wiki/Servo_(layout_engine) http://en.wikipedia.org/wiki/Servo_(layout_engine) 2: http://pcwalton.github.io/blog/2014/02/25/revamped-parallel-layout-in-servo/ http://pcwalton.github.io/blog/2014/02/25/revamped-parallel-...
      • amelius 12y ago
        Interesting. I wonder how they handle incremental rendering though. Only the forward-path is described in your reference [2].
        • sanxiyn 12y ago
          As far as I can tell there is nothing unusual or difficult here. Servo's incremental layout implementation is here: https://github.com/servo/servo/blob/master/components/layout/incremental.rs https://github.com/servo/servo/blob/master/components/layout...
• lukasm 12y ago
  Does anyone know what is the origin of async/await? It's very convenient for simple cases, but it makes it very hard to mix synchronous and async code(C#).
  • coderzach 12y ago
    How does it make it difficult?
    • lukasm 12y ago
      I have encounter this problem https://stackoverflow.com/questions/28708238/catching-exceptions-in-async-code-called-synchronously https://stackoverflow.com/questions/28708238/catching-except... Basically, it's hard and prone to bugs.
      • TheCoreh 12y ago
        The implementation in JS seems to be simpler and consequently less error prone than the one in C#. Calling an async function just returns a Promise. The await operator just yields to the event loop until a given Promise is fullfilled. Exceptions are handled "normally" inside the async function with try/catch, outside they're handled with a callback, like in existing code that uses promises.
    • sanxiyn 12y ago
      You can only call async functions inside async functions. See also What color is your function? http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/ http://journal.stuffwithstuff.com/2015/02/01/what-color-is-y...
      • TheCoreh 12y ago
        If that was the case then async functions would be useless, since the global scope is not an async function. You can call async functions from regular functions, they will just return a promise. You can then use normal promise handing behavior (passing a callback function, which is how you'd currently handle async anyway). In real-world scenarios though, most of the time you'll be reacting to events, and not calling async code from sync code. Edit: To clarify I'm talking about the ES7 async/await feature.
• polskibus 12y ago
  What's wrong with message passing though - MPI does it, Erlang does it - surely this paradigm can deliver good performance for data and task parallelism. I hope Mozilla will continue experimenting with parallel js. Exciting times!
  • sunfish 12y ago
    The shared ArrayBuffer interface being described here is following the philosophy of the Extensible Web Manifesto [0]. The idea is that libraries providing higher-level APIs and programming models, such as message passing, can be built on top of low-level primitives. [0] https://extensiblewebmanifesto.org/ https://extensiblewebmanifesto.org/
  • ndesaulniers 12y ago
    Forgive me if my comment seems ignorant, as I've had experience with MPI and threaded code, but not professionally. I also do not provide any numbers or profiles. I would think message passing in terms of MPI is acceptable, because "the cost of copying" is insignificant to "the cost of network latency." When you have very little overhead (multiple threads performing atomic operations on shared memory), then "the cost of copying" becomes relatively significant. And if you want to target JS given existing legacy C++ code that probably won't be rewritten, well then the JS execution environment will have to be the one to bend.
    • woah 12y ago
      Which existing C++ code are you referring to? It seems like a bad idea to compromise the soundness of Javascript to do whatever it is you are talking about doing. I don't think that legacy C++ code is something that should be causing anything to bend.
  • odiroot 12y ago
    I think they mostly mean the overhead of (de)serialization from/into JSON. It's also hard to pass binary data that way.
    • 12y ago
• higherpurpose 12y ago
  Will Spidermonkey be rewritten in Rust eventually? Sidenote: WebGL 2.0 should come with ASTC support to be relatively future-proof.
  • steveklabnik 12y ago
    That is too far in the future to see.
  • gsnedders 12y ago
    Note that JITing compilers gain a lot less from Rust's safety guarantees than most code: you can easily JIT some code that breaks one of the safety properties that Rust ordinarily defends.
• reissbaker 12y ago
  This is nice for some pretty limited use cases, but the most common use case for multithreading in app-like programs (which is what Worker-based apps presumably service: these are not documents) is removing latency from the UI thread. But as long as only the main thread can touch the UI, and the main thread also can't access shared memory, this limits uses of this to scenarios where copying the entire render state from a Worker is reasonably fast — in which case, Workers currently already solve the problem. This proposed implementation of shared memory doesn't actually solve one of the big remaining needs for shared memory, which is when it's prohibitively expensive to copy state between a Worker thread and the UI thread at 60fps. For example, Workers aren't particularly useful for games in their current iteration: the overhead of copying the state of the world back to the rendering thread is high. This is exactly the problem that shared memory would solve, were it not limited to Workers. This puts web export (or even primary web-based game authorship) at a significant disadvantage as compared to native apps: native code can share memory, and web-based implementations can't. In many cases architectures that are optimal for shared-memory threading are pathological when the rendering thread requires copies, meaning that threading gets thrown out the window for web. Even with asm.js-compiled "near-native" performance on the single core, you can only use 25% of the available CPU if you can't use multithreading. A 4x performance hit is the difference between 60fps and 15fps... Or 15fps and ~4fps. The title of the blog post got me pretty excited, but the proposal is fairly disappointing in terms of unlocking better performance for web apps. The use cases here are pretty limited to things like CPU-bound number crunching, and I doubt too many people are running machine learning algorithms in a browser as compared to the number people who're using browsers to, y'know, render UIs. By all means scope the problem down to sharing primitive data in ArrayBuffers — we can build abstractions on top of that! — but limiting it to Worker threads makes it near-useless for most web applications. Workers already solve the use cases for UIs that can tolerate copies between the UI thread and the Worker threads, and this proposal doesn't allow us to solve needs for UIs that can't.
  • azakai 12y ago
    The blog post does mention the main thread, as something that is more complex and in need of further investigation. Still, even without shared memory being accessible to the main thread, I think sharing between workers can be extremely useful. Yes, you need to proxy information to the main thread in order to render, but that doesn't need to be a big problem. See for example the test here, where a 3D game's rendering was proxied to the main thread, with little loss of performance, https://blog.mozilla.org/research/2014/07/22/webgl-in-web-workers-today-and-faster-than-expected/ https://blog.mozilla.org/research/2014/07/22/webgl-in-web-wo... That very small overhead could be worth letting the game run in multiple workers while using shared memory. Also, things like Canvas 2D and WebGL are APIs that might exist in workers, there are efforts towards that happening right now. That would eliminate the need to copy anything to the main thread, and avoid a lot of latency.
• general_failure 12y ago
  Why not implement go routines model?
  • tlrobinson 12y ago
    Aren't go routines pretty similar to WebWorkers, but with special syntax for creating them (and sending/receiving messages over channels) and perhaps lighter weight (though that may just be an implementation issue with current JS engines)? Edit: nevermind, it looks like go routines can share memory, (but channels are the preferred method of synchronization): https://golang.org/ref/mem https://golang.org/ref/mem
• spidermantoo 12y ago
  Good Article, Thanks.
• spidermantoo 12y ago
  Good Article, Thanks.
• thomasfoster96 12y ago
  From what I've seen, SIMD.js does make doing some calculations quicker, although it's not the 4x increase one might assume. It's more like 30% to 50%. The latency and overhead associated with moving the SIMD.js calculations into a Web Worker actually reduces the performance increase to as little as 10% to 20%. While message passing might make sense for some tasks, it's not going to be quick enough to do things in 16ms and achieve the magical 60fps. Eventually shared memory is going to be needed, and if we get that far I think there will have to be some sort of acknowledgement that these performance-related features can't possibly be foolproof. Oh, and an asynchronous thread safe DOM, please and thanks :)
• tracker1 12y ago
  I've been thinking that something combined with the use of async functions (es7) could be used for Shared* locking... sharedObject.lock(^() => { /* use object, which is locked until async promise resolves/rejects */ }); where `^` is a short key for an async lambda function... `async` keyword could be used too... just throwing the `^` out there. This could lock the object, allowing for an async function to execute... when the async function promise resolves, the lock is released... it would have to be limited to async functions though. but that would likely hit the JS engines around the same time as any shared objects anyway.
  • tracker1 12y ago
    For me, the biggest problems with workers, is that you can't simply pass the functions that the worker needs (separated from state) from the main window... it means you're creating a separate script for workers, which isn't so bad, just not always easy to reason around. It also makes isomorphic interfaces (async node & browser) slightly harder.