Entropic Communications is a start-up company based in San Diego, California. It develops next-generation semiconductor products for broadband communications applications. The company will have its first chips available in time for their customers' product introductions this year.

Entropic's initial chip design is a highly integrated, mixed-signal SOC, which includes a fair amount of RAM. The combination of imported cores for control and various interfaces, plus Entropic's internally-developed logic, results in an extremely complex design. The Entropic team manages its own tool flow from the register transfer level (RTL) through timing sign off, at which point they rely on service partners to do the back-end physical design. The team uses a Verilog-based flow with standard simulation and synthesis tools.

John Coates is a VLSI Designer at Entropic, and a major part of his team's strategy is to integrate third-party design modules into their designs. The Entropic team prefers the flexibility afforded by soft (synthesizeable) cores versus simply plugging in hard macros. This approach allows them to work interactively with both their own internally-developed logic and externally-sourced components at the system level using RTL descriptions.

"The advantage of using soft cores is that we have the ability to make some modifications to certain functions to meet our specific needs," says Coates. "Of course, the downside is that we are more responsible if we change something and it doesn't work, which means debug is extremely critical."

Coates is a long-time user of the Debussy Debug System from Novas, which is a complete structure-based debug system for tracking down design errors. While using the tool in previous jobs, Coates depended on Debussy's integrated set of debug tools for quick navigation between source code views, schematics and waveforms to build a mental picture of the basic connections between elements. But as designs become more complex and more unfamiliar elements are introduced, engineers like Coates and the Entropic design team need a way to better understand design behavior over time.

To this end, Coates was recently introduced to the Verdi Behavior-Based Debug System. As Novas' next-generation debugging solution, Verdi advances debugging with innovative behavior analysis and visualization capabilities especially designed to assist in the understanding of complex and unfamiliar design elements. Verdi uses proven synthesis technology and advanced formal methods to quickly isolate causes and effects. Packaged with all the core capabilities of Debussy, Verdi includes all the familiar ways to view designs - waveforms, source code, schematics and state machines and raises the debug process to new levels of automation and abstraction in order to radically reduce the time required to comprehend how a design works or why it does not.

"When you're dealing with a lot of imported soft cores, you're working with code that's not your own. That presents a real problem for simple waveform viewers that come with simulators. They can be very painful to debug with, especially for large, complex designs," said Coates. "I was lucky enough to see a demo of Verdi and was impressed with its features. Frankly, after having used it now for a while, it's difficult to see how powerful it really is just from the demo."

Verdi provides an intuitive way for designers to analyze cause and effect relationships, visualize design behavior over time, and explore alternate behaviors. It does this by automatically inferring the logic functions of a design from its RTL (or gate-level) description, and interpreting simulation results to generate an internal model of actual design behavior over time. The result is a much higher-level view of the design and a more efficient way to navigate though its complexity.

Using Verdi, Coates quickly browses through unfamiliar code and correlates sections to the appropriate waveform and schematic views. Synchronized viewing capabilities allow him to automatically trace signals back through time, rather than manually tracing back statement by statement or gate by gate. As a result, he can slice through long chains of connectivity and spans of time to move quickly from questionable effect to actual cause."

The statement flow graphs in Verdi are extremely handy for tracing data and tracing X's. And because of the system's active annotation, I can easily see values of variables at the same point in waveform files and the source code files," he notes. "This type of synchronization makes it easier to step back through time, and if you're unfamiliar with the design, it's a powerful way to pinpoint causes of errors or to understand variables that might not make sense."

Coates, who has used the Novas system only at the RTL level, points out that Verdi is helpful not just with the debugging of imported design elements, but for working with code from other team members as well. He utilizes Verdi's capabilities when integrating blocks, regardless of their source, at the system and sub-system level."

To trace an X through a complex core and design element would normally take a couple of hours at least. With Verdi, I can usually trace through a fairly substantial piece of code in a half hour," Coates says. "That's a significant speed-up, especially if you consider that we have to do that several times a day. Now, instead of tracing down two or three Xs a day, we can do 10 or more. That type of productivity improvement certainly makes our design schedules more attainable."

The Entropic team still relies on the core technology of Debussy for much of their debugging process, but Coates sees a growing need for Verdi's behavior-based method. "As the design we're working on gets larger and more complex and we continue to rely on externally-sourced IP, we'll need a more efficient way to navigate through unfamiliar design elements and help gain an understanding of design behavior. Verdi does that for us, and I'm sure we'll be using it more in the future."