SOC-ing it to Software
by Lindsey Vereen
This is the Year of the System on a
Chip. Again. A system on a chip (or SOC - sometimes they're called system-level integrated circuits, SLICs, or any of a number of other similar names) integrates multiple cores on a single die. The concept is in vogue because with decreasing feature sizes on silicon (0.35 microns is becoming common), engineers can design chips with gate counts extending into the millions. With all that area, engineers can stuff most of the functionality they need onto a single die. Elements they can integrate include
microprocessor cores, DSP cores, ROM, peripherals, specialty functions like MPEG or PCI, and even DRAM. A cottage industry of third party intellectual property (IP) providers has sprung up to help take the development burden of cores off of the shoulders of system developers.
No matter where you stand on the technology curve, the systems you are designing today are more highly integrated than the ones you were designing a few years ago. This trend will not reverse itself because integration offers too many
advantages to give up. Benefits of high integration include lower cost, higher reliability, faster time to market, smaller physical product size, lower power consumption, and better security for your intellectual property. Because exploiting high integration requires that you partner with semiconductor vendors and come up with some pretty healthy non-recurring engineering costs, this opportunity is not open to everyone. But over time itýs becoming available to an increasing number of companies, and other
high-integration opportunities are available to everyone else.
Even with all of the benefits of higher integration on your side, you still must overcome numerous challenges. Integrating multiple cores successfully is not a trivial task, especially when they come from different IP vendors. Cores can be described in various ways and often use different interfacing methodologies. They also may use different test methodologies or none at all. An organization called the Virtual Socket Interface (VSI) Alliance has
been established to promote standard solutions to these problems. Members of VSI include major electronic design automation (EDA) vendors, silicon vendors, independent IP providers, and system companies all working together to find ways to successfully mix and match intellectual property on a piece of silicon.
All of the problems associated with higher integration are not on the hardware side. Software development, integration, and debug present new challenges as more functions are packed into a chip
whose operating speed may climb beyond 100MHz. One obstacle to software developers is the loss of visibility within the chip. When everything is on the chip, and all signals do not come out to pins, itýs harder to see what's going on within the system. Ironically, the time-to-market advantages that can be gained with highly integrated systems are liable to be lost through slow and difficult software integration.
You'll probably stop hearing about the system on a chip once the process of embedding systems
into silicon becomes a fait accompli. After all, you never hear the term "system on a board." The trend toward higher integration is inexorable and will soon affect most embedded software developers. To be successful, solutions to the software integration and debug challenges will have to be found and implemented. For that to happen, software engineering must be brought in early in the development cycle. Integration doesn't stop with hardware and software - it must include the engineers as well. That may be
the hardest task of all.
Lindsey Vereen
