Gate-level simulation is supposed to give confidence before tapeout.
In reality, once designs cross millions of gates, it becomes the bottleneck itself.
If you’ve tried verifying large designs with traditional open-source simulators, you’ve likely hit the same walls we did:
- Simulations that run for days
- Massive trace files
- Memory exhaustion
- Jobs that never finish
That experience forced us to ask a blunt question:
Is the problem really the design—or the way we simulate it?
That question led us to build VHE — Virtual Hardware Emulator.
Why Traditional Simulation Stops Scaling
CPU-based gate-level simulation evaluates gates sequentially. That works—until it doesn’t.
As designs grow:
- Parallelism collapses
- Runtime explodes
- Debug cycles slow to a crawl
Commercial hardware emulators exist, but they come with six-figure licensing costs, making them inaccessible for startups, researchers, and open silicon teams.
There’s a clear gap:
Open tools scale well for small designs—and fall apart for large ones.
The Idea Behind VHE
Instead of trying to optimize CPU simulation further, we stepped back and asked:
What if gate-level simulation was mapped to massively parallel hardware instead?
VHE is a GPU-accelerated virtual hardware emulator that:
- Converts synthesized netlists into a levelized structure
- Evaluates large numbers of gates in parallel
- Targets **million-gate designs **that CPU simulators struggle with
The goal wasn’t to replace commercial emulators—but to make large-scale verification practical in open flows.
Where Things Got Interesting
GPU acceleration sounds obvious—but it introduces its own constraints:
- Memory layout matters
- Scheduling matters
- Netlist structure matters far more than expected
One design decision we made early on dramatically improved throughput—but also introduced a limitation we didn’t anticipate.
👉 That trade-off, and how it affected real NPU verification, is explained here: VHE — Virtual Hardware Emulator
Real Designs, Real Constraints
We tested VHE on a real multi-million-gate NPU design.
What changed wasn’t just runtime—it was feasibility:
- Jobs that previously failed could complete
- Results arrived within hours instead of days
- Verification became iterative again
The exact numbers, scaling behavior, and limits are covered in the full article.
When VHE Actually Makes Sense
VHE is useful when:
- Your design is too large for CPU simulation
- FPGA prototyping is too slow or expensive
- You need more fidelity than high-level models
- Commercial emulators are not an option
It sits in the middle ground— between simulation and emulation.
Full Technical Deep Dive (Canonical)
This dev.to post intentionally skips:
- Netlist parsing details
- Levelization strategy
- GPU scheduling model
- Performance bottlenecks and limits
If you want the actual engineering details, benchmarks, and lessons learned, read the full article:
👉 VHE — Virtual Hardware Emulator
Takeaway
As designs scale, verification—not logic—becomes the real problem.
VHE explores one practical direction for making large-scale gate-level verification possible without enterprise tooling.
Top comments (0)