Simpler Coordination of JavaScript Web Workers

Abstract

JavaScript is a popular sequential language for implementing Web applications. To enable concurrent execution of JavaScript code, modern JavaScript engines support the Web Workers API. Using this API, developers can spawn concurrent background workers from a distinguished main worker. These workers, which run on the same machine (e.g., to exploit multicore), interact via message-passing. The Web Workers API is relatively low-level, which makes implementing coordination protocols among background workers laborious and errorprone. To simplify this, we propose to hide the Web Workers API behind a coordination language that provides higher-level constructs. Importantly, developers already use JavaScript together with domain-specific languages HTML (for markup/structure) and CSS (for style/design); another domain-specific language (for coordination) seamlessly fits this practice. Using the coordination language Reo, we demonstrate the advantages and feasibility of this approach by example. We also present the necessary tool support (compiler; runtime library and API; front-end).

Centralized coordination vs. partially-distributed coordination with Reo and constraint automata

“…Despite this, we really have been talking about, and investigating, compiler technology for a general kind of communicating automata. Because also other programming languages can have semantics in terms of such automata (e.g., Rebeca [90,91] and Bip [29,30]), our findings may have applications beyond Reo. Moreover, although encountered by us in the context of Reo, mitigating overparallelization seems a generally interesting problem: specifying a system as many parallel processes may feel natural to a system designer, but implementing each of those processes as a thread may give poor performance.…”

“…The development of these two improvements would not have been possible without (the careful analysis of) the experimental results in this paper. It shall be interesting to see how these optimization techniques, in turn, affect our earlier real-world case studies with compiler-generated Reo implementations, such as the NAS Parallel Benchmarks [7] and RSA decryption [89].…”

Modular Programming of Synchronization and Communication Among Tasks in Parallel Programs

“…Originally, Reo is a language for specification of protocols among components in componentbased systems. However, it has qualities that make it attractive for our purpose as well: Reo provides high-level, graphical abstractions (protocols are specified as graphs, reminiscent of data-flow diagrams, but more expressive); it is intimately built upon the principle of separation of concerns (components in Reo are oblivious to the synchronization and communication between them); it has formal semantics and rigorous tool support (e.g., compilers for code generation [19]- [21]; model checkers for verification [22]- [24]). As a well-studied language, under research and development for over a decade, Reo seems exactly what we aim parallel programmers to provide.…”

“…Reo is fully independent from both the host language in which code is generated and the platform on which it is run. For instance, tools exist that generate code for Reo connectors in C [19], Java [20], JavaScript [21], and Scala [28]. Due to this independence, Reo can in principle be used to abstract away from platform-dependent synchronization and communication constructs and runtimes, and enforce protocols among tasks across heterogeneous platforms.…”