Building AI SoCs with a continuous hardware verification strategy

For many years, hardware emulation was reserved for the largest semiconductor companies and the most demanding system-on-chip (SoC) programs. That model no longer fits the way advanced ICs are designed. AI accelerators, edge devices, networking silicon, and data-center processors combine enormous hardware complexity with software stacks that define much of the product’s behavior.
As a result, verification can no longer stop after individual RTL blocks function correctly. Design teams need a coordinated environment that exposes interactions among hardware, firmware, operating software, and workloads before tape-out.
Hardware-assisted verification (HAV) has expanded to meet that need. A modern HAV flow combines emulation, enterprise prototyping, and FPGA prototyping. Each platform serves a different phase and execution-speed requirement, but the greater value comes from using them as a connected methodology. Engineers can move from deep RTL debug to early software development and then to system-level validation without abandoning the design context established earlier in the project.
The pressure is particularly intense for AI products. New models and algorithms appear quickly, while the underlying hardware must deliver best throughput within strict power and thermal limits. Performance per watt has become a central design target for devices operating at the edge and for accelerators deployed at the heart of data centers. Reaching that target requires architectural choices to be tested against realistic software workloads, not only synthetic vectors or isolated block-level tests.
Verification must include the workload
Traditional SoC development often treated hardware and software as sequential activities. Hardware teams verified the RTL, handed the design downstream, and software teams began serious integration later. That approach creates risk when software exposes bottlenecks, memory behavior, scheduling conflicts, or power/thermal characteristics that were not visible during conventional RTL verification. On an AI SoC, the workload can reveal that an apparently correct architecture is inefficient for the computations it must execute.
A more effective flow allows hardware and software development to progress concurrently. Early in the project, engineers still lint and debug SystemVerilog and other RTL descriptions at the IP level. The verified blocks are then assembled on a logic emulator, where teams can run large designs with high visibility into internal behavior. This stage is critical for finding functional errors across subsystems and for validating that the complete SoC behaves as intended before manufacturing commitments make changes extremely expensive.
Emulation also supports more meaningful validation when real firmware, drivers, and application workloads are introduced. Instead of asking only whether the logic produces the expected value, engineers can investigate how the design behaves under sustained traffic, software-controlled corner cases, and realistic data movement. Those observations give architects evidence for refining accelerator blocks, interconnects, memory hierarchies, and power-management logic while the design is still changeable.

An integrated HAV flow connects emulation, enterprise prototyping, and FPGA-based software prototyping. Source: Siemens EDA
Three platforms, one development continuum
Emulation provides capacity, deterministic execution, and very fast detailed debug for complex RTL. FPGA prototyping shifts the emphasis toward execution speed and software availability. Hardware teams can map a functional representation of the SoC into an FPGA-based platform, so software developers can begin work well before silicon returns. Middleware/firmware, AI runtimes, algorithms, and applications can be exercised against a live target rather than waiting for a physical chip.
Enterprise prototyping fills the space between deep emulation debug and individual FPGA prototyping. It offers higher execution speed than emulation while supporting larger, shared use across hardware, software, and systems teams. Enterprise prototyping can run three to five times faster than emulation. That additional performance makes longer software sequences and broader system scenarios practical while preserving a closer connection to the verified design.
The three technologies should not be viewed as competing choices. Emulation is suited to finding difficult hardware defects and examining internal signals in the IC design. FPGA prototyping gives software engineers rapid access to an early target. Enterprise prototyping supports collaborative validation of hardware-software behavior at greater speed. Together, they create a faster path from RTL bring-up through workload execution and system qualification.
A unified environment shortens debug loops
Earlier HAV implementations often forced teams to treat emulation and prototyping as separate islands. Different user interfaces, compilers, and setup procedures made design movement difficult. When a failure appeared after transitioning to another platform, engineers first had to determine whether the problem came from the design, the mapping flow, or the verification system itself. That uncertainty consumed engineering time and often required specialists who understood the quirks of each environment.
Current integrated platforms reduce that friction by sharing core software infrastructure. For instance, Veloce CS family brings Veloce Strato CS emulation, Veloce Primo CS enterprise prototyping, and Veloce proFPGA CS FPGA software prototyping under a common operating environment and unified compiler. Consistent flow makes it easier to reproduce failure across platforms, distinguish design defects from platform issues, and carry a validated configuration from hardware debug into software development.
For design teams, this continuity matters as much as raw execution speed. A bug discovered by a software workload can be traced back toward emulation, where engineers have finer visibility into the RTL. After the correction, the updated design can return to a faster prototyping platform for broader regression and application testing. Shorter transitions help teams repeat this loop more often before tape-out.
From chip verification to the system digital twin
An SoC rarely operates in isolation. AI processors are installed in boards, racks, vehicles, industrial equipment, medical systems, and aerospace platforms. Electrical behavior interacts with thermal conditions, mechanical constraints, power delivery, cooling, and software control. Validating the IC within a broader digital twin allows engineering teams to study those interactions before all physical elements are available.
In-circuit use of emulation can connect the developing SoC and its software to a larger system model. A data-center team, for example, can examine power consumption while the modeled device experiences thermal stress in a rack configuration.
Automotive and other mission-critical programs can use similar techniques to investigate reliability and system responses across electrical, thermal, and mechanical conditions. The objective is not simply to prove that the RTL is correct, but to determine whether the complete product behaves acceptably in its intended environment.
This system perspective also supports power-performance optimization. When engineers run representative software through a digital twin, they can identify whether an undesirable result is best addressed in the microarchitecture, firmware, compiler, runtime, or application. The ability to trade hardware and software changes against the same scenario is essential when performance per watt is a primary product requirement.
Capacity and deployment must match next-generation designs
Growing gate counts have historically forced companies to purchase highly customized emulation installations. Special rooms, racks, power arrangements, and operational expertise increased both cost and deployment time. Modern systems address those constraints with greater capacity and packaging designed for conventional data-center infrastructure.
Cloud access further changes who can use advanced HAV. Rather than purchasing a full platform, a startup or smaller design group can lease emulation or enterprise prototyping capacity for the periods when a project needs it. Flexible consumption does not remove the need for careful planning around security, data transfer, compilation, and queue availability, but it broadens access to verification resources that were once limited to the largest semiconductor companies.
The most important shift is methodological. HAV is no longer only a late-stage appliance for proving that a large RTL design runs. It’s an engineering continuum that connects architecture, functional verification, software enablement, power/performance analysis, and system validation. Teams gain the strongest benefit when they plan platform transitions early, define which workloads must run at each stage, and preserve a consistent debug path from application behavior back to RTL.
For engineers designing next-generation ICs, that approach provides earlier evidence about whether the architecture can meet its real product goals. Logic may be functionally correct yet fail to provide adequate throughput, power efficiency, software compatibility, or behavior under system stress. Integrated emulation and prototyping expose those gaps while engineers still have options.
As AI SoCs continue to grow in scale and software dependence, tape-out confidence will increasingly depend on the quality of hardware-software validation. A connected HAV environment gives teams the capacity scalability, speed, observability, and system context needed to make design decisions before fabrication. The result is not merely fewer bugs. It’s a better opportunity to deliver an IC whose hardware, software, and operating environment work together as engineered.
Vijay Chobisa is senior director of product marketing for hardware-assisted verification at Siemens EDA.
Related Content
- The Hardware-assisted Verification Imperative
- Time to rethink EDA flows and tool infrastructure
- The Growing Use of Hardware-Assisted Verification
- Four ways to build a CAD flow: In-house design to custom-EDA tool
- Enhancing SoC HW/SW co-verification with FPGA-based prototyping
The post Building AI SoCs with a continuous hardware verification strategy appeared first on EDN.


