Note that starting with Android 5.0, the Dalvik Virtual Machine has been replaced by Android Runtime (ART).
2. What Is a Runtime?
A runtime system provides an environment to translate the code written in a high-level language like Java to machine code and understandable by the Central Process Unit (CPU).
We can distinguish these types of translators:
- Assemblers: They directly translate assembly codes to machine code so it is fast
- Compilers: They translate the code into assembly code, then it uses assemblers to translate the resulting code into binary. Using this technique is slow but the execution is fast. Also, the resulting machine code is platform dependent
- Interpreters: They translate the code while executing it. Since the translation happens at runtime, the execution may be slow
3. Java Virtual Machine
The JVM is a virtual machine to run Java desktop, server, and web applications. Another important thing about Java is it was developed with portability in mind. Thus, the JVM has been shaped also to support multiple host architectures and run everywhere. But, it is too heavy for embedded devices.
Java has an active community and will continue to be widely used in the future. Moreover, HotSpot is the JVM reference implementation. As well, there are also more than five other implementations maintained by the Open Source Community.
With the new cadence-based release, Java and the JVM are receiving new updates every six months. For example, we can list some proposals for the next releases such as Foreign-Memory Access and Packaging Tool.
4. Dalvik Virtual Machine
The DVM is a virtual machine to run Android applications. The DVM executes Dalvik bytecode, which is compiled from programs written in the Java language. Note that the DVM is not a JVM.
One of the key design principles of the DVM is that it should run on low memory mobile devices and loads quicker compared to any JVM. Also, this VM is more efficient when it runs multiple instances on the same device.
In 2014, Google released Android Runtime (ART) for Android 5 which replaced Dalvik for improved application performance battery usage. The last version was 1.6.0 on Android 4.4.
5. Difference Between JVM and DVM
The JVM is a stack-based VM where all the arithmetic and logic operations are carried out via push and pop operands and results are stored on the stack. The stack is also the data structure to store methods.
Contrastingly the DVM is a register-based VM. These registers located in the CPU carry out all the arithmetic and logic operations. The register is the data structure to store operands.
Java code is compiled inside the JVM to an intermediary format called Java bytecode (.class files). Then, the JVM parses the resulting Java bytecode and translates it to machine code.
On an Android device, the DVM compiles the Java code to an intermediate format called Java bytecode (.class file) like the JVM. Then, with the help of a tool called Dalvik eXchange or dx, it transforms Java bytecode to Dalvik bytecode. Finally, the DVM translates the Dalvik bytecode to binary machine code.
As seen previously, JVM is a Stack-based VM and DVM is a Register-based VM. Stack-based VM bytecode is very compact because the location of operands is implicitly on the operand stack. Register-based VM bytecode requires all the implicit operands to be part of an instruction. That indicates that the Register-based code size will usually be much larger than Stack-based bytecode.
On the other hand, register-based VM's can express computations using fewer VM instructions than a corresponding stack-based VM. Dispatching a VM instruction is costly, so the reduction in executed VM instructions is likely to significantly improve the speed of the register-based VM.
Of course, this distinction is only relevant when running the VM in interpreted mode.
Although it is possible to set up an instance of the JVM per running application, typically we'll only configure one single instance of a JVM with shared processes and memory space to run all the applications we have deployed.
However, Android was designed to run multiple DVM instances. So to run an application or a service, the Android OS creates a new DVM instance with a separate process in shared memory space and deploys the code to run the application.
In this tutorial, we presented the main differences between the JVM and DVM. Both VM's run applications written in Java, but they use different techniques and processes to compile and run code.