The Core Concept: The Vector API has been in incubation for 11 iterations because its finalization is deliberately deferred until Project Valhalla‘s value types reach completion, enabling SIMD (Single Instruction, Multiple Data) processing for numerically intensive Java workloads including AI applications.

The Guest: Simon Ritter, Deputy CTO at Azul

The Bottom Line:
• Project Valhalla‘s value types enable primitives in collections, eliminating wrapper class overhead and unlocking true CPU SIMD performance for the Vector API

[expander_maker]

Speaking with TFiR, Simon Ritter of Azul explained why the Vector API remains in its 11th incubation iteration and how its dependency on Project Valhalla’s value types architecture justifies the extended development timeline for this performance-critical feature.

WHAT IS PROJECT VALHALLA AND WHY DOES THE VECTOR API DEPEND ON IT?

Project Valhalla introduces value types to Java, representing a fundamental change in how the JVM handles object layout and primitive type integration with collections. Currently, Java collections can only contain reference types, requiring primitives like int to be wrapped in classes like Integer. Value types eliminate this restriction, enabling developers to use primitives directly in collections while improving memory efficiency and performance.

“The Vector API is part of Project Valhalla. Valhalla is the idea of value types in Java. It’s a big change—although it’s not a huge change from the programming point of view, it’s a big change in terms of how the JVM works underneath. It’s going to allow better efficiency and performance because of the way that we can lay out objects. The impact from the point of view of your coding is that it will allow you to do things like have a collection where you can not just have a collection of integers using wrapper classes, but you can also have a collection or list of int. So, you can actually put primitives into a collection. You can’t do that at the moment, but Project Valhalla will allow you to do that.”

The Vector API’s dependency on value types stems from its need for efficient primitive array processing without the overhead of wrapper classes, which is essential for achieving optimal SIMD performance.

SIMD Processing and CPU Wide Register Architecture

The Vector API enables Java applications to leverage SIMD (Single Instruction, Multiple Data) capabilities built into modern CPUs. SIMD allows a single processor instruction to operate on multiple data elements simultaneously by loading them into very wide registers and applying the same operation to all elements in a single clock cycle.

“The Vector API is all about the idea of using SIMD, enabling true parallelism in terms of processing large numbers of values using the fundamental abilities of the CPU. You’ve got these very wide registers. You can load multiple elements from an array into those very wide registers. They could be 128 bits wide, 256, or 512 bits — which is the widest available on Intel. ARM goes all the way up to, I think, 4,000 bits in some of its processors. That allows you to apply the same operation to all of those elements in a single clock cycle.”

This architecture delivers massive performance improvements for numerically intensive operations by eliminating the need to iterate through array elements sequentially.

Single-Clock-Cycle Operations for AI and Numerical Workloads

The performance advantage of SIMD processing becomes particularly significant for AI and machine learning workloads that involve extensive mathematical computation on large datasets. Operations that would traditionally require multiple clock cycles can be reduced to a single cycle when parallelized across wide registers.

“If you want to add three to each of the elements, you can do that in a single clock cycle. That’s very efficient if you’re doing numerically intensive operations. If you’re doing things like AI, where there’s a lot of math involved, this can be very useful for you.”

This capability transforms the performance profile of Java applications handling matrix operations, vector calculations, and other mathematical workloads common in machine learning pipelines.

Why the Vector API Remains in Iteration 11

The Vector API’s extended incubation period reflects a deliberate choice to wait for Project Valhalla’s value types rather than finalize with architectural limitations that would constrain long-term performance. The API itself has stabilized with minimal changes between iterations.

“There’s not much that’s actually changing there. The last time I looked at the JEP, there were just very minor changes to the structure of the API. It’s just ticking over. Once they deliver the key parts of Valhalla, they will finalize the Vector API.”

This approach prioritizes delivering optimal SIMD performance with value types over rushing to finalization without the foundational architecture that enables efficient primitive array processing.

Broader Context: Project Valhalla Timeline and JVM Evolution

In the full TFiR interview, Simon Ritter explained that Project Valhalla’s value types are expected within approximately one year, which would enable Vector API finalization as part of a broader JVM evolution toward better memory efficiency and performance for modern workloads.

The architectural changes Project Valhalla introduces represent one of the most significant JVM improvements for numerically intensive applications, AI workloads, and high-performance computing use cases that have historically faced performance limitations due to wrapper class overhead and memory layout constraints.

Watch the full TFiR interview with Simon Ritter here.

[/expander_maker]