A document, whether it is stored as a simple text file or as a word processor formatted file, is often a living entity that is constantly evolving. A user may create a first draft, revise it multiple times, have other team members review it and make alterations, and refine it over time to keep up with new information and requirements. What has changed since the last revision becomes very important to know, otherwise you would spend a lot of time reviewing the same document in its entirety multiple times. Not only is this highly inefficient, it is highly frustrating and impossible to know if you even reviewed all the changes made since the last review.
The same problem exists in the semiconductor design domain, where design teams are spread across multiple sites with a number of designers constantly editing various versions of the same design files, textual and binary alike. Here, identifying the differences becomes a very complex, yet necessary, problem to solve. Identifying the differences in a design — either a VHDL or Verilog file, a schematic or a layout — becomes critical in the face of tight design schedules and distributed design teams. An edit made by one designer at a design site can impact the work of another designer from the same team at another location. In such a case, identifying the differences to narrow down a problem becomes critical.
While a skeptic may argue that the original Unix diff command is sufficient for checking and verifying design changes, the reality is that the concept of identifying differences needs to be extended to an entire design hierarchy. Not only that, but a design can also include schematic for an analog design, which cannot be parsed by the Unix diff command. Presenting the key differences in a meaningful format while removing the “noise” is equally important.
Identifying Differences in Text
People have used various techniques to solve this problem. Different colored pens and highlighters were used before computers became pervasive. Word processors such as Microsoft Word and other office utility tools such as PowerPoint and Excel have built in capabilities to track changes so that it is easy to see who made what changes, when. If tracking has not been turned on, then users can also compare different versions of a document to identify the differences.
The text diff utility was developed in the early 70s for the Unix operating system and, of course, several variations of the same, with GUIs, are available today. This relatively simple utility is a key tool in a programmer’s toolbox, helping to save innumerable hours of tedium and to fix issues before they are released. The diff utility serves many purposes:
- A programmer can review changes before checking in a new version.
- A colleague or supervisor can quickly verify changes made.
- A release engineer can find and merge changes made on different branches of development.
Today most programmers would find it very difficult to live without this incredibly useful tool. It is no surprise that digital developers programming in Verilog or VHDL have adopted many of the tools that software programmers use and that the diff utility has become an integral part of the toolset.
Identifying Differences in Graphics
Tracking changes to graphics and comparing two versions is not only trickier but also harder to display. Even word processors that can track changes and compare different versions are limited to text and format changes but do not provide a good solution for graphics.
Therefore it is not surprising that designers working with graphical design entry tools — like schematic and layout editors — have so far been denied this very useful capability, even though the design flows are more complex and the need to find differences is more challenging. Schematic and layout editors are complicated tools. The chance of accidental changes is higher than with text files and the challenge of finding the difference between versions is far more difficult.
Additionally, if there are ECOs to a schematic after the layout has been created, the layout engineer has to make the corresponding changes to the layout view. Engineers can end up spending countless frustrating hours playing Spot the Difference, which is especially difficult because they don’t know how many differences there are and therefore never know when the game has ended.
Engineers often have to jump through hoops to solve this problem, but some attempts at automation have been made to resolve this problem. Some of the solutions include:
- Schematics are exported into text formats like EDIF or net lists and the text files are compared using text diff tools. This method is probably better than staring at two open schematics but it is still tedious and time consuming as the text differences have to be traced back to the schematic.
- Layouts are exported to GDS format and two versions of GDS can then be xor-ed to spot the differences. This is much better than diff-ing exported text files but it does take time and uses expensive tool licenses.
Figure 1: Find the differences
Visual Design Diff
The difficulty of the process and the time required to find differences between versions of schematics and layouts often prevents engineers from reviewing their changes before checking them in. For this same reason, peer and supervisor reviews are also limited, even though overlooked differences can directly lead to project delays and deficiency in product quality. Design teams can benefit tremendously by having the capability to quickly and easily identify the changes between different versions of graphical design objects.
Currently, major EDA vendors do not provide graphical design diff capabilities. To fill this void, Cliosoft has built a graphical diff utility that visually highlights the differences between two schematics or layouts, or two versions of the same. For the Cadence Virtuoso® flow, for example, changes to nets, instances, layers, labels and properties are detected and highlighted directly in the Cadence Virtuoso schematic or layout editor. The differences and details are presented in a list allowing users to step through the changes.
Figure 2: Identifying the differences
A graphical difference engine for schematics and layout brings the power of diff to mixed-signal and custom designers that software and front-end digital engineers have long enjoyed. It enables designers to quickly check changes before publishing a new revision of a cell view and managers can review the changes before approval. For the layout engineers, visual design diff can identify modifications made to the schematics, and review the ECOs without the time-consuming process of generating and comparing GDS. Cliosoft’s Visual Design Diff relieves engineers from the tedious task of finding differences and guarantees that all changes are highlighted. This encourages checks and reviews, which directly increases productivity and improves product quality.