skip to main content

A fast in-place interpreter for WebAssembly

Published:31 October 2022Publication History
Skip Abstract Section

Abstract

WebAssembly (Wasm) is a compact, well-specified bytecode format that offers a portable compilation target with near-native execution speed. The bytecode format was specifically designed to be fast to parse, validate, and compile, positioning itself as a portable alternative to native code. It was pointedly not designed to be interpreted directly. Instead, design considerations at the time focused on competing with native code, utilizing optimizing compilers as the primary execution tier. Yet, in JIT scenarios, compilation time and memory consumption critically impact application startup, leading many Wasm engines to later deploy faster single-pass (baseline) compilers. Though faster, baseline compilers still take time and waste code space for infrequently executed code. A typical interpreter being infeasible, some engines resort to compiling Wasm not to machine code, but to a more compact, but easy to interpret format. This still takes time and wastes memory. Instead, we introduce in this article a fast in-place interpreter for WebAssembly, where no rewrite and no separate format is necessary. Our evaluation shows that in-place interpretation of Wasm code is space-efficient and fast, achieving performance on-par with interpreting a custom-designed internal format. This fills a hole in the execution tier space for Wasm, allowing for even faster startup and lower memory footprint than previous engine configurations.

References

  1. 1998. Hotspot internals: interpreter. https://openjdk.java.net/groups/hotspot/docs/RuntimeOverview.html (Accessed 2022-4-07) Google ScholarGoogle Scholar
  2. 2015. lli - directly execute programs from LLVM bitcode. https://llvm.org/docs/CommandGuide/lli.html (Accessed 2022-4-12) Google ScholarGoogle Scholar
  3. 2018. https://v8.dev/blog/liftoff (Accessed 2022-4-07) Google ScholarGoogle Scholar
  4. 2018. TurboFan: V8’s Optimizing Compiler. https://v8.dev/docs/turbofan (Accessed 2021-07-29) Google ScholarGoogle Scholar
  5. 2018. WAVM: a non-browser WebAssembly virtual machine. https://github.com/WAVM/WAVM (Accessed 2022-1-10) Google ScholarGoogle Scholar
  6. 2019. A New Bytecode Format for JavaScriptCore. https://webkit.org/blog/9329/a-new-bytecode-format-for-javascriptcore/ (Accessed 2022-04-07) Google ScholarGoogle Scholar
  7. 2020. The edge of the multi-cloud. https://www.fastly.com/cassets/6pk8mg3yh2ee/79dsHLTEfYIMgUwVVllaa4/5e5330572b8f317f72e16696256d8138/WhitePaper-Multi-Cloud.pdf (Accessed 2021-07-06) Google ScholarGoogle Scholar
  8. 2020. Wasm3: The fastest WebAssembly interpreter, and the most universal runtime.. https://github.com/wasm3/wasm3 (Accessed 2021-08-11) Google ScholarGoogle Scholar
  9. 2021. A fast WebAssembly Interpreter design in WASM-Micro-Runtime. https://www.intel.com/content/www/us/en/developer/articles/technical/webassembly-interpreter-design-wasm-micro-runtime.html (Accessed 2022-09-19) Google ScholarGoogle Scholar
  10. 2021. JavaScriptCore, the built-in JavaScript engine for WebKit. https://trac.webkit.org/wiki/JavaScriptCore (Accessed 2021-07-29) Google ScholarGoogle Scholar
  11. 2021. SpiderMonkey: Mozilla’s JavaScript and WebAssembly engine. https://spidermonkey.dev (Accessed 2021-07-29) Google ScholarGoogle Scholar
  12. 2021. V8 Development Site. https://v8.dev (Accessed 2021-07-29) Google ScholarGoogle Scholar
  13. 2021. Wasmer: A Fast and Secure WebAssembly Runtime. https://github.com/wasmerio/wasmer (Accessed 2021-07-06) Google ScholarGoogle Scholar
  14. 2021. Wasmtime: a standalone runtime for WebAssembly. https://github.com/bytecodealliance/wasmtime (Accessed 2021-08-11) Google ScholarGoogle Scholar
  15. 2022. Ignition: a fast low-level interpreter. https://v8.dev/docs/ignition (Accessed 2022-04-11) Google ScholarGoogle Scholar
  16. 2022. Labels as Values (GNU Compiler Collection). https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html (Accessed 2022-04-11) Google ScholarGoogle Scholar
  17. 2022. LEB128. https://en.wikipedia.org/wiki/LEB128 (Accessed 2022-04-11) Google ScholarGoogle Scholar
  18. 2022. WebAssembly Micro Runtime (WAMR). https://github.com/bytecodealliance/wasm-micro-runtime (Accessed 2022-04-11) Google ScholarGoogle Scholar
  19. Nada Amin and Tiark Rompf. 2017. Collapsing Towers of Interpreters. Proc. ACM Program. Lang., 2, POPL (2017), Article 52, dec, 33 pages. https://doi.org/10.1145/3158140 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Gergö Barany. 2014. Python Interpreter Performance Deconstructed. In Proceedings of the Workshop on Dynamic Languages and Applications (Dyla’14). Association for Computing Machinery, New York, NY, USA. 1–9. isbn:9781450329163 https://doi.org/10.1145/2617548.2617552 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. James R. Bell. 1973. Threaded Code. Commun. ACM, 16, 6 (1973), jun, 370–372. issn:0001-0782 https://doi.org/10.1145/362248.362270 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. Carl Friedrich Bolz, Antonio Cuni, Maciej Fijalkowski, and Armin Rigo. 2009. Tracing the Meta-Level: PyPy’s Tracing JIT Compiler. In Proceedings of the 4th Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages and Programming Systems (ICOOOLPS ’09). Association for Computing Machinery, New York, NY, USA. 18–25. isbn:9781605585413 https://doi.org/10.1145/1565824.1565827 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Stefan Brunthaler. 2010. Efficient Interpretation Using Quickening. In Proceedings of the 6th Symposium on Dynamic Languages (DLS ’10). Association for Computing Machinery, New York, NY, USA. 1–14. isbn:9781450304054 https://doi.org/10.1145/1869631.1869633 Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Kevin Casey, M. Anton Ertl, and David Gregg. 2007. Optimizing Indirect Branch Prediction Accuracy in Virtual Machine Interpreters. ACM Trans. Program. Lang. Syst., 29, 6 (2007), oct, 37–es. issn:0164-0925 https://doi.org/10.1145/1286821.1286828 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. Kevin Casey, David Gregg, and M. Anton Ertl. 2005. Tiger – an Interpreter Generation Tool. In Proceedings of the 14th International Conference on Compiler Construction (CC’05). Springer-Verlag, Berlin, Heidelberg. 246–249. isbn:3540254110 https://doi.org/10.1007/978-3-540-31985-6_18 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Po-Yung Chang, Eric Hao, and Yale N Patt. 1997. Target prediction for indirect jumps. ACM SIGARCH Computer Architecture News, 25, 2 (1997), 274–283. Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. Charlie Curtsinger and Emery D. Berger. 2013. STABILIZER: Statistically Sound Performance Evaluation. In Proceedings of the Eighteenth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’13). Association for Computing Machinery, New York, NY, USA. 219–228. isbn:9781450318709 https://doi.org/10.1145/2451116.2451141 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Brian Davis, Andrew Beatty, Kevin Casey, David Gregg, and John Waldron. 2003. The Case for Virtual Register Machines. In Proceedings of the 2003 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’03). Association for Computing Machinery, New York, NY, USA. 41–49. isbn:1581136552 https://doi.org/10.1145/858570.858575 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Alan Demers, Mark Weiser, Barry Hayes, Hans Boehm, Daniel Bobrow, and Scott Shenker. 1989. Combining Generational and Conservative Garbage Collection: Framework and Implementations. In Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’90). Association for Computing Machinery, New York, NY, USA. 261–269. isbn:0897913434 https://doi.org/10.1145/96709.96735 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Robert B. K. Dewar. 1975. Indirect Threaded Code. Commun. ACM, 18, 6 (1975), jun, 330–331. issn:0001-0782 https://doi.org/10.1145/360825.360849 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. Amer Diwan, Eliot Moss, and Richard Hudson. 1992. Compiler Support for Garbage Collection in a Statically Typed Language. In Proceedings of the ACM SIGPLAN 1992 Conference on Programming Language Design and Implementation (PLDI ’92). Association for Computing Machinery, New York, NY, USA. 273–282. isbn:0897914759 https://doi.org/10.1145/143095.143140 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. M. Anton Ertl and David Gregg. 2004. Combining Stack Caching with Dynamic Superinstructions. In Proceedings of the 2004 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’04). Association for Computing Machinery, New York, NY, USA. 7–14. isbn:1581139098 https://doi.org/10.1145/1059579.1059583 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. M. Anton Ertl and David Gregg. 2004. Combining Stack Caching with Dynamic Superinstructions. In Proceedings of the 2004 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’04). Association for Computing Machinery, New York, NY, USA. 7–14. isbn:1581139098 https://doi.org/10.1145/1059579.1059583 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. M. Anton Ertl, David Gregg, Andreas Krall, and Bernd Paysan. 2002. Vmgen: A Generator of Efficient Virtual Machine Interpreters. Softw. Pract. Exper., 32, 3 (2002), mar, 265–294. issn:0038-0644 https://doi.org/10.1002/spe.434 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Y. Futamura. 1983. Partial computation of programs.. Lecture Notes in Computer Science, 147 (1983). Google ScholarGoogle ScholarCross RefCross Ref
  36. Andreas Gal, Brendan Eich, Mike Shaver, David Anderson, David Mandelin, Mohammad R. Haghighat, Blake Kaplan, Graydon Hoare, Boris Zbarsky, Jason Orendorff, Jesse Ruderman, Edwin W. Smith, Rick Reitmaier, Michael Bebenita, Mason Chang, and Michael Franz. 2009. Trace-Based Just-in-Time Type Specialization for Dynamic Languages. In Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’09). Association for Computing Machinery, New York, NY, USA. 465–478. isbn:9781605583921 https://doi.org/10.1145/1542476.1542528 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Robbert Gurdeep Singh and Christophe Scholliers. 2019. WARDuino: A Dynamic WebAssembly Virtual Machine for Programming Microcontrollers. In Proceedings of the 16th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes (MPLR 2019). Association for Computing Machinery, New York, NY, USA. 27–36. isbn:9781450369770 https://doi.org/10.1145/3357390.3361029 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Andreas Haas, Andreas Rossberg, Derek L. Schuff, Ben L. Titzer, Michael Holman, Dan Gohman, Luke Wagner, Alon Zakai, and JF Bastien. 2017. Bringing the Web up to Speed with WebAssembly. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). Association for Computing Machinery, New York, NY, USA. 185–200. isbn:9781450349888 https://doi.org/10.1145/3062341.3062363 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Xiaowen Hu, David Zhao, Herbert Jordan, and Bernhard Scholz. 2021. An Efficient Interpreter for Datalog by De-Specializing Relations. PLDI 2021. Association for Computing Machinery, New York, NY, USA. 681–695. isbn:9781450383912 https://doi.org/10.1145/3453483.3454070 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Tomas Kalibera, Petr Maj, Floreal Morandat, and Jan Vitek. 2014. A Fast Abstract Syntax Tree Interpreter for R. In Proceedings of the 10th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments (VEE ’14). Association for Computing Machinery, New York, NY, USA. 89–102. isbn:9781450327640 https://doi.org/10.1145/2576195.2576205 Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Takafumi Kataoka, Tomoharu Ugawa, and Hideya Iwasaki. 2018. A Framework for Constructing Javascript Virtual Machines with Customized Datatype Representations. In Proceedings of the 33rd Annual ACM Symposium on Applied Computing (SAC ’18). Association for Computing Machinery, New York, NY, USA. 1238–1247. isbn:9781450351911 https://doi.org/10.1145/3167132.3167266 Google ScholarGoogle ScholarDigital LibraryDigital Library
  42. Channoh Kim, Sungmin Kim, Hyeon Gyu Cho, Dooyoung Kim, Jaehyeok Kim, Young H. Oh, Hakbeom Jang, and Jae W. Lee. 2016. Short-Circuit Dispatch: Accelerating Virtual Machine Interpreters on Embedded Processors. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA). 291–303. https://doi.org/10.1109/ISCA.2016.34 Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. Borui Li, Hongchang Fan, Yi Gao, and Wei Dong. 2021. ThingSpire OS: A WebAssembly-Based IoT Operating System for Cloud-Edge Integration. In Proceedings of the 19th Annual International Conference on Mobile Systems, Applications, and Services (MobiSys ’21). Association for Computing Machinery, New York, NY, USA. 487–488. isbn:9781450384438 https://doi.org/10.1145/3458864.3466910 Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. John McCarthy. 1960. Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I. Commun. ACM, 3, 4 (1960), apr, 184–195. issn:0001-0782 https://doi.org/10.1145/367177.367199 Google ScholarGoogle ScholarDigital LibraryDigital Library
  45. Microsoft. 2021. ChakraCore: a JavaScript engine with a C API. https://github.com/chakra-core/ChakraCore (Accessed 2021-07-29) Google ScholarGoogle Scholar
  46. Todd Mytkowicz, Amer Diwan, Matthias Hauswirth, and Peter F. Sweeney. 2009. Producing Wrong Data without Doing Anything Obviously Wrong!. In Proceedings of the 14th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS XIV). Association for Computing Machinery, New York, NY, USA. 265–276. isbn:9781605584065 https://doi.org/10.1145/1508244.1508275 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. Manuel Nieke, Lennart Almstedt, and Rüdiger Kapitza. 2021. Edgedancer: Secure Mobile WebAssembly Services on the Edge. In Proceedings of the 4th International Workshop on Edge Systems, Analytics and Networking (EdgeSys ’21). Association for Computing Machinery, New York, NY, USA. 13–18. isbn:9781450382915 https://doi.org/10.1145/3434770.3459731 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Fabio Niephaus, Tim Felgentreff, and Robert Hirschfeld. 2018. GraalSqueak: A Fast Smalltalk Bytecode Interpreter Written in an AST Interpreter Framework. In Proceedings of the 13th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS ’18). Association for Computing Machinery, New York, NY, USA. 30–35. isbn:9781450358040 https://doi.org/10.1145/3242947.3242948 Google ScholarGoogle ScholarDigital LibraryDigital Library
  49. Mohammed Nurul-Hoque and Khaled A. Harras. 2021. Nomad: Cross-Platform Computational Offloading and Migration in Femtoclouds Using WebAssembly. In 2021 IEEE International Conference on Cloud Engineering (IC2E). 168–178. https://doi.org/10.1109/IC2E52221.2021.00032 Google ScholarGoogle ScholarCross RefCross Ref
  50. Kazunori Ogata, Hideaki Komatsu, and Toshio Nakatani. 2002. Bytecode Fetch Optimization for a Java Interpreter. In Proceedings of the 10th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS X). Association for Computing Machinery, New York, NY, USA. 58–67. isbn:1581135742 https://doi.org/10.1145/605397.605404 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Jens Palsberg. 2014. From Java to Mips in Four Nifty Steps. http://web.cs.ucla.edu/classes/spring11/cs132/kannan/index.html (Accessed 2022-4-07) Google ScholarGoogle Scholar
  52. Jinzhan Peng, Gansha Wu, and Guei-Yuan Lueh. 2004. Code Sharing among States for Stack-Caching Interpreter. In Proceedings of the 2004 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’04). Association for Computing Machinery, New York, NY, USA. 15–22. isbn:1581139098 https://doi.org/10.1145/1059579.1059584 Google ScholarGoogle ScholarDigital LibraryDigital Library
  53. Ian Piumarta and Fabio Riccardi. 1998. Optimizing Direct Threaded Code by Selective Inlining. In Proceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation (PLDI ’98). Association for Computing Machinery, New York, NY, USA. 291–300. isbn:0897919874 https://doi.org/10.1145/277650.277743 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Filip Pizlo. 2016. Introducing the B3 JIT Compiler. https://webkit.org/blog/5852/introducing-the-b3-jit-compiler/ (Accessed 2022-4-12) Google ScholarGoogle Scholar
  55. Todd A. Proebsting. 1995. Optimizing an ANSI C Interpreter with Superoperators. In Proceedings of the 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’95). Association for Computing Machinery, New York, NY, USA. 322–332. isbn:0897916921 https://doi.org/10.1145/199448.199526 Google ScholarGoogle ScholarDigital LibraryDigital Library
  56. Gregory B. Prokopski and Clark Verbrugge. 2008. Analyzing the Performance of Code-Copying Virtual Machines. SIGPLAN Not., 43, 10 (2008), oct, 403–422. issn:0362-1340 https://doi.org/10.1145/1449955.1449796 Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. Erven Rohou, Bharath Narasimha Swamy, and André Seznec. 2015. Branch prediction and the performance of interpreters — Don’t trust folklore. In 2015 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). 103–114. https://doi.org/10.1109/CGO.2015.7054191 Google ScholarGoogle ScholarCross RefCross Ref
  58. Gülfem Savrun-Yeniçeri, Wei Zhang, Huahan Zhang, Eric Seckler, Chen Li, Stefan Brunthaler, Per Larsen, and Michael Franz. 2014. Efficient Hosted Interpreters on the JVM. ACM Trans. Archit. Code Optim., 11, 1 (2014), Article 9, feb, 24 pages. issn:1544-3566 https://doi.org/10.1145/2532642 Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Yunhe Shi, David Gregg, Andrew Beatty, and M. Anton Ertl. 2005. Virtual Machine Showdown: Stack versus Registers. In Proceedings of the 1st ACM/USENIX International Conference on Virtual Execution Environments (VEE ’05). Association for Computing Machinery, New York, NY, USA. 153–163. isbn:1595930477 https://doi.org/10.1145/1064979.1065001 Google ScholarGoogle ScholarDigital LibraryDigital Library
  60. Ben L. Titzer. 2013. Harmonizing Classes, Functions, Tuples, and Type Parameters in Virgil III. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’13). Association for Computing Machinery, New York, NY, USA. 85–94. isbn:9781450320146 https://doi.org/10.1145/2491956.2491962 Google ScholarGoogle ScholarDigital LibraryDigital Library
  61. Ben L. Titzer. 2021. Wizard, An advanced WebAssembly Engine for Research. https://github.com/titzer/wizard-engine (Accessed 2021-07-29) Google ScholarGoogle Scholar
  62. Ben L. Titzer. 2022. Oopsla 2022 Artifact. https://github.com/titzer/oopsla22-artifact (Accessed 2021-10-1) Google ScholarGoogle Scholar
  63. Ben L. Titzer. 2022. OOPSLA 2022 Artifact for "A Fast in-place Interpreter for WebAssembly". https://doi.org/10.5281/zenodo.7093079 Google ScholarGoogle ScholarDigital LibraryDigital Library
  64. Ben L. Titzer and Jens Palsberg. 2005. Nonintrusive Precision Instrumentation of Microcontroller Software. In Proceedings of the 2005 ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES ’05). Association for Computing Machinery, New York, NY, USA. 59–68. isbn:1595930183 https://doi.org/10.1145/1065910.1065919 Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. Kevin Williams, Jason McCandless, and David Gregg. 2010. Dynamic Interpretation for Dynamic Scripting Languages. In Proceedings of the 8th Annual IEEE/ACM International Symposium on Code Generation and Optimization (CGO ’10). Association for Computing Machinery, New York, NY, USA. 278–287. isbn:9781605586359 https://doi.org/10.1145/1772954.1772993 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. Kevin Williams, Albert Noll, Andreas Gal, and David Gregg. 2008. Optimization Strategies for a Java Virtual Machine Interpreter on the Cell Broadband Engine. In Proceedings of the 5th Conference on Computing Frontiers (CF ’08). Association for Computing Machinery, New York, NY, USA. 189–198. isbn:9781605580777 https://doi.org/10.1145/1366230.1366265 Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. Thomas Würthinger, Andreas Wöß, Lukas Stadler, Gilles Duboscq, Doug Simon, and Christian Wimmer. 2012. Self-Optimizing AST Interpreters. SIGPLAN Not., 48, 2 (2012), oct, 73–82. issn:0362-1340 https://doi.org/10.1145/2480360.2384587 Google ScholarGoogle ScholarDigital LibraryDigital Library
  68. Bennet Yee, David Sehr, Gregory Dardyk, J. Bradley Chen, Robert Muth, Tavis Ormandy, Shiki Okasaka, Neha Narula, and Nicholas Fullagar. 2010. Native Client: A Sandbox for Portable, Untrusted X86 Native Code. Commun. ACM, 53, 1 (2010), jan, 91–99. issn:0001-0782 https://doi.org/10.1145/1629175.1629203 Google ScholarGoogle ScholarDigital LibraryDigital Library
  69. Alon Zakai. 2013. asm.js: an extraordinarily optimizable, low-level subset of JavaScript. http://asmjs.org (Accessed 2021-07-29) Google ScholarGoogle Scholar
  70. Mathew Zaleski, Marc Berndl, and Angela Demke Brown. 2005. Mixed Mode Execution with Context Threading. In Proceedings of the 2005 Conference of the Centre for Advanced Studies on Collaborative Research (CASCON ’05). IBM Press, 305–319. Google ScholarGoogle ScholarDigital LibraryDigital Library
  71. Qiang Zhang, Lei Xu, Xiangyu Zhang, and Baowen Xu. 2022. Quantifying the interpretation overhead of Python. Science of Computer Programming, 215 (2022), 102759. issn:0167-6423 https://doi.org/10.1016/j.scico.2021.102759 Google ScholarGoogle ScholarDigital LibraryDigital Library
  72. Massimiliano Zilli, Wolfgang Raschke, Reinhold Weiss, Johannes Loinig, and Christian Steger. 2015. Hardware/Software Co-Design for a High-Performance Java Card Interpreter in Low-End Embedded Systems. Microprocess. Microsyst., 39, 8 (2015), nov, 1076–1086. issn:0141-9331 https://doi.org/10.1016/j.micpro.2015.05.004 Google ScholarGoogle ScholarDigital LibraryDigital Library
  73. Massimiliano Zilli, Wolfgang Raschke, Reinhold Weiss, Christian Steger, and Johannes Loinig. 2015. A Light-Weight Compression Method for Java Card Technology. SIGBED Rev., 11, 4 (2015), jan, 13–18. https://doi.org/10.1145/2724942.2724944 Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. A fast in-place interpreter for WebAssembly

    Recommendations

    Comments

    Login options

    Check if you have access through your login credentials or your institution to get full access on this article.

    Sign in

    Full Access

    PDF Format

    View or Download as a PDF file.

    PDF

    eReader

    View online with eReader.

    eReader
    About Cookies On This Site

    We use cookies to ensure that we give you the best experience on our website.

    Learn more

    Got it!