Versus
    32-bit vs 64-bit
    Annotations vs Decorators
    BigQuery vs Bigtable
    Block Storage vs File Storage vs Object Storage
    C vs C++
    Canvas vs SVG
    Constructor vs Init() vs Factory
    Containers vs Virtual Machines (VMs)
    DOM vs Virtual DOM vs Shadow DOM
    DQL vs DDL vs DCL vs DML
    Dagger vs Guice
    Data Mining vs Machine Learning vs Artificial Intelligence vs Data Science
    Flux vs Redux
    GCP API Gateway vs Cloud Endpoint
    GCP Cloud Run vs Cloud Functions vs App Engine
    GCP DataFlow vs Dataproc
    Google Analytics 4 vs Universal Analytics
    Google Internal vs Open Source
    HEIC vs HEIF vs HEVC vs JPEG
    Java vs C++
    Jetty vs Netty
    Kotlin vs Java
    LLVM vs JVM
    Linux vs BSD
    Microcontroller vs Microprocessor vs Computer
    Node.js vs Erlang
    POSIX vs SUS vs LSB
    Pass-by-value vs Pass-by-reference
    Proto2 vs Proto3
    PubSub vs Message Queue
    REST vs SOAP
    React vs Flutter vs Angular
    Rust vs C++
    SLI vs SLO vs SLA
    SRAM vs DRAM
    SSD vs HDD
    Software Engineer vs Site Reliability Engineer
    Spanner vs Bigtable
    Stack based VM vs Register based VM
    Stateless vs Stateful
    Static Site Generation vs Server-side Rendering vs Client-side Rendering
    Strong Consistency vs Eventual Consistency
    Subroutines vs Coroutines vs Generators
    Symlinks vs Hard Links
    Tensorflow vs PyTorch
    Terminal vs Shell
    Vi vs Vim vs gVim vs Neovim
    WAL vs rollback journal
    gtag vs Tag Manager
    stubs vs mocks vs fakes

LLVM vs JVM

Updated: 2022-04-25

Compile time:

  • JVM: compiles source code (e.g. Java / Kotlin / Scala) to bytecode;
  • LLVM:
    • front-end (e.g. Clang / Flang) compiles source code to IR (intermediate representation, IR was designed from the beginning to be a portable assembly.)
    • back-end turns IR into a native binary executable.

Runtime:

  • JVM: garbage collection, access to resources, etc. JVM is an interpreter for Java bytecode, It has to be running during program execution. (Bigger size and higher overhead).
  • LLVM: not needed during runtime (since it generates architecture specific executables in advance)

Just-in-time and Ahead-of-time

As discussed above, LLVM is primarily ahead-of-time, JVM is primarily just-in-time.

LLVM also supports just-in-time compiling (based on the generated IR), since in some cases code needs to be generated on the fly, e.g. when using REPL in Julia. (lli: directly executes programs in LLVM bitcode format. It takes a program in LLVM bitcode format and executes it using a just-in-time compiler or an interpreter.)

GraalVM can compile JAVA application ahead-of-time to native binaries.

register-based vs stack-based

  • LLVM: low level, register-based virtual machine. It is designed to abstract the underlying hardware and draw a clean line between a compiler back-end (machine code generation) and front-end (parsing, etc.).
  • JVM: higher level, stack-based virtual machine (rather than loading values into registers, JVM bytecode loads values onto a stack and computes values from there).

Cross Language

Because of IR and bytecode, both LLVM and JVM can support multiple languages.

  • LLVM: C, C++, Rust, Swift, Fortran, Kotlin/Native, etc.
  • JVM: Java, Kotlin/JVM, Scala, Groovy, Closure, etc.
    • GraalVM: Java, JavaScript, Python, Ruby, R, WASM, etc.

LLVM provide primitives for common programming languages features. E.g. functions, global variables, coroutines and C foreign-function interfaces. LLVM has many of these as standard elements in its IR. The split of front-end and backend-end frees high-level language compilers from having to target every platform (they only need to emit LLVM intermediate representation).

LLVM front-ends:

  • Clang: for C family of languages, e.g. C, C++, Objective-C
  • Flang: for Fortran, added in LLVM 13

Implementation

  • LLVM itself is written in C++; it provides C and C++ APIs.
  • OpenSDK is written in C++.
  • GraalVM is written in Java.