We’ve noted here before how old-school analog designers are. While digital designers have moved up in abstraction layer by layer by layer, analog designers still do things the old way. They still draw schematics. They still push polygons. OK, they don’t cut rubylith anymore, but that’s about it.
That’s not to say that they’re stuck in the past; it’s just that no one has really given them a better alternative – or at least not one that’s natural and easy to use. So they’ve remained in their own world with their own tools and their own methods, largely owned by Cadence – conceded by all to be the master of analog.
Actually, no one seems to call it analog. It’s called “custom.” Seems like you could have custom digital circuits as well, but never mind. In this world, “custom” is synonymous with “analog.” Simply put, they’re the only ones that are going to concern themselves with the exact location and shape of each transistor.
From a simulation standpoint, the kinds of abstractions that can be used for digital don’t work, of course. So it’s SPICE (or Fast SPICE if you don’t need quite the same accuracy). But what you can do with SPICE is relatively primitive as far as schematic entry goes. According to Lynguent’s Martin Vlach, you get about 20 primitives, and from there you have to build your own macros.
One of the big advances of the digital world was the transition from schematic-based design to text-based design. In fact, when it comes to much of the critical infrastructure for things like design configuration management, digital designs are considered basically to be software. (And somehow that’s said in a way that could be interpreted as somewhat deprecating or condescending… I challenge anyone to navigate the intricacies of a 10-million-line piece of “just software”…)
So while digital architects might create block diagrams to represent structure and abstract functionality, in the end those blocks are filled with RTL to describe what is supposed to happen in detail.
That hasn’t really been possible for analog designers until recently, with the advent of AMS variants of VHDL and Verilog. So now, finally, analog designers can do what digital designers have been doing for years: they can do their designs using text rather than graphically.
There’s only one problem.
Analog designers like designing graphically, according to Mr. Vlach. They don’t like text. While powerful, the languages are complex and alien; they’re simply not a natural paradigm for capturing and modeling analog behavior.
Well, isn’t that a fine thank-you-very-much indeed! Here folks went off and spent time and energy, slaving away, developing a perfectly fine text-based way of expressing analog behavior, and these guys sniff and push it off the table like a one-year-old tests gravity (again) (call it a regression test) by pushing a plate of hand-crafted spinach onto the floor. Like spinach, these languages are supposed to be good for you.
And this is where Lynguent steps in. They provide the ModLyng integrated modeling environment, which, at its heart, is a pretty simple concept: take text analog designs and wrap them in a graphic symbol. Or, looked at another way, take a graphic symbol and generate text to represent the intended behavior.
The reality is, of course, more complex than that. These models are based on what Lynguent calls “effects.” An effect is a behavior that isn’t fully a model on its own. It’s kind of like a primitive or a basic operation (and it can be a basic operation, like an add function). These can be assembled into models; the environment comes with a library of such models already developed.
These models can then be interconnected to represent the desired analog circuit. Many of the models are parameterizable, allowing a single complex block to be customized for numerous specific instances.
The specification and interconnection of these models results in the creation of a text file that can be handled by any of the analog simulators that handle the AMS language variants. ModLyng is integrated seamlessly into the Cadence environment, but it can also output models for other simulators as well.
While the out-of-the-box models may suffice for many uses, it’s likely that some designers will need to go beyond them. In that case, they can either build models from scratch or modify existing ones. Modifying an existing model can be done three different ways:
– by editing the HDL underlying the model;
– by adding effects to the model; or
– by taking the model, adding effects, and then saving with a new symbol as a new model.
As a result of the variety of models plus the complexity that the underlying language enables, Lynguent claims that ModLyng can be used to model entire circuits rather than single blocks.
Based on this capability, designers can also now do top-down design, starting with abstract behavior and pushing down to the details, ultimately invoking SPICE as needed for detailed precision. Having to rely on SPICE throughout, using the old model, was almost by definition a bottom-up approach.
All of these specifics aside, however, there lingers one of those nagging questions. The concept of encapsulating code in a symbol is not new and it’s not really hard. OK, you have to keep track of some stuff, but that’s pretty much all bookkeeping. It would be surprising for a new technology company to base its future on something relatively straightforward that could be easily copied if it took off.
And so I asked why it was something that couldn’t be done by just anyone. And it turns out that the mere burying of code under the symbol isn’t the hard part. Several things raise the barrier against someone simply copying the idea.
– The parameterization adds a layer of complexity (although that in and of itself wouldn’t remain a barrier for long; parameterization is a pretty well-understood concept).
– The blocks have to be isomorphic to multiple languages – at present, VHDL-AMS, Verilog-AMS, and MAST (not surprising, since Mr. Vlach invented MAST). The AMS versions of VHDL and Verilog are rather different in how they approach circuits, so being able to handle both is non-trivial.
– They can export models for multiple simulators. Perhaps you might not file this under “B” for “breakthrough new technology,” but it’s the kind of work where you can invest a lot in the details, and it can take a long time to get it right; anyone else stepping in would have to do the same thing.
– They’ve also built extensibility into the system.
So they seem pretty convinced that what they have is easily differentiated and protected from would-be usurpers.
And so we come full circle, only not quite. (There seems to be a bit of that going around…) We’ve gone from simple graphical design to complex – but hard-to-use – languages to graphical design that incorporates the complexity made available by the languages.
What’s old is new again.