Skip to the stories
Electronics & Semiconductors

Chip Design Shift Left Expands from Verification to System Validation

  • Ed Sperling
  • 356 reads

Disconnected hardware, software and physics models let bugs cross team boundaries. AI could connect their context while simulation and emulation remain essential.

Chip Design Shift Left Expands from Verification to System Validation

Chip teams can verify individual blocks and still miss failures caused by mismatched assumptions across the system. That gap is pushing “shift left” beyond earlier verification toward earlier system validation: bringing software behavior, physical constraints and design intent into view before late integration exposes a problem.

That shift matters because a defect found late can force expensive redesign work, and for a small company the consequences can be severe. The engineers and tool vendors discussing the issue describe a recurring pattern: architects, designers, verification teams and software developers each believe the device will behave in a particular way, yet their models don’t fully agree. Verification can establish that a design meets its stated properties. It can’t settle whether those properties reflect the system everyone intends to build.

Validation needs a shared system picture

Ashish Darbari, founder and CEO of Axiomise, said teams investigating escaped bugs often find communication gaps among architecture, design, UVM, emulation, FPGA and software groups. In one case he recalled, a processor design had been exhaustively proved, but the software team expected different behavior when multiple transactions were outstanding. The software trace showed transactions being lost. The architect and designer had assumed later transactions could simply be discarded, while the software team’s model of the SoC differed. The mismatch surfaced late and required a patch.

The lesson is not that formal verification failed at its job. The design may have met the assumptions supplied to the verification process. The problem was that those assumptions didn’t capture how software would drive the system. Earlier software participation could help expose such disagreements while architecture and implementation choices are still easier to revisit.

System context extends beyond hardware and software. Frank Schirrmeister, executive director of strategy programs and system solutions at Synopsys, pointed to electromagnetic, thermal and mechanical constraints, along with packaging. A chip’s intended application affects its physical arrangement: a package designed for a phone may face different constraints from one intended for a data center. Models can incorporate measurements from real systems, but project teams still have to account for practical limits, including packaging choices that may not be feasible at the time.

Those constraints are interdependent. A design decision that looks sound in a functional model may create a thermal or packaging problem, while a software assumption may conflict with power management. When each discipline keeps its own model and context, no single review necessarily reveals the combined effect.

Earlier work needs connected workflows

Moving work earlier can help teams discover conflicts sooner, but it doesn’t automatically connect the work. Jack Berg, vice president of business development at Silvaco, described verification as traditionally one of the longest and most expensive parts of design. Some tasks have shifted earlier and can be checked sooner; the industry is still learning how to bring the broader set of activities forward.

Historical packaging and thermal data could help teams build models that inform new projects, Darbari suggested. Berg said inference from earlier work is possible. But the panelists didn’t describe a single workflow that unifies functional safety, security, power, packaging and thermal analysis. Berg characterized the need as a workflow problem: the separate capabilities exist, while integrating them remains ongoing work.

That distinction matters. A collection of capable tools doesn’t provide a complete system view if each tool receives a different model or set of assumptions. Ronen Laviv, vice president of business development and strategic partnerships at Hiveware, said AI could make a shared pool of information across verification, emulation and physical work more useful, potentially even across companies. The practical value would depend on whether that information can be made available in context and used to coordinate the work.

AI can guide the tools, not skip their work

The panelists see a role for agentic AI in coordinating tasks, finding bottlenecks and helping teams choose how to use their existing tools. That could mean deciding which questions are best handled with simulation, formal methods, emulation or FPGA-based prototyping. It could also mean giving AI access to tool interfaces and internal results so it can make useful judgments sooner, rather than waiting for a long run to finish before deciding what to try next.

But AI doesn’t remove the need for the underlying engineering methods. Schirrmeister said characterization, simulation and emulation will remain necessary, even if AI changes how teams select and operate them. An emulator still has to be built, and the design has to be loaded into it. Tool execution takes time, and smarter orchestration can improve productivity without removing the computation itself.

This is a practical limit on “shift left”: teams can move some checks earlier, reduce wasted tool time and bring the right evidence into decisions sooner, but they can’t bypass every process that establishes how a design behaves. Schirrmeister said some customers review why a problem appeared in simulation if they believe it should have been caught with formal verification or an earlier simulation run. That feedback can help improve the flow, provided the teams understand which check was expected to find the issue.

Laviv raised the possibility of using AI to identify bottlenecks in formal verification, general verification and emulation. For very large designs, he said, simulation tools face challenges without emulation. He cited Intel’s Broadwell as a chip with 200 billion transistors and argued that scale increases the need for verification. AI interfaces to simulation APIs and insight into formal or simulation activity could help teams assess progress and clean up work while runs are underway. Those interfaces would augment the tools’ work rather than replace it.

Context must cross team boundaries

Schirrmeister recalled a separate hardware and software integration problem involving an emulator. Software developers and hardware developers spent days investigating an apparent tool issue. The cause turned out to be system behavior: the relevant logic was powered down in that state because its clock was gated. The software developer didn’t interpret the register programming as correct; the hardware developer understood the register state but hadn’t connected it to the power-down behavior.

Neither team had the full context needed to diagnose the result. For AI agents to help, that context has to be available to them too. Darbari warned that agents operating in separate contexts could leave the same gaps intact. A useful system would need to connect information about functional behavior, software, manufacturing and physical effects so teams can reason about the device as a whole. At this scale of complexity, assembling that picture entirely by hand is difficult.

Earlier design analysis may also expose problems that conventional checks don’t target. Darbari described power, performance and area estimates that revealed unused logic still occupying die area and consuming power. Synthesis wasn’t removing it, lint wasn’t flagging it and coverage wasn’t identifying it as a problem. That kind of finding suggests redundant logic should be considered during design or architecture, rather than left for synthesis or layout to resolve.

The larger change is a move from asking whether each component passed its checks to asking whether the system models agree with one another. AI may help teams connect evidence, surface bottlenecks and direct tool use. The engineering payoff will depend on whether teams bring software and physical constraints into the shared context early enough to catch mismatches while they can still change the design.

Source: Ed Sperling · semiengineering.com

From the same set