RVA23 marks a turning point in how mainstream CPUs are expected to scale performance. By making the RISC-V Vector Extension (RVV) mandatory, it elevates structured, explicit parallelism to the same architectural status as scalar execution. Vectors are no longer optional accelerators bolted onto speculation-heavy cores. They are baseline capabilities that software can rely on.

RVA23 doesn’t force scalar execution to become deterministic. It simply makes determinism viable because the scalar side is no longer responsible for throughput. The vector unit handles the parallel work explicitly, and the scalar core becomes a coordinator that can be simple, predictable, and low‑power without sacrificing performance.

To understand why this shift matters, it helps to recall how thoroughly speculative execution came to dominate high-performance CPU design. It delivered speed, but at increasing cost—in power, complexity, verification burden, and security exposure. RVA23 does not reject speculation. Instead, it restores balance. It acknowledges that predictable, vector-driven parallelism is now a credible, mainstream path for performance growth.

Mandatory vector support fundamentally changes the software performance contract. Compilers, libraries, and applications can now assume RVV exists on every compliant core. Optimization strategy shifts away from “let the CPU guess” toward explicit, structured parallelism. Toolchains must reliably emit vector code. Math and DSP libraries can reduce or eliminate scalar fallbacks. Application developers gain a predictable model for scaling loops and data-parallel workloads.

The cultural shift is significant: parallelism becomes something software expresses directly, not something hardware attempts to infer. For hardware designers, the shift is different but equally profound. Vector units are now mandatory, yet the specification preserves microarchitectural freedom.

Implementers can choose lane width, pipeline depth, issue policy, and memory design. What changes is the performance center of gravity. Designers are no longer forced to rely exclusively on deeper speculation—larger branch predictors, wider reorder buffers, and increasingly complex recovery mechanisms—to remain competitive.

Instead, area and power can shift toward vector throughput and memory bandwidth. Simpler in-order cores with strong vector engines become viable for workloads that once demanded complex speculative machinery.

How Speculation Came to Dominate

Speculative execution did not appear overnight. It emerged gradually from techniques that loosened strict sequential execution. In 1967, Robert Tomasulo’s work on the IBM System/360 Model 91 introduced dynamic scheduling and register renaming, allowing instructions to execute out of order without violating program semantics. Around the same time, James Thornton’s scoreboard in the CDC 6600 kept pipelines active in the presence of hazards. These mechanisms did not speculate—but they removed structural barriers that once forced processors to stall. Once out-of-order execution became viable, speculation became irresistible.

In the late 1970s and early 1980s, James E. Smith formalized branch prediction, grounding speculation in probability. Memory ceased to be something processors simply waited on; it became something to anticipate. Data was fetched before it was confirmed to be needed. Caches evolved from locality optimizers into buffers that absorbed the turbulence of speculative execution.

Academia reinforced this direction. Instruction-level parallelism research at Stanford and Berkeley treated speculation as the path forward. John Hennessy framed speculation  as a way to increase performance without abandoning sequential programming. David Patterson articulated the “memory wall,” encouraging deeper caching and hierarchical storage.

Industry followed. Intel’s Pentium Pro (P6) crystallized speculative out-of-order execution with deep cache hierarchies into the mainstream CPU template. IBM POWER and AMD Zen reinforced the same model: sustain ever larger volumes of in-flight speculative work by expanding buffering, bandwidth, and memory-level parallelism. Each generation scaled speculation rather than questioning it.

The Growing Costs

Over time, the costs became clearer. In his ISSCC 2014 plenary, Mark Horowitz argued that energy—not transistor density or raw logic speed—had become the primary constraint in computing. Arithmetic consumes only a few picojoules. Cache accesses cost an order of magnitude more. DRAM accesses cost two to three orders more. Data movement, not computation, dominates energy consumption.

Voltage scaling stalled and frequency scaling hit thermal limits. Simply adding cores no longer restored historical performance curves. Meanwhile, last-level caches and register files grew so large that they began consuming energy comparable to—and often exceeding—the cores they served.  Modern memory hierarchies evolved not independently, but in symbiosis with speculative execution. They became the scaffolding required to sustain large volumes of in-flight, uncertain work. Speculation optimizes for the appearance of forward progress. The memory system exists to sustain that appearance—and to clean up when predictions fail.

At the DRAM level, Onur Mutlu showed how modern processors stress memory systems through interference, row conflicts, and unpredictable access patterns—many driven not by committed computation, but by speculation that would ultimately be discarded.

Seen in this light, modern CPU memory hierarchies did not evolve independently. They co-evolved with speculative, out-of-order execution, becoming the physical scaffolding required to sustain it. At its core, speculative execution optimizes for illusion—the illusion that a single sequential thread is progressing faster by guessing ahead.

Deterministic execution, by contrast, optimizes for what is known. It treats latency as schedulable rather than something to hide behind ever-increasing bandwidth. Where speculative architectures grow in complexity to compensate for uncertainty, deterministic architectures grow in predictability and sustained throughput.

The Path Not Taken

Speculation was not inevitable. Seymour Cray’s vector machines demonstrated that speculation was never the only path forward. They rejected it entirely, relying instead on predictable memory stride patterns, explicit vector lengths, and deterministic scheduling. Parallelism was exposed directly to the hardware, not inferred through guesswork, and latency was something to plan around rather than hide.

Their memory systems were engineered for stable, high‑throughput access rather than the guess‑and‑recover behavior that later speculative architectures required. In this sense, Cray’s approach aligns more closely with RVV’s structured, length‑agnostic model than with the speculative superscalar lineage that came to dominate general‑purpose CPUs

Speculation won historically because it preserved sequential programming models and minimized software disruption. But that success created path dependence. Memory hierarchies were optimized for speculative throughput even as power consumption, verification complexity, and architectural opacity escalated.

RVA23 and the Nature of Modern Compute

AI, machine learning, and signal processing workloads are structured and inherently data-parallel. Their access patterns are often knowable rather than probabilistic. These are precisely the domains where explicit parallelism outperforms speculative guessing. By making RVV mandatory, RVA23 guarantees hardware support for such workloads. Structured parallelism moves from optional extension to architectural baseline. This does not eliminate speculation. It eliminates exclusivity.

Architectures such as deterministic, time-based scheduling approaches—like those explored at Simplex Micro—can now assume vector capability as a foundation. Rather than compensating for speculative inefficiency, they coordinate compute and memory explicitly. Performance scales through utilization and predictability rather than speculation depth. For vector and matrix workloads, this is less a revolution than a return to a lineage that speculation once displaced.

Structured Parallelism as First-Class Architecture

The significance of RVA23 goes beyond instruction encoding. Compiler infrastructures can assume vector support. Operating systems can schedule with vector resources in mind. Hardware implementations can optimize for vector efficiency without worrying whether the ecosystem will ignore it. For three decades, speculation received consistent architectural investment. Structured parallelism did not.

RVA23 changes that. It does not mandate abandoning speculation. It mandates architectural parity. Designers may deploy both where appropriate, but structured parallelism is no longer a second-class citizen. The false binary—scale through speculation or accept inferior performance—no longer applies.

Less to Speculate On

With RVA23, there is less uncertainty about vector capability, less doubt that deterministic approaches can achieve first-class performance, and less need to rely exclusively on speculation to scale. Less reliance on speculation as the sole path to scaling. Today’s workloads are parallel by design, not by heroic compiler extraction from sequential code. For these workloads, speculation’s costs increasingly outweigh its benefits.

RVA23 does not end the era of speculation. It ends its monopoly. And that shift—more than any single technical feature—may be its most important contribution to processor architecture.

Also Read:

Reimagining Compute in the Age of Dispersed Intelligence

Two Open RISC-V Projects Chart Divergent Paths to High Performance

The Foundry Model Is Morphing — Again

The AI PC: A New Category Poised to Reignite the PC Market