Steve Leibson

Cut Power Through Peripheral Magic (and SSDs)

You might be focusing all your effort on developing low-power systems by concentrating your efforts on your system’s logic board. Did you stop to consider that you can also find a quick way to cut a lot of power consumption by re-evaluating your choice of peripherals? Here, I’m specifically writing about hard disk drives (HDDs). Many embedded systems, and larger systems, incorporate rotating, mechanical disk drives. Both IDE/PATA and SATA HDDs are increasingly common in all sorts of systems including many embedded designs. Your designs might use either type. I’ve just spent the last three days attending the Flash Memory Summit and the theme of the day and of the year was solid-state drives (SSDs)—assemblages of semiconductors that emulate HDDs at the interface level so that they can plug into existing interfaces in most systems. SSDs can replace HDDs in many cases and save you Watts of power.

Here’s where a bit of digression is in order. The HDD industry has hit bottom on cost, resulting in the $30 HDD, as explained at the Flash Memory Summit by Sun Microsystems’ Lead Technologist for Flash Memory, Michael Cornwell. The $30 HDD has one platter and one head. It’s the cheapest thing the HDD vendors can make. It rides the bit-density curve and whatever fits on one platter at any given time is what the capacity is. It costs $30 (hence the name).

Lots of embedded products use this cheap HDD for secondary storage. The $30 HDD’s capacity is presently 120 Gbytes, which conveniently works out to 25 cents per Gbyte of storage. However, HDD capacity never stands still. The industry has a consensus road map for improving HDD density 10-30x and the $30 HDD will ride that curve like all of the more expensive HDDs. They will still cost $30.

SSDs of equivalent capacity cost more than $30. A lot more. And they will for a while. While many industry pundits predicted a crossover in cost per Gbyte last year when NAND Flash prices were dropping like a rock, the picture is quite different this year. NAND Flash prices aren’t falling nearly so fast so the pundits are saying (this year) that SSDs will never reach price parity with equivalent-sized HDDs.

For a lot of products, that smaller drive capacity doesn’t matter. For many products, 120 Gbytes of capacity is already way too much and yet that’s the smallest HDD increment you can get today. Not so with SSDs, which are based on NAND Flash chips, not spinning platters. For example, you can get IDE/PATA and SATA SSDs from SanDisk in capacities from 8 to 64 Gbytes. If those capacities work for your design, then you’ll like the power consumption: 0.5W typical, 0.15W average (typical), and 15mW in sleep mode. If the smaller capacities work for your design, you can also save money because at least some of those SanDisk SSDs cost less than $30. Also note that an SSD wakes up much faster than an HDD, so a sleep mode spec has considerable value in many applications.

Switching from an HDD to an SSD may be a very easy way to carve out some power consumption from your design. As an added bonus, the SanDisk drives are even smaller than a conventional 1.8-inch HDD, so you can carve some cubic millimeters from your system design and you can save on BOM cost as well. SSDs have a lot to commend them and merit consideration in your design.

Squeezing Excess Power Out of Synthesized Blocks

With the glacial-like industry move towards transaction-level simulation using OSCI’s TLM 2.0, I think that C and SystemC will be used more and more for the initial descriptions of large portions of many systems. Many system blocks will therefore end up as compiled software (or firmware) running on standard-architecture processors and application-specific processors because it’s just easier to compile such descriptions and run them on processors. C and SystemC are sequential languages and they just beg to be implemented as firmware running on a processor.

But processors just aren’t the right implementation solution for every design problem. Sometimes, it just has to be gates; Lots of them. There are two ways to generate gate-level designs. One way is to write an RTL description of the block by hand and then verify it through simulation. I discussed a way to fit such a block into a system-level simulation using Mentor’s Vista in a previous blog entry. Mentor’s Vista incorporates a model builder that will generate a TLM 2.0 functional description of an RTL block. Another way to generate gate-level block designs from a C or SystemC description is to synthesize the description and produce an RTL description.

Whether manually produced or synthesized, there’s a good chance that the resulting block will need some attention to squeeze excess power dissipation out of the design. Why? Because designers creating RTL descriptions often do not have the time to go back and make sure that all of a block’s clocks are gated off whenever possible and C or SystemC descriptions mostly omit any hints as to what portions of a block can be switched off during block operation, giving synthesis tools little to go on.

Enter Calypto and its SLEC (sequential logic equivalence checker) technology. I had an interesting discussion about SLEC and derivative products at DAC with Venkatram Krishnaswamy, Calypto’s VP of Applications Engineering and Solutions. The original idea behind SLEC was to formally verify equivalence between two block descriptions. Today, these block descriptions can be written in C, C++, SystemC, or RTL and SLEC can compare the blocks for equivalency. The original intent for creating SLEC was to find bugs but the resulting deep circuit analysis is useful for other tasks, like power reduction. The detailed sequential analysis technology developed for Calypto’s SLEC can deduce facts about that design that can help cut operating power.

SLEC can look at RTL blocks synthesized from C or SystemC and verify that a synthesized block is functionally equivalent to the original description. This is an important aspect of the product because C and SystemC descriptions are essentially untimed and therefore give synthesis tools many problems. Many C coders write C and SystemC code that’s not easily synthesized. Let’s face facts. It’s almost too easy to write hard-to-synthesize code in a language not originally intended to be synthesized. Calypto’s SLEC can detect the presence of synthesis impediments in the generated RTL and can help coders rewrite their source code with more detailed functional descriptions that help a synthesis tool generate better RTL. Think of SLEC as a second pair of mechanical eyes on the code that helps the code writer iterate on a C model that results in a better QOR (quality of results).

Detailed sequential analysis can deduce facts about that design that can help cut operating power and so Calypto has produced two additional tools based on sequential analysis that provide push-button power reduction for RTL blocks. The first such tool is called PowerPro CG, which inserts clock-gating enable logic into the RTL description based on an analysis of the RTL block’s sequential operation. This added RTL allows the logic-synthesis tool to more easily infer the required combinational clock gating. Gating clocks in sequential circuits cuts a block’s dynamic power consumption while raising static power consumption slightly due to increased gate count so there’s a balance to be struck. Of course a good block designer with sufficient time can analyze the block’s function and insert the clock-gating circuits manually. But who has the time? Typically, you find extensive clock gating only in highly leveraged blocks such as commercial processor IP cores.

Often, you need test vectors that exercise a block to ensure that you’ve caught all of the clock-gating opportunities. Although PowerPro CG isn’t perfect, Krishnaswamy estimated that PowerPro CG can find roughly 80% of the clock-gating opportunities without test vectors. If true, you know that most engineers will push the button and just take the 80%. Even though they might get most of the remaining 20% by writing a comprehensive test vector suite, well, “Who has the time?”

The other Calypto power-reduction tool is called PowerPro MG. It gates memories using similar analysis techniques. PowerPro MG exploits a “light-sleep” mode available in many of the latest static-memory IP cores available from vendors such as Virage Logic. The light-sleep mode, which is activated by a pin on the memory core, powers down the memory but retains memory state. PowerPro MG can take sleep and wake-up memory timing into consideration when determining the opportunities for exploiting light-sleep modes. Casual analysis of memory usage on SOCs will demonstrate that many memories are never put into a sleep mode, so there is much opportunity for power savings in this arena.