Doppio: Breaking the Browser Language Barrier
•Download as PPTX, PDF•
2 likes•1,051 views
Web browsers have become a de facto universal operating system, and JavaScript its instruction set. Unfortunately, running other languages in the browser is not generally possible. Translation to JavaScript is not enough because browsers are a hostile environment for other languages. Previous approaches are either non-portable or require extensive modifications for programs to work in a browser. This talk presents Doppio, a JavaScript-based runtime system that makes it possible to run unaltered applications written in general- purpose languages directly inside the browser. Doppio provides a wide range of runtime services, including a file system that enables local and external (cloud-based) storage, an unmanaged heap, sockets, blocking I/O, and multiple threads. We demonstrate Doppio's usefulness with two case studies: we extend Emscripten with Doppio, letting it run an unmodified C++ application in the browser with full functionality, and present DoppioJVM, an interpreter that runs unmodified JVM programs directly in the browser. While substantially slower than a native JVM, DoppioJVM makes it feasible to directly reuse existing, non compute-intensive code.
Recommended
More Related Content
What's hot
What's hot (20)
Viewers also liked
Viewers also liked (8)
Similar to Doppio: Breaking the Browser Language Barrier
Similar to Doppio: Breaking the Browser Language Barrier (20)
More from Emery Berger
More from Emery Berger (20)
Recently uploaded
Recently uploaded (20)
Doppio: Breaking the Browser Language Barrier
- 2. Java
- 3. Java
- 4. Motivating Example Java Chat Client
- 5. Motivating Example Java Chat Client Features: • Connects to multiple chat servers • Logs chats to file system • 1 thread per server
- 6. Motivating Example Java Chat Client Features: • Connects to multiple chat servers • Logs chats to file system • 1 thread per server
- 9. Breaking the Browser Language Barrier 1. Key Challenges 2. Doppio Runtime System 3. Proof-of-concept: DoppioJVM
- 10. Java I’m dynamic! Unsuitable for ahead-of-time compilation
- 11. Native VS Browser Threads Chat Process Java I’m dynamic !
- 12. Native VS Browser Workers (“Processes”) Threads Chat Process Java I’m dynamic !
- 13. Workers (“Processes”) Java I’m dynamic ! Native VS Browser Threads Chat Process Hey, how’s it going? Terrible.
- 14. Native VS Browser TCP Sockets Threads Chat Process Java I’m dynamic !
- 15. Native VS Browser TCP Sockets WebSockets Threads Chat Process Java I’m dynamic !
- 16. Native VS Browser File System TCP Sockets Threads Chat Process Java I’m dynamic !
- 17. Native VS Browser File System Persistent Storage SQL Database TCP Sockets Threads Chat Process Java I’m dynamic ! Key-value (<5MB) [localStorage] (>5MB) [WebSQL] Object Database (>5MB) [IndexedDB] “File System” (>5MB) [HTML5 FileSystem]
- 18. Native Browser Unmanaged VS Heap TCP Sockets File System Threads Chat Process Java I’m dynamic !
- 19. Native Browser Unmanaged VS Heap Nothing. TCP Sockets File System Threads Chat Process Java I’m dynamic !
- 20. TCP Sockets File System Threads Chat Process Java I’m dynamic ! Unmanaged Heap
- 21. File System TCP Sockets Threads Chat Process Java I’m dynamic ! Unmanaged Heap
- 22. Challenge #1 Browser Diversity
- 23. Challenge #1 Browser Diversity
- 24. Challenge #1 Browser Diversity
- 25. Browser Diversity Example: Storing Chat Client Logs
- 26. Browser Diversity Example: Storing Chat Client Logs Key-value (<5MB) [localStorage]
- 27. Browser Diversity Example: Storing Chat Client Logs * * SQL Database (>5MB) [WebSQL] Key-value (<5MB) [localStorage] * Only for temporary storage
- 28. Browser Diversity Example: Storing Chat Client Logs ** * * * * Object Database (>5MB) [IndexedDB] SQL Database (>5MB) [WebSQL] Key-value (<5MB) [localStorage] * Only for temporary storage ** Partial support
- 29. Browser Diversity Example: Storing Chat Client Logs Key-value (<5MB) [localStorage] ** Object Database (>5MB) [IndexedDB] * * SQL Database (>5MB) [WebSQL] * Only for temporary storage * * “File System” (>5MB) [HTML5 FileSystem] ** Partial support
- 30. Browser Diversity Example: Storing Chat Client Logs ** Object Database (>5MB) [IndexedDB] SQL Database (>5MB) [WebSQL] “File System” (>5MB) [HTML5 FileSystem] * Only for temporary storage ** Partial support
- 31. Challenge #2 Event-Driven Runtime Model
- 32. Challenge #2 Event-Driven Runtime Model
- 34. void main(String[] args) { Call Stack main … byte[] response = sendPing(); … } Chat Client PING/PONG in Java
- 35. void main(String[] args) { Call Stack main byte[] sendPing() { socket.write(PING); socket.read(readBuffer); return readBuffer; } sendPing … byte[] response = sendPing(); … } Chat Client PING/PONG in Java
- 36. Call Stack main sendPing socket.write void main(String[] args) { … byte[] response = sendPing(); … } byte[] sendPing() { socket.write(PING); socket.read(readBuffer); return readBuffer; } Chat Client PING/PONG in Java
- 37. Call Stack main sendPing socket.read void main(String[] args) { … byte[] response = sendPing(); … } byte[] sendPing() { socket.write(PING); socket.read(readBuffer); return readBuffer; } Chat Client PING/PONG in Java
- 38. void main(String[] args) { Call Stack main sendPing … byte[] response = sendPing(); … } byte[] sendPing() { socket.write(PING); socket.read(readBuffer); return readBuffer; } Chat Client PING/PONG in Java
- 39. void main(String[] args) { Call Stack main … byte[] response = sendPing(); … } byte[] sendPing() { socket.write(PING); socket.read(readBuffer); return readBuffer; } Chat Client PING/PONG in Java
- 40. Chat Client PING/PONG in JavaScript function main() { … var response = sendPing(); … } Call Stack main
- 41. Call Stack main function main() { … var response = sendPing(); … } Chat Client PING/PONG in JavaScript
- 42. Call Stack main function main() { function sendPing() { sendPing socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; ??? } … var response = sendPing(); … } Chat Client PING/PONG in JavaScript
- 43. Call Stack main sendPing socket.send function main() { … var response = sendPing(); … } function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; ??? } Chat Client PING/PONG in JavaScript
- 44. Call Stack main sendPing function main() { … var response = sendPing(); … } function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; ??? } Chat Client PING/PONG in JavaScript
- 45. Call Stack main sendPing function main() { … var response = sendPing(); … } function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; ??? } Chat Client PING/PONG in JavaScript
- 46. Call Stack main sendPing function main() { … var response = sendPing(); … } function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; ??? } Chat Client PING/PONG in JavaScript
- 47. Call Stack main function main() { function sendPing() { sendPing socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; while(noData) { /* Busy Wait?? */ } } … var response = sendPing(); … } Chat Client PING/PONG in JavaScript
- 48. Chat Client PING/PONG in JavaScript Call Stack main sendPing function main() { … var response = sendPing(); … } Browser Event Queue WebSocket message from chat server function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; while(noData) { /* Busy Wait?? */ } }
- 49. Chat Client PING/PONG in JavaScript function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; while(noData) { /* Busy Wait?? */ } } Call Stack main sendPing function main() { … var response = sendPing(); … } Browser Event Queue WebSocket message from chat server
- 50. Chat Client PING/PONG in JavaScript Call Stack main sendPing function main() { … var response = sendPing(); … } Browser Event Queue WebSocket message from chat server function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; while(noData) { /* Busy Wait?? */ } }
- 51. Chat Client PING/PONG in JavaScript Call Stack main function main() { function sendPing() { sendPing socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; return; } … var response = sendPing(); … } Browser Event Queue WebSocket message from chat server
- 52. Call Stack main function main() { … var response = sendPing(); return; } Browser Event Queue WebSocket message from chat server function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; return; } Chat Client PING/PONG in JavaScript
- 53. Call Stack function main() { … var response = sendPing(); return; } Browser Event Queue WebSocket message from chat server function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; return; } Chat Client PING/PONG in JavaScript
- 54. Call Stack function main() { … var response = sendPing(); return; } socket.onmessage callback Browser Event Queue function sendPing() { socket.send(PING); socket.onmessage = function(event) { // event.data has the PONG }; return; } Chat Client PING/PONG in JavaScript
- 55. Chat Client PING/PONG in JavaScript function main() { … var response = sendPing(); return; } function sendPing() { socket.send(PING); socket.onmessage = function({ // event.data has the PONG }; return; } void main(String[] args) { … byte[] response = sendPing(); … } byte[] sendPing() { socket.write(PING); socket.read(readBuffer); return readBuffer; }
- 56. Breaking the Browser Language Barrier 1. Key Challenges 2. Doppio Runtime System • Doppio Threads • Doppio File System • Doppio Sockets • Doppio Unmanaged Heap 3. Proof-of-concept: DoppioJVM
- 57. Doppio 100% JavaScript Runtime Library
- 58. 100% JavaScript Runtime Library Doppio Threads Doppio
- 59. 100% JavaScript Runtime Library Doppio TCP Sockets Doppio File System Doppio Unmanaged Heap Doppio Threads Doppio
- 60. Doppio Threads DoppioJVM Proof-of-concept: 100% JavaScript JVM Interpreter Doppio TCP Sockets Doppio File System Doppio Unmanaged Heap
- 61. Doppio Threads DoppioJVM Proof-of-concept: 100% JavaScript JVM Interpreter Doppio TCP Sockets Doppio File System Doppio Unmanaged Heap
- 62. Breaking the Browser Language Barrier 1. Key Challenges 2. Doppio Runtime System • Doppio Threads • Doppio File System • Doppio Sockets • Doppio Unmanaged Heap 3. Proof-of-concept: DoppioJVM
- 64. Doppio Threads java.lang.Thread JavaScript has one thread
- 65. Doppio Threads java.lang.Thread JavaScript has one thread ?
- 66. Doppio Threads java.lang.Thread JavaScript has one thread ? Doppio Thread Stack
- 67. Doppio Threads java.lang.Thread JavaScript has one thread ? Doppio Thread Stack ✓ Suspend ✓ Resume
- 68. Doppio Threads java.lang.Thread JavaScript has one thread Timesliced priority-based scheduling
- 69. Doppio Threads java.lang.Thread JavaScript has one thread Timesliced priority-based scheduling
- 70. Doppio Threads java.lang.Thread ✓ Language threads ✓ Responsive
- 71. Doppio Threads java.lang.Thread ✓ Language threads ✓ Responsive ✓ Synchronous I/O
- 72. Doppio Threads java.lang.Thread ✓ Language threads ✓ Responsive ✓ Synchronous I/O Doppio Threads
- 73. Breaking the Browser Language Barrier 1. Key Challenges 2. Doppio Runtime System • Doppio Threads • Doppio File System • Doppio Sockets • Doppio Unmanaged Heap 3. Proof-of-concept: DoppioJVM
- 74. Doppio File System java.io.UnixFileSystem
- 75. Doppio File System java.io.UnixFileSystem Doppio POSIX File System Interface
- 76. Doppio File System Key-value [localStorage] Object database [IndexedDB] “File System” [HTML5 FileSystem] Cloud Storage [Dropbox] RAM Disk Zip Archive java.io.UnixFileSystem Doppio POSIX File System Interface
- 77. Doppio File System Key-value [localStorage] Object database [IndexedDB] “File System” [HTML5 FileSystem] Cloud Storage [Dropbox] RAM Disk Zip Archive java.io.UnixFileSystem Doppio POSIX File System Interface
- 78. Breaking the Browser Language Barrier 1. Key Challenges 2. Doppio Runtime System • Doppio Threads • Doppio File System • Doppio Sockets • Doppio Unmanaged Heap 3. Proof-of-concept: DoppioJVM
- 79. Doppio TCP Sockets Natively-running Server Server TCP connection
- 80. Doppio TCP Sockets Natively-running Server WebSocket connection X Server
- 81. Doppio TCP Sockets Server java.net.PlainSocketImpl Doppio Sockets Natively-running Server WebSocket Connection What’s a WebSocket ?
- 82. Doppio TCP Sockets Server TCP connection WebSockify java.net.PlainSocketImpl Doppio Sockets Natively-running Server WebSocket Connection
- 83. Breaking the Browser Language Barrier 1. Key Challenges 2. Doppio Runtime System • Doppio Threads • Doppio File System • Doppio Sockets • Doppio Unmanaged Heap 3. Proof-of-concept: DoppioJVM
- 84. Doppio Unmanaged Heap sun.misc.Unsafe
- 85. Doppio Unmanaged Heap Need: • malloc • free sun.misc.Unsafe
- 86. Doppio Unmanaged Heap Binary Data Representations • ArrayBuffer • CanvasPixelArray • Array of 32-bit ints sun.misc.Unsafe
- 87. Doppio Unmanaged Heap Binary Data Representations • ArrayBuffer • CanvasPixelArray • Array of 32-bit ints 1:1 sun.misc.Unsafe
- 88. Doppio Unmanaged Heap Binary Data Representations • ArrayBuffer • CanvasPixelArray • Array of 32-bit ints 1:1 1:2 sun.misc.Unsafe
- 89. Doppio Unmanaged Heap Binary Data Representations • ArrayBuffer • CanvasPixelArray • Array of 32-bit ints 1:1 1:2 sun.misc.Unsafe Doppio Unmanaged Heap
- 90. Breaking the Browser Language Barrier 1. Key Challenges 2. Doppio Runtime System 3. Proof-of-concept: DoppioJVM
- 91. DoppioJVM OpenJDK Java Class Library sun.* Packages java.* Packages javax.* Packages etc…
- 92. DoppioJVM sun.misc Unsafe Doppio Unmanaged Heap java.io UnixFileSystem Doppio File System java.net PlainSocketImpl Doppio Sockets java.lang Thread Doppio Threads OpenJDK Java Class Library sun.* Packages java.* Packages javax.* Packages etc… Doppio OS Services
- 93. DoppioJVM sun.misc Unsafe java.io UnixFileSystem java.net PlainSocketImpl java.lang Thread OpenJDK Java Class Library sun.* Packages java.* Packages javax.* Packages etc… Java Objects JavaScript Objects Most Numeric Types JavaScript Numbers Java Arrays JavaScript Arrays 64-bit Integers gLong Library JVM Data Structures
- 94. DoppioJVM JVM Data Structures For Free sun.misc Unsafe java.io UnixFileSystem java.net PlainSocketImpl java.lang Thread OpenJDK Java Class Library sun.* Packages java.* Packages javax.* Packages etc… Java Objects JavaScript Objects Most Numeric Types JavaScript Numbers Java Arrays JavaScript Arrays 64-bit Integers gLong Library JVM GC JS GC
- 95. DoppioJVM JVM Data Structures For Free OpenJDK Java Class Library Java Objects JavaScript Objects Most Numeric Types JavaScript Numbers Java Arrays JavaScript Arrays 64-bit Integers gLong Library JVM GC JS GC Bytecode Interpreter JVM Features ClassLoader Monitors
- 96. in Action
- 97. in Action
- 98. in Action
- 99. in Action
- 100. in Action
- 101. DoppioJVM Native Compatibility Runs real, unmodified programs * • javac (44 KLOC) • Java compiler • javap (4 KLOC) • JVM class file disassembler • Kawa-Scheme (121 KLOC) • Scheme implementation on the JVM • Rhino (57 KLOC) • JavaScript implementation on the JVM
- 102. DoppioJVM Performance * * Caused by Safari memory leak: https://bugs.webkit.org/show_bug.cgi?id=119049
- 104. Contributions • Doppio: Bridges impedance mismatch between conventional languages and browser • Proof-of-concept: DoppioJVM
Editor's Notes
- Many programming languages, e.g. Java, Python, Ruby — just three examples. Lots of useful programs and libraries
- Unfortunately, only one language that runs across all browsers: JavaScript. Wouldn’t it be nice if we could take existing well-tested programs & libraries, and run them in the browser with no modifications?
- To motivate the problem: nonexistent text chat client in Java. Illustrates challenges of bringing conventional languages & their programs to browser.
- Chat client lets you connect to multiple chat servers at once, logs chats as text files, and encapsulates server connection in its own thread. Goal: take this Java chat client
- and run in browser. How?
- Compile Java source code of chat client into JavaScript?
- Unfortunately, infeasible for variety of reasons.
- Why? Key challenges.
- First problem: nature of Java itself. Java = dynamic language. Performing AOTcompilation on Java code rules out dynamic class loading, + many parts of the Java reflection API.
- Second problem more fundamental. Chat client uses multiple threads, all in same address space.
- JavaScript does not support threads. Instead: workers. These workers do not share same address space => cannot share memory with one another.
- Instead, communicate by sending messages. Thus, cannot simply map threads to workers — posing challenge to bringing chat client to web.
- Chat client uses TCP sockets to communicate with chat servers.
- But browser does not support TCP sockets. Instead: WebSockets, protocol implemented on top of TCP => chat client can’t communicate with chat servers, which expect regular TCP connections.
- To log chats, the chat client writes text files to file system.
- Browser doesn’t have file system. Instead, variety of other mechanisms for storing data, unevenly supported across browsers + variety of restrictions. One uses file system abstraction, but asynchronous & does not support blocking ops. More on that later.
- Unbeknownst to chat program, Java Class Library performs # of unsafe operations with explicit memory allocation, requiring unmanaged heap.
- Browser does not offer mechanism for explicit memory allocation. Not necessarily bad. Just not there.
- Chat client needs all these components to function properly.
- To run chat client in browser, we need to somehow emulate all these resources in browser.
- Challenge: browser diversity. Not just trying to bring chat client to one browser.
- Trying to bring to multiple browsers — unevenly implement various web standards. But not just one version of each browser.
- Multiple major versions in use. Not to mention desktop, tablet, & mobile diffs. Browser diversity —> major obstacle to bringing the resources chat client needs into browser. Let’s illustrate with example.
- Ignore version differences, and focus on latest version of each browser. As mentioned earlier, chat client needs to write log files into FS. # persistent storage mechanisms in browser that could use to emulate FS.
- All implement key-value store that gives programs GIGANTIC 5 MB of storage.
- Safari lets web pages store more data in SQL DB. Chrome and Opera offer same functionality, but don’t persist DB… :(
- Firefox and IE: web pages can persist data in object DB. Once again, Chrome & Opera don’t persist DB. IE’s implementation - also not fully spec-compliant. SURPRISE
- Finally, HTML5 FS. Only Chrome and Opera support this interface. Takeaway = if chat client wants to persist > 5 MB of logs in browser AND cares about browser compatibility,
- then must support three completely different storage interfaces. PITA
- Second complication stems from JS event-driven runtime model => pervasive asynchrony in JS code.
- In particular, JS I/O requires callbacks: painful for bringing conventional languages to browser.
- Walk through example: Chat client periodically sends PING to server to ensure connection alive, waits for PONG. Walk through Java, then try to directly translate to JS.
- Say, somewhere in main method, chat client fires off ping.
- sendPing function might look like this. Simplifying for presentation purposes.
- First, chat client writes PING command on socket to server.
- Then, blocking read to wait for response.
- Finally, returns data read off of wire.
- And chat client continues on merry way.
- Now, same thing in JS.
- Like before, main function calls sendPing.
- sendPing sends ping command on WebSocket (like before)
- Then, need to assign callback function on socket obj., which browser will call once gets data from chat server. But: problem.
- main function expects sendPing returns response from server. But sendPing does not have response yet; must wait for browser to call callback just registered.
- Now what? What do we do to return value main expects? JS: no sleep function to suspend execution & persist activation records for sendPing and main.
- Busy-wait? server does send WebSocket message to the browser…
- …ends up in browser event queue, which program has no access to. This q = mouse clicks, timer fires, and other events while JS executing. PLUS, if try to busy wait,
- …browser will kill script, because blocking progress. JS programs have no choice! must execute in CPS, periodically yield to browser event queue, scheduling next phase as new event.
- Only way to unblock browser event queue & receive WebSocket message from server = empty JS call stack
- So: sendPing returns
- and main returns
- Now, JS call stack empty Browser fires next event
- which triggers callback. But now - completely disrupted program.
- To port this Java code to JS: program needs to be completely restructured into CPS to allow breaks in execution for callbacks to execute.
- OK, challenges. Now, how Doppio Runtime System overcomes them.
- Doppio = 100% JS runtime library for bringing conventional languages to the web.
- We implement threads on top of JS’s event-driven runtime model. Language implementations use these threads: (1) keep programs responsive, (2) support synchronous I/O, (3) run multithreaded programs.
- Expose TCP socket interface on top of WebSockets, FS interface on top of various storage mechanisms available to the browser, and emulate unmanaged heap. These 3 services handle challenges of browser diversity - programs running in Doppio work across all major browsers.
- Using Doppio, we implement DoppioJVM; proof-of-concept JVM interpreter written in 100% JavaScript (TypeScript) can run unmodified programs straight from JAR files.
- DoppioJVM contains all features required to bring chat client to web.
- Doppio’s threads:
- Mentioned before: chat client encapsulates each server connection into own thread.
- Problem in browser because JS only has 1 thread.
- How to map multiple language-level threads onto one hardware thread?
- Doppio Threads - language implementations must explicitly maintain their stack state.
- Doppio Threads can then suspend execution by saving stack information into JS object, resume later using saved stack.
- build time sliced priority-based thread scheduler adjusts quanta dynamically for responsiveness. = support MT programs w/ preemptive semantics & long-running threads spanning multiple quanta,
- prevents freezing web page + keeps application responsive to I/O.
- But wait, there’s more!
- Can also support synchronous I/O by suspending threads when use JS asynchronous I/O, Resuming once needed information arrives
- Now, can hook up JVM threads to Doppio Threads. Chat client can spawn and run across multiple threads w/o needing to be modified.
- Now Doppio FS.
- Recall: chat client writes files to FS, normally implemented in UnixFileSystem class.
- The Doppio FS exposes POSIX FS interface in JavaScript.
- FS supports many backends most persistent storage mechanisms mentioned earlier Dropbox cloud storage zip files
- Can be mounted into arbitrary locations in Doppio DS dir. hierarchy = great flexibility for where chat client writes log files.
- On to network sockets.
- chat client expects to connect to chat server via TCP BUT - problem porting to browser…
- …no raw access to TCP Instead, WebSockets Server - no idea how to handle WebSocket conn.
- Using Doppio Threads, implement JVM’s synch socket abstraction on asynch JS WebSockets. But server - still no idea what WebSocket connection is.
- Fix with “WebSockify” Wraps server, transparently proxies WS connections to server as standard TCP connection. = no modification to client or server
- Last = unmanaged heap.
- @ chat client startup - pulls in LOTS of libraries in Java Class Library Some invoke Unsafe Java API when statically initializing needed to do lots of stuff support = required for running client in browser
- Back to my old friends malloc and free. Trust me, I know how to do this efficiently. Must operate on buffers of memory.
- Representing binary data efficiently across browsers - tricky! 3 different representations, depending on browser:
- ArrayBuffer and predecessor, CanvasPixelArray: guaranteed to compactly represent heap in memory. HTML5 Canvas - CanvasPixelArray used to back img info written to canvas. We abuse it for its compact mem. representation.
- Browser doesn’t support these? Fall back to vanilla JS array of #s. 2X memory overhead - JS #s = 64-bit doubles. But: best universal fallback, since all JS bit ops coerce #s into 32-bit form.
- Now, implement Doppio’s Unmanaged Heap using these data structures implement the JVM’s malloc and free on top => JCL can perform its unsafe voodoo @ startup
- Now, proof of concept, DoppioJVM.
- DoppioJVM - unmodified copy of the OpenJDK JCL Provides apps with library support they expect.
- Map core JCL interfaces w/ Doppio OS services. Doppio Threads => interfaces keep blocking JVM semantics, even to invoke asynch JS Also - implement native portions of other classes, omitted here
- More fundamental details! map core JVM data structures to JS features straightforwardly Java Objects -> JS objects Java Arrays -> JS arrays Most numeric types -> JS numbers - act both as 32-bit integers and 64-bit doubles. 64-bit ints not natively provided in browser - emulate using Google’s gLong library.
- This mapping -> GC ‘for free’ because already executing in GC’d environment.
- Finally, some features of JVM that we had to simply reimplement. This includes the core bytecode interpreter for JVM bytecodes, the JVM classloader, and JVM monitors, which are used for synchronization across JVM threads.
- DoppioJVM is real, it exists, and it has been evaluated by the artifact evaluation committee. This is our mock Terminal interface, which you can check out at doppiojvm.org.
- First, I edit a file called Test.java, and I write a variant of the popular Hello World program.
- I run an unmodified copy of javac on the Java source, which is now in the Doppio File System, and it compiles it into a class file.
- Then, I run this class file, which produces the expected result: Hello, PLDI!
- And just for fun, I run the unmodified Java disassembler on the class file, which displays the public methods of the class.
- DoppioJVM runs many large, real, unmodified programs. For example, it can run the official Java compiler and disassembler, it can run an implementation of Scheme, and, yes, it can run an implementation of JavaScript. It can run many other programs as well, but we benchmarked DoppioJVM using these programs.
- We compare DoppioJVM’s performance to the HotSpot interpreter, because DoppioJVM is an interpreter as well. But we note that DoppioJVM is an untuned proof-of-concept, whereas HotSpot is a highly-optimized native interpreter. Despite this, DoppioJVM is 24 to 42 times slower than the HotSpot interpreter in Google Chrome. While there is a significant difference in DoppioJVM’s performance in Chrome over other browsers, we note that we developed DoppioJVM in Chrome, so that likely biased our results. And as DoppioJVM is an interpreter, any gain in performance in core interpreter loops can significantly improve program runtime. A side note: we found a memory leak in Safari while developing this work, which has since been fixed. In any case, these results are from compute-intensive code. Browsers don’t generally run compute-intensive code, so DoppioJVM is fast enough for many people already.
- For example, the University of Illinois launched a website, CodeMoo.com, that uses DoppioJVM to teach children how to program in Java using interactive games. In this basic ‘Level 1’ game, children string together function calls to guide the character in red to the goal without bumping into bad guys. When ready, the child clicks the green button, [HIT SPACE] and watches the character carry out the instructed actions. Under-the-covers, these instructions are placed into a Java file, compiled with the Eclipse Compiler running in DoppioJVM, and then the resulting class file is run in DoppioJVM — all harnessing the power of the visitor’s own browser.
- So, in this talk, I introduced Doppio, a full runtime system that bridges the impedance mismatch between conventional languages in the browser. I also introduced our proof-of-concept Java Virtual Machine, DoppioJVM, which can run unmodified Java programs in the browser. I encourage you to check out Doppio at DoppioJVM.org. Thank you for your attention.