Change search
Link to record
Permanent link

Direct link
BETA
Martinsen, Jan Kasper
Publications (10 of 10) Show all publications
Martinsen, J. K., Grahn, H. & Isberg, A. (2017). Combining thread-level speculation and just-in-time compilation in Google’s V8 JavaScript engine. Concurrency and Computation, 29(1), Article ID e3826.
Open this publication in new window or tab >>Combining thread-level speculation and just-in-time compilation in Google’s V8 JavaScript engine
2017 (English)In: Concurrency and Computation, ISSN 1532-0626, E-ISSN 1532-0634, Vol. 29, no 1, article id e3826Article in journal (Refereed) Published
Abstract [en]

Summary: Thread-level speculation can be used to take advantage of multicore architectures for JavaScript in web applications. We extend previous studies with these main contributions; we implement thread-level speculation in the state-of-the art just-in-time-enabled JavaScript engine V8 and make the measurements in the Chromium web browser both from Google instead of using an interpreted JavaScript engine. We evaluate the thread-level speculation and just-in-time compilation combination on 15 very popular web applications, 20 HTML5 demos from the JS1K competition, and 4 Google Maps use cases. The performance is evaluated on two, four, and eight cores. The results clearly show that it is possible to successfully combine thread-level speculation and just-in-time compilation. This makes it possible to take advantage of multicore architectures for web applications while hiding the details of parallel programming from the programmer. Further, our results show an average speedup for the thread-level speculation and just-in-time compilation combination by a factor of almost 3 on four cores and over 4 on eight cores, without changing any of the JavaScript source code.

Place, publisher, year, edition, pages
Wiley Online Library, 2017
Keywords
Computer architecture; Computer programming; Engines; High level languages; Just in time production; Parallel programming; Software architecture; World Wide Web, Javascript; Just in time; Just-in-time compilation; Multicore architectures; Source codes; State of the art; Thread level speculation; WEB application, Multicore programming
National Category
Computer Engineering Computer Sciences
Identifiers
urn:nbn:se:bth-13219 (URN)10.1002/cpe.3826 (DOI)000390562700002 ()2-s2.0-84966359864 (Scopus ID)
Available from: 2016-10-03 Created: 2016-10-03 Last updated: 2018-02-02Bibliographically approved
Martinsen, J. K., Grahn, H. & Isberg, A. (2015). The Effects of Parameter Tuning in Software Thread-Level Speculation in JavaScript Engines. ACM Transactions on Architecture and Code Optimization, 11(4)
Open this publication in new window or tab >>The Effects of Parameter Tuning in Software Thread-Level Speculation in JavaScript Engines
2015 (English)In: ACM Transactions on Architecture and Code Optimization, ISSN 1544-3566, Vol. 11, no 4Article in journal (Refereed) Published
Abstract [en]

JavaScript is a sequential programming language that has a large potential for parallel execution in Web applications. Thread-level speculation can take advantage of this, but it has a large memory overhead. In this article, we evaluate the effects of adjusting various parameters for thread-level speculation. Our results clearly show that thread-level speculation is a useful technique for taking advantage of multicore architectures for JavaScript in Web applications, that nested speculation is required in thread-level speculation, and that the execution characteristics of Web applications significantly reduce the needed memory, the number of threads, and the depth of our speculation.

Place, publisher, year, edition, pages
ACM, 2015
Keywords
Design, Languages, Performance, Experimentation, Web applications, multithreading, speculative execution, dynamic parallelization, virtual machines
National Category
Computer Sciences Computer Engineering
Identifiers
urn:nbn:se:bth-6332 (URN)10.1145/2686036 (DOI)000348232000012 ()
Projects
EASE - Embedded Applications Software Engineering
Available from: 2015-05-26 Created: 2015-05-26 Last updated: 2018-02-02Bibliographically approved
Martinsen, J. K., Grahn, H. & Isberg, A. (2014). An argument for thread-level speculation and just-in-time compilation in the google's v8 javascript engine. In: : . Paper presented at ACM International Conference on Computing Frontiers (CF). Cagliari: ACM
Open this publication in new window or tab >>An argument for thread-level speculation and just-in-time compilation in the google's v8 javascript engine
2014 (English)Conference paper, Published paper (Refereed)
Abstract [en]

Thread-Level Speculation can be used to take advantage of multicore architectures for web applications. We have implemented Thread-Level Speculation in the state-of-the-art JavaScript engine V8 instead of using an interpreted JavaScript engine. We evaluate the implementation with the Chromium web browser on 15 popular web applications for 2, 4, and 8 cores. The results show that it is benecial to combine Thread-Level Speculation and Just-in-time compi-lation and that it is possible to take advantage of multicore architectures while hiding the details of parallel program-ming from the programmer of web applications.

Place, publisher, year, edition, pages
Cagliari: ACM, 2014
Keywords
Applications, Engines, High level languages, Software architecture Javascript, Just in time, Just-in-time compilation, Multicore architectures, Thread level speculation, WEB application
National Category
Computer Sciences
Identifiers
urn:nbn:se:bth-6528 (URN)10.1145/2597917.2597950 (DOI)9781450328708 (ISBN)
Conference
ACM International Conference on Computing Frontiers (CF)
Projects
EASE - Embedded Applications Software Engineering
Available from: 2014-11-24 Created: 2014-11-24 Last updated: 2018-02-02Bibliographically approved
Martinsen, J. K. (2014). Design and Implementation of Thread-Level Speculation in JavaScript Engines. (Doctoral dissertation). Karlskrona: Blekinge Tekniska Högskola
Open this publication in new window or tab >>Design and Implementation of Thread-Level Speculation in JavaScript Engines
2014 (English)Doctoral thesis, comprehensive summary (Other academic)
Abstract [en]

Two important trends in computer systems are that applications are moved to the Internet as web applications, and that computer systems are getting an increasing number of cores to increase the performance. It has been shown that JavaScript in web applications has a large potential for parallel execution despite the fact that JavaScript is a sequential language. In this thesis, we show that JavaScript execution in web applications and in benchmarks are fundamentally different and that an effect of this is that Just-in-time compilation does often not improve the execution time, but rather increases the execution time for JavaScript in web applications. Since there is a significant potential for parallel computation in JavaScript for web applications, we show that Thread-Level Speculation can be used to take advantage of this in a manner completely transparent to the programmer. The Thread-Level Speculation technique is very suitable for improving the performance of JavaScript execution in web applications; however we observe that the memory overhead can be substantial. Therefore, we propose several techniques for adaptive speculation as well as for memory reduction. In the last part of this thesis we show that Just-in-time compilation and Thread-Level Speculation are complementary techniques. The execution characteristics of JavaScript in web applications are very suitable for combining Just-in-time compilation and Thread-Level Speculation. Finally, we show that Thread-Level Speculation and Just-in-time compilation can be combined to reduce power usage on embedded devices.

Place, publisher, year, edition, pages
Karlskrona: Blekinge Tekniska Högskola, 2014. p. 202
Series
Blekinge Institute of Technology Doctoral Dissertation Series, ISSN 1653-2090 ; 8
Keywords
parallel computation, web applications, thread-level speculation
National Category
Computer and Information Sciences
Identifiers
urn:nbn:se:bth-00589 (URN)oai:bth.se:forskinfo02E94D7D415A3A73C1257CAF004E5E06 (Local ID)978-91-7295-281-2 (ISBN)oai:bth.se:forskinfo02E94D7D415A3A73C1257CAF004E5E06 (Archive number)oai:bth.se:forskinfo02E94D7D415A3A73C1257CAF004E5E06 (OAI)
External cooperation:
Available from: 2014-06-17 Created: 2014-04-03 Last updated: 2018-01-11Bibliographically approved
Martinsen, J. K., Grahn, H. & Isberg, A. (2014). Heuristics for Thread-Level Speculation in Web Applications. IEEE Computer Architecture Letters, 13(2), 77-80
Open this publication in new window or tab >>Heuristics for Thread-Level Speculation in Web Applications
2014 (English)In: IEEE Computer Architecture Letters, ISSN 1556-6056, Vol. 13, no 2, p. 77-80Article in journal (Refereed) Published
Abstract [en]

JavaScript is a sequential programming language, and Thread-Level Speculation has been proposed to dynamically extract parallelism in order to take advantage of parallel hardware. In previous work, we have showed significant speed-ups with a simple on/off speculation heuristic. In this paper, we propose and evaluate three heuristics for dynamically adapt the speculation: a 2-bit heuristic, an exponential heuristic, and a combination of these two. Our results show that the combined heuristic is able to both increase the number of successful speculations and decrease the execution time for 15 popular web applications.

Place, publisher, year, edition, pages
IEEE, 2014
Keywords
Multicore processors, Parallel Computing, Automatic Parallelization, JavaScript
National Category
Computer Sciences
Identifiers
urn:nbn:se:bth-6342 (URN)10.1109/L-CA.2013.26 (DOI)000346979300006 ()oai:bth.se:forskinfo830C67FFA1E26306C1257C2F005135BC (Local ID)oai:bth.se:forskinfo830C67FFA1E26306C1257C2F005135BC (Archive number)oai:bth.se:forskinfo830C67FFA1E26306C1257C2F005135BC (OAI)
Available from: 2015-05-26 Created: 2013-11-26 Last updated: 2018-05-24Bibliographically approved
Martinsen, J. K., Grahn, H., Isberg, A. & Sundström, H. (2014). Reducing Memory in Software-Based Thread-Level Speculation for JavaScript Virtual Machine Execution of Web Applications. In: 2014 IEEE INTERNATIONAL CONFERENCE ON HIGH PERFORMANCE COMPUTING AND COMMUNICATIONS, 2014 IEEE 6TH INTL SYMP ON CYBERSPACE SAFETY AND SECURITY, 2014 IEEE 11TH INTL CONF ON EMBEDDED SOFTWARE AND SYST (HPCC,CSS,ICESS): . Paper presented at 16th IEEE International Conference on High Performance Computing and Communications HPCC 2014\11th IEEE International Conference on Embedded Software and Systems ICESS 2014\6th International Symposium on Cyberspace Safety and Security CSS 2014, Paris (pp. 181-184). Elsevier
Open this publication in new window or tab >>Reducing Memory in Software-Based Thread-Level Speculation for JavaScript Virtual Machine Execution of Web Applications
2014 (English)In: 2014 IEEE INTERNATIONAL CONFERENCE ON HIGH PERFORMANCE COMPUTING AND COMMUNICATIONS, 2014 IEEE 6TH INTL SYMP ON CYBERSPACE SAFETY AND SECURITY, 2014 IEEE 11TH INTL CONF ON EMBEDDED SOFTWARE AND SYST (HPCC,CSS,ICESS), Elsevier, 2014, p. 181-184Conference paper, Published paper (Refereed)
Abstract [en]

Thread-Level Speculation has been used to take advantage of multicore processors in virtual execution environments for the sequential JavaScript scripting language. While the results are promising the memory overhead is high. Here we propose to reduce the memory usage by limiting the checkpoint depth based on an in-depth study of the memory and execution time effects. We also propose an adaptive heuristic to dynamically adjust the checkpoints. We evaluate this using 15 web applications on an 8-core computer. The results show that the memory overhead is reduced for Thread-Level Speculation by over 90% as compared to storing all checkpoints. Further, the performance is often better than when storing all the checkpoints and at worst 4% slower.

Place, publisher, year, edition, pages
Elsevier, 2014
Keywords
Internet;Java;authoring languages;checkpointing;multiprocessing systems;virtual machines;JavaScript scripting language;Javascript virtual machine execution;Web applications;checkpoint depth;memory overhead;memory usage;multicore processor;software-based thread-level speculation;virtual execution environment;Electronic publishing;Encyclopedias;Instruction sets;Internet;Limiting;Memory management;multicore;thread-level speculation;web applications
National Category
Computer Engineering Computer Sciences
Identifiers
urn:nbn:se:bth-11410 (URN)10.1109/HPCC.2014.34 (DOI)000380560600028 ()978-1-4799-6123-8 (ISBN)
Conference
16th IEEE International Conference on High Performance Computing and Communications HPCC 2014\11th IEEE International Conference on Embedded Software and Systems ICESS 2014\6th International Symposium on Cyberspace Safety and Security CSS 2014, Paris
Projects
EASE - Embedded Applications Software Engineering
Available from: 2016-01-14 Created: 2016-01-14 Last updated: 2018-02-02Bibliographically approved
Martinsen, J. K., Grahn, H. & Isberg, A. (2013). Preliminary Results of Combining Thread-Level Speculation and Just-in-Time Compilation in Google’s V8. In: : . Paper presented at Sixth Swedish Workshop on Multicore Computing (MCC-13). Halmstad: Halmstad University
Open this publication in new window or tab >>Preliminary Results of Combining Thread-Level Speculation and Just-in-Time Compilation in Google’s V8
2013 (English)Conference paper, Published paper (Refereed)
Abstract [en]

We present the first implementation of Thread-Level Speculation in combination with Just-in-time compilation. The implementation is done in Google’s V8, a well-known JavaScript engine, and evaluated on 15 popular web application executing on 2, 4, and 8 core computers. Our results show an average speedup of 2.9 on 4 cores, without any JavaScript code modifications. Further, we have found that the Just-in-time compilation time is significant, and that most functions are lazily compiled (approximately 80%) and that V8 contains features that are advantageous in Thread-Level Speculation.

Place, publisher, year, edition, pages
Halmstad: Halmstad University, 2013
National Category
Software Engineering Computer Sciences
Identifiers
urn:nbn:se:bth-6847 (URN)oai:bth.se:forskinfo5596B2DD128E4C64C1257C2F004C9B0B (Local ID)oai:bth.se:forskinfo5596B2DD128E4C64C1257C2F004C9B0B (Archive number)oai:bth.se:forskinfo5596B2DD128E4C64C1257C2F004C9B0B (OAI)
Conference
Sixth Swedish Workshop on Multicore Computing (MCC-13)
Available from: 2013-11-29 Created: 2013-11-26 Last updated: 2018-02-02Bibliographically approved
Martinsen, J. K., Grahn, H. & Isberg, A. (2013). Using speculation to enhance JavaScript performance in web applications. IEEE Internet Computing, 17(2), 10-19
Open this publication in new window or tab >>Using speculation to enhance JavaScript performance in web applications
2013 (English)In: IEEE Internet Computing, ISSN 1089-7801, E-ISSN 1941-0131, Vol. 17, no 2, p. 10-19Article in journal (Refereed) Published
Abstract [en]

JavaScript lets developers provide client-side interactivity in Web applications, but because it is sequential, it can't take advantage of multicore processors. Thread-level speculation (TLS) addresses this issue by enabling the speculation of JavaScript function calls and thus exploits the parallel performance potential multicore processors provide. The authors implemented TLS in the Squirrelfish JavaScript engine, which is part of the WebKit browser environment. They evaluate their approach using 15 popular Web applications on an eight-core computer, and show significant speed-ups without any modifications to the JavaScript source code.

Place, publisher, year, edition, pages
IEEE, 2013
Keywords
JavaScript function calls, multicore processors, parallel performance, thread-level speculation
National Category
Computer Sciences
Identifiers
urn:nbn:se:bth-6798 (URN)10.1109/MIC.2012.146 (DOI)000316505700004 ()oai:bth.se:forskinfo10A9BE122B64EF90C1257B64003BA3C6 (Local ID)oai:bth.se:forskinfo10A9BE122B64EF90C1257B64003BA3C6 (Archive number)oai:bth.se:forskinfo10A9BE122B64EF90C1257B64003BA3C6 (OAI)
External cooperation:
Available from: 2013-12-17 Created: 2013-05-07 Last updated: 2018-02-02Bibliographically approved
Martinsen, J. K., Grahn, H. & Isberg, A. (2012). A Limit Study of Thread-Level Speculation in JavaScript Engines --- Initial Results. In: : . Paper presented at Fifth Swedish Workshop on Multicore Computing (MCC). Stockholm: Swedish Multicore Initiative
Open this publication in new window or tab >>A Limit Study of Thread-Level Speculation in JavaScript Engines --- Initial Results
2012 (English)Conference paper, Published paper (Other academic)
Abstract [en]

JavaScript is a programming language for interactive clientside functionalities in web applications. It is a sequential pro- gramming language, so it cannot take advantage of multicore processors. Previously Thread-Level Speculation has been used to take advantage of multicore processors for JavaScript execution in web applications with promising results execu- tion time wise, but with a large memory overhead. In this study we have evaluated the effects of limiting the amount of memory, the number of threads and the depth of specula- tion in Thread-Level Speculation. Our results indicate that we can tune these parameters to improve execution time and reduce the memory overhead.

Place, publisher, year, edition, pages
Stockholm: Swedish Multicore Initiative, 2012
National Category
Computer Sciences
Identifiers
urn:nbn:se:bth-7089 (URN)oai:bth.se:forskinfo820671E9E13A582BC1257AD00005ABD9 (Local ID)oai:bth.se:forskinfo820671E9E13A582BC1257AD00005ABD9 (Archive number)oai:bth.se:forskinfo820671E9E13A582BC1257AD00005ABD9 (OAI)
Conference
Fifth Swedish Workshop on Multicore Computing (MCC)
Available from: 2012-12-12 Created: 2012-12-10 Last updated: 2018-02-02Bibliographically approved
Martinsen, J. K. & Grahn, H. (2011). Thread-level speculation as an optimization technique in Web Applications Initial results. In: : . Paper presented at IEEE International Symposium on Industrial Embedded Systems, SIES. Västerås: IEEE
Open this publication in new window or tab >>Thread-level speculation as an optimization technique in Web Applications Initial results
2011 (English)Conference paper, Published paper (Refereed)
Abstract [en]

Web Applications have become increasingly popular as they allow developers to use an uniform platform for user interactions. The dynamic programming language JavaScript used in most Web Applications has performance penalties, that have been addressed by traditional optimization techniques. We have found that while the performance gain of such techniques are positive for a set of established benchmarks, it often fails to improve the performance of real-life Web Applications. We suggest Thread-Level Speculation (TLS) at the JavaScript function level to automatically extract parallelism to gain performance. There have been multiple TLS proposals in both hardware and software, but little work has been done within JavaScript. Currently we are implementing our TLS ideas in a state-of-the-art JavaScript engine targeted for embedded mobile devices.

Place, publisher, year, edition, pages
Västerås: IEEE, 2011
Keywords
JavaScript, Multithreading, Parallel Computing, Runtime environment, Speculative execution
National Category
Software Engineering
Identifiers
urn:nbn:se:bth-7370 (URN)10.1109/SIES.2011.5953686 (DOI)oai:bth.se:forskinfo9A0D35F040E3A722C1257979003874A2 (Local ID)9781612848204 (ISBN)oai:bth.se:forskinfo9A0D35F040E3A722C1257979003874A2 (Archive number)oai:bth.se:forskinfo9A0D35F040E3A722C1257979003874A2 (OAI)
Conference
IEEE International Symposium on Industrial Embedded Systems, SIES
Available from: 2012-09-18 Created: 2012-01-02 Last updated: 2018-02-02Bibliographically approved
Organisations

Search in DiVA

Show all publications