DOCSEARCHbyAlgolia
Submit Docs

v8.dev Documentation

repository·main·Indexed 21 days ago

https://github.com/v8/v8.dev

Source code and documentation for v8.dev, the official website for the V8 JavaScript and WebAssembly engine project. Includes guides on local development, V8 core concepts like Isolates, BigInt support, Spectre mitigations, and technical deep dives into the Ignition interpreter, TurboFan optimization, and WebAssembly memory allocation (up to 4GB) using Emscripten.

Tokens
203.1K
Snippets
579
Records
992
Agent score
76%

What's inside v8.dev

  1. What is V8 and how can it be used?

    main

    V8 is an open-source, high-performance JavaScript and WebAssembly engine written in C++. It is designed to be embedded into C++ applications, allowing developers to expose their own C++ objects and functions to JavaScript code.

    Key characteristics:

    • Implementations: Implements ECMAScript and WebAssembly standards.
    • Memory Management: Includes a stop-the-world, generational, accurate garbage collector.
    • Platform Support: Runs on Windows, macOS, and Linux (x64, IA-32, or ARM). Other systems like IBM i, AIX, MIPS, ppcle64, and s390x are maintained via external ports.
    • Scope: V8 provides data types, operators, objects, and functions. It does not provide the Document Object Model (DOM); the DOM is typically provided by the host environment (like Chrome).

  2. Overview of V8 documentation and resources

    main

    The V8 documentation is categorized into several key areas for developers:

    Building and Setup

    Covers checking out source code, building with GN, cross-compiling for ARM/Android/iOS, and IDE setup.

    Embedding V8

    Guides for C++ developers on how to embed the engine, manage version numbers, handle built-in functions, i18n support, and untrusted code mitigations.

    Debugging

    Includes techniques for using the V8 Inspector Protocol, debugging builtins with GDB, investigating memory leaks, using the Stack trace API, and using the d8 shell.

    Under the Hood (Engine Internals)

    Explains core components like Ignition (interpreter), TurboFan (optimizing compiler), Torque (language for writing builtins), and Maps (hidden classes).

    Performance and Profiling

    Provides instructions on writing optimizable JavaScript using the sample-based profiler, Linux perf, tracing, and Runtime Call Stats (RCS).

  3. Overview of V8 Builtin implementation methods

    main

    In V8, builtins are chunks of code executable by the VM at runtime, used for implementing builtin object functions (like RegExp or Promise) or internal functionality (like the IC system).

    Available implementation methods include:

    • Platform-dependent assembly language: Highly efficient but difficult to maintain and requires manual porting.
    • C++: Access to V8 runtime functionality but generally not suitable for performance-sensitive areas.
    • JavaScript: Concise and readable, but deprecated for new builtins due to performance unpredictability and complex semantics.
    • CodeStubAssembler (CSA): Efficient, low-level, platform-independent, and readable.
    • V8 Torque: A domain-specific language that translates to CSA. It provides static typing and a more expressive syntax than raw CSA, making it the recommended way to implement new builtins.

  4. Performance impact of lazy unlinking in V8

    main

    Lazy unlinking provides performance improvements across various workloads by changing how V8 handles deoptimized functions.

    Key Performance Gains:

    • Promises: Significant improvements in benchmarks like bluebird-parallel (~33% gain) and wikipedia (~22.40% gain).
    • ARES-6 Benchmark Suite: Overall performance improvement of ~1.9%, with specific cases like Air steadyState seeing ~5.36% improvement. This is particularly beneficial for programs that spend significant time in GC-related activities.
    • Node.js (Router Benchmarks):
      • Isolated tests: Routers like router and express can perform approximately 2x more operations per second.
      • Integrated tests: In environments where multiple tests run without switching the VM, improvements are even higher. For example, routr can see ~3.80x improvement, server-router ~3x, and router ~2x. This is because V8 accumulates more optimized functions over time, and lazy unlinking reduces the overhead during garbage collection cycles.

    Memory Savings

    By removing the next field from the JSFunction class (since V8 no longer keeps a linked-list of JavaScript functions in the context), V8 saves the size of one pointer per function. This results in measurable memory savings on high-traffic web pages:

    • facebook.com: ~170 KB (3.70% average effective size)
    • twitter.com: ~284 KB (1.20% average size of allocated objects)
    • cnn.com: ~788 KB (1.53% average size of allocated objects)
    • youtube.com: ~129 KB (0.79% average size of allocated objects)

  5. Performance and memory improvements in V8 v6.3

    main

    V8 v6.3 includes several optimizations for speed and memory efficiency:

    Speed Improvements

    • Concurrent Marking: Part of the Orinoco project, 70-80% of marking is now performed on a non-blocking thread.
    • Parser Optimization: The parser no longer needs to preparse functions a second time, resulting in a ~14% median improvement in parse time on startup benchmarks.
    • Builtin String Functions: string.js was ported to CodeStubAssembler, making functions like String#trim significantly faster.
    • ES2015+ Performance: Improvements to Object.is(), polymorphic access to symbols, polymorphic inlining of constructor calls, and (tagged) template literals.
    • Lazy Unlinking: The weak optimized function list has been removed.

    Memory Consumption

    • Write Barriers: Switched to using CodeStubAssembler, saving approximately 100 KB of memory per isolate.

  6. V8 v8.0 Release Highlights

    main

    V8 version 8.0 introduces several significant performance and language features, including:

    Performance Improvements

    • Pointer Compression: Reduces memory usage by approximately 40%.
    • Optimizing higher-order builtins: Enhances the speed of common higher-order functions.

    JavaScript Language Features

    • Optional chaining (?.)
    • Nullish coalescing (??)

  7. Maglev performance characteristics and tier positioning

    main

    Maglev is designed as a mid-tier JIT compiler positioned between Sparkplug (a fast, non-optimizing compiler) and TurboFan (a highly optimizing compiler).

    Performance Trade-offs

    • Compilation Speed: Maglev is approximately 10x slower than Sparkplug but 10x faster than TurboFan.
    • Execution Speed: It provides significantly better performance than Sparkplug, allowing V8 to delay the more expensive TurboFan compilation until feedback is stable.
    • Resource Efficiency: Because it compiles faster than TurboFan, Maglev reduces overall V8 resource consumption by using less off-thread CPU time.

    Benchmarks

    Maglev shows improvements in Core Web Vitals and reduces energy consumption in common benchmarks:

    BenchmarkEnergy Consumption
    JetStream-3.5%
    Speedometer-10%

    Availability: Maglev is available in desktop Chrome and is being rolled out to mobile devices.

  8. Identify V8 heap snapshot performance optimizations

    main

    V8 has implemented optimizations to significantly reduce the time required to generate heap snapshots. These optimizations target the generation phase rather than the serialization phase.

    Key improvements include:

    • Improved StringsStorage hashing: Speeds up the processing of string data.
    • Caching source positions: Reduces the overhead of calculating source line positions, which is particularly beneficial for large, minified production JavaScript files.

    Performance Impact:

    • Development JS: ~50% faster generation.
    • Production JS: ~90% faster generation (due to larger, bundled files benefiting from position caching).
    • Extreme cases: In some scenarios, capture times for 100MB snapshots were reduced from 10 minutes to 6 seconds.

    Availability:

    • Shipped in V8 v11.5.130.
    • Found in Chromium 115.0.5576.0.
    • Node.js support is expected in upcoming major releases.

  9. Compare Sea of Nodes vs. CFG-based IR (Turboshaft)

    main

    V8 is transitioning from the Sea of Nodes (SoN) architecture used in Turbofan to a more traditional Control Flow Graph (CFG) based Intermediate Representation (IR) called Turboshaft.

    Key improvements of the new CFG IR (Turboshaft) over Sea of Nodes include:

    • Reduced Compile Time: Compile time was approximately halved compared to SoN.
    • Simpler Codebase: The compiler code is significantly simpler and shorter.
    • Easier Debugging: Investigating bugs is more straightforward due to the traditional CFG structure.
    • Better Optimization Implementation: Easier to implement and refine optimizations because the graph is easier to read and analyze.

  10. V8 Security Enhancements

    main

    V8 has implemented several security layers to protect users:

    • Sandboxing: Improved infrastructure including code- and trusted pointer tables.
    • Control-flow Integrity (CFI): A new architecture to ensure the execution flow follows the intended program structure, preventing many exploit techniques.
    • Fuzzing: Continuous investment in specialized fuzzers to identify vulnerabilities.
    • V8CTF: A dedicated exploit bounty program for security researchers.

  11. Performance optimization of class fields in V8

    main

    Since V8 v9.7, the initialization of class fields and private methods has been optimized to close the performance gap between class field initialization and ordinary property assignment.

    Previously, V8 used costly runtime calls (%AddPrivateField() and %CreateDataProperty()) to ensure compliance with the specification's "define" semantics (which avoid triggering setters or Proxy traps).

    With the optimization, V8 uses a new Inline Cache (IC) system. When class field initialization patterns are predictable, V8 uses pre-generated code instead of runtime calls, significantly increasing speed.

    Key Versions:

    • v9.7: Fixed the performance gap for class field initializations.
    • v10.0: Fixed support for class field initializers in startup snapshots.

  12. Memory utilization improvements via pointer compression in Oilpan

    main

    Pointer compression in Oilpan (enabled by default in Chrome 106) reduces the size of pointers to halfwords, leading to significant memory savings in the Blink renderer.

    Expected Memory Savings

    Based on fleet data, users can expect improvements in Blink memory usage:

    • Windows: ~21% reduction (P50) to ~33% reduction (P99).
    • Android: ~6% reduction (P50) to ~8% reduction (P99).

    Implementation Details for Developers

    • Structure Packing: To maximize the benefits of halved pointer sizes, ensure data structures are packed. If using garbage-collected classes, be aware that internal padding can negate size reductions. A Clang plugin can be used to reorder fields to minimize this padding.
    • Stack Scanning: Note that Oilpan uses conservative stack scanning. Because compressed pointers are treated as halfwords, the scanner must consider all possible intermediate values (including truncated values) spilled onto the stack, which can increase false positives and slightly offset memory gains.