Skip to : [Content] [Navigation]
 

Originally Published MEM Fall 2001

EMBEDDED SYSTEMS

Reconfigurable Computing for 3-D Medical Imaging

Field-programmable gate arrays in combination with cpus provide a flexible system that can be upgraded easily, quickly, and cheaply.

Stuart Newton and David Vornholt

Three-dimensional imaging technology may have extended the diagnostic capabilities of physicians more than any medical advance since the taming of the x-ray. For example, computerized axial tomography machines—CAT scanners—capture a series of cross-sectional images of a body structure that can then be intelligently assembled into a 3-D image by a computer. The processing performance of the image-rendering system determines just how quickly a doctor gets the information needed to diagnose and treat the patient. Sometimes, the watchword is "the sooner the better." In general, this class of diagnostic instruments collects huge amounts of data from high-density organs like the brain and liver, requiring extremely complex algorithms to convert the data into meaningful images. To accelerate the performance of these algorithms frequently means depending on hardware-based processing engines, because using software on a general-purpose processor simply does not produce an acceptable delivery time for the final, readable image.

Medical imaging systems such as these are often mission-critical: a patient's health may be at risk. These systems can help doctors diagnose medical problems faster for prompt attention and help scientists develop new drugs that can save lives. Because of their enormous potential capability, the healthcare market clamors for state-of-the-art systems that can process images rapidly for analysis using techniques that identify shades, colors, and relationships that cannot be perceived by the unaided eye. Equipment manufacturers are under pressure to develop cost-effective medical diagnostic instruments based on the most advanced technology—which is constantly changing—and to bring these products to market quickly. Fortunately, there is a way they can manage this.

Instead of trying to squeeze more and more operational power out of central processing units (cpus) to support the insatiable computing requirements of image processing, designers can now develop combinations of cpus and field-programmable gate array technology to provide system-level processing performance to match their application needs (see Figure 1).

Figure 1. Closely coupled system combining a cpu with an FPGA.

Field-programmable gate arrays (FPGAs), arrays of digital logic blocks that are defined in detail below, continue to grow in sophistication, with higher gate counts, faster clock speeds, and lower power requirements, not to mention declining cost. These factors enable medical equipment manufacturers to take advantage of highly optimized silicon without having to assume the expense and risk of developing a custom application-specific integrated circuit (ASIC), an undertaking that can add many months to a product design schedule.

But more important, FPGA technology is reconfigurable. This means that engineers can send not only software improvements but also hardware upgrades to a cpu/FPGA-based system at a moment's notice, to perform a new function, to change existing functionality, or to extend it with new features. The ability to upgrade an expensive piece of medical equipment by a simple file transfer means a faster time to market for instrument manufacturers and cost savings for healthcare establishments that can go no longer before needing to replace equipment. For patients, this advance means more-timely access to the best possible diagnosis and treatment.

Reconfigurable computing is an important enabling technology that is poised to revolutionize the medical diagnostic industry. This article is intended to provide equipment designers and manufacturers with an understanding of how this concept can be applied across a wide range of high-powered medical devices.

The Advantages of Reconfigurability

The term reconfigurable computing has come to refer to a loose class of embedded systems. Many system-on-a-chip (SoC) computer designs provide reconfigurability options that provide the high performance of hardware with the flexibility of software. To most designers, SoC means encapsulating one or more processing elements—that is, general-purpose embedded processors and/or digital signal processor (DSP) cores—along with memory, input/output devices, and other hardware into a single chip. These versatile chips can perform many different functions. However, while SoCs offer choices, the user can choose only among functions that already reside inside the device. Developers also create ASICs—chips that handle a limited set of tasks but do them very quickly.

The limitation of most types of complex hardware devices—SoCs, ASICs, and general-purpose cpus—is that the logical hardware functions cannot be modified once the silicon design is complete and fabricated. Consequently, developers are typically forced to amortize the cost of SoCs and ASICs over a product lifetime that may be extremely short in today's volatile technology environment.

Solutions involving combinations of cpus and FPGAs allow hardware functionality to be reprogrammed, even in deployed systems, and enable medical instrument OEMs to develop new platforms for applications that require rapid adaptation to input. The technologies combined provide the best of both worlds for system-level design. Careful analysis of computational requirements reveals that many algorithms are well suited to high-speed sequential processing, many can benefit from parallel processing capabilities, and many can be broken down into components that are split between the two. With this in mind, it makes sense to always use the best technology for the job at hand.

Processors are best suited to general-purpose processing and high-speed sequential processing (as are DSPs), while FPGAs excel at high-speed parallel processing. The general-purpose capability of the cpu enables it to perform system management very well, and allows it to be used to control the content of the FPGAs contained in the system. This symbiotic relationship between cpus and FPGAs also means that the FPGA can off-load computationally intensive algorithms from the cpu, allowing the processor to spend more time working on general-purpose tasks such as data analysis, and more time communicating with a printer or other equipment.

Evolving FPGAs

FPGAs are arrays of logic blocks that are strung together through software commands to implement higher-order logic functions. Logic blocks are similar to switches with multiple inputs and a single output, and are used in digital circuits to perform binary operations. Unlike with other integrated circuits, developers can alter both the logic functions performed within the blocks and the connections between the blocks of FPGAs by sending signals that have been programmed in software to the chip. FPGA blocks can perform the same high-speed hardware functions as fixed-function ASICs, and—to distinguish them from ASICs—they can be rewired and reprogrammed at any time from a remote location through software. Although it took several seconds or more to change connections in the earliest FPGAs, FPGAs today can be configured in milliseconds.

Field-programmable gate arrays have historically been applied as what is called glue logic in embedded systems, connecting devices with dissimilar bus architectures. They have often been used to link digital signal processors—cpus used for digital signal processing—to general-purpose cpus.

The growth in FPGA technology has lifted the arrays beyond the simple role of providing glue logic. With their current capabilities, they clearly now can be classed as system-level components just like cpus and DSPs. The largest of the FPGA devices made by the company with which one of the authors of this article is affiliated, for example, has more than 150 billion transistors, seven times more than a Pentium-class microprocessor. Given today's time-to-market pressures, it is increasingly critical that all system-level components be easy to integrate, especially since the phase involving the integration of multiple technologies has become the most time-consuming part of a product's development cycle.

Integrating Hardware and Software

Systems designers producing mixed cpu and FPGA designs can take advantage of deterministic real-time operating systems (RTOSs). Deterministic software is suited for controlling hardware. As such, it can be used to efficiently manage the content of system data and the flow of such data from a cpu to an FPGA.

FPGA developers can work with RTOS suppliers to facilitate the design and deployment of systems using combinations of the two technologies. FPGAs operating in conjunction with embedded design tools provide an ideal platform for developing high-performance reconfigurable computing solutions for medical instrument applications. The platform supports the design, development, and testing of embedded systems based on the C language.

Integration of FPGA technology into systems using a deterministic RTOS can be streamlined by means of an enhanced application programming interface (API). Designers can emulate the collaboration between Xilinx (San Jose, CA), a manufacturer of programmable logic devices (i.e., FPGAs), and Wind River Systems Inc. (Alameda, CA), a creator of RTOS-based embedded systems, which produced the PAVE framework. That API provides a set of commands covering configuration, readback, rollback, and utilities for verification, and serves as the intermediary between the cpu, the RTOS, and an FPGA. Such an interface allows developers to create an application to download FPGA content during development and after deployment. Collaborations can also generate hardware reference solutions featuring FPGA devices and tools that could support the use of FPGA technology in systems in order to optimize the synergy of the two technologies.

The blending of hardware, firmware, application software, and an RTOS into a platform-based approach removes many of the development barriers that still limit the functionality of embedded applications. Development, profiling, and analysis tools are available that can be used to analyze computational hot spots in code and to perform low-level timing analysis in multitasking environments.

One way developers can use these analytical tools is to determine when to design a function in hardware or software. Profiling enables them to quickly identify functionality that is frequently used or computationally intensive. Such functions may be prime candidates for moving from software to FPGA hardware. An integrated suite of run-time analysis tools with a run-time error checker and visual interactive profiler can help developers create higher-quality, higher-performance code in little time.

Other tools can aid developers in determining the appropriate loading and timing for system functions. Once the analysis is complete, properly loaded and timed functions can be off-loaded from a cpu to an FPGA. System-level diagnostic and analytical tools can provide detailed, graphical insight into the dynamics of embedded applications, visually demonstrating the time-based flow of interactions between tasks, interrupts, and system objects. The tools can contribute advanced triggering, filtering, and logging capabilities that enable developers to home in on program areas of interest quickly.

Conclusion

Medical equipment manufacturers are under more pressure than ever to develop cost-effective medical diagnostic instruments. Using the most advanced technology to bring these products to market quickly requires an understanding of the options that are available. The ability to reconfigure systems will give OEMs many exciting new opportunities to develop and deploy high-performance embedded solutions for a wide range of medical imaging applications. Existing technologies can be combined in operational platforms that support reconfigurability now. Such future technological advances involving system-level components may bring another great leap in diagnostic capabilities and patient outcomes.

Development Tools for Embedded Systems

Wind River (Alameda, CA), Xilinx (San Jose, CA), and Celoxica (Abingdon, UK) offer the operating system and development tools needed to design, develop, and test embedded systems based on the C language as well as on hardware description languages (HDLs) such as very-high-speed integrated circuits hardware description language (VHDL) and Verilog. These tools are even more applicable within the new design environment required for high-performance reconfigurable computing systems.

Tools available from Wind River include the following:

  • Tornado Tools' integrated development environment enables developers to accelerate the configuration, development, and debugging of applications based on real-time operating systems such as VxWorks.
  • Alternately, developers can use Diab C/C++ compilers, which feature target- and application-specific optimization technology to generate fast, compact code.
  • An integrated suite of Run-Time Analysis tools, including a run-time error checker and visual interactive profiler, help developers create high-quality, high-performance code in less time.
  • WindView is a system-level diagnostic and analysis tool that provides detailed graphical insight into the dynamics of embedded VxWorks applications, visually demonstrating the time-based flow of interactions between tasks, interrupts, and system objects.
  • VisionPROBE II provides a high-speed parallel connection between a host debugger and target microprocessor for a PC-based development environment.
  • VisionCLICK is a C/C++ source-level debugger for Windows 9x/NT. It contains a graphical, object-oriented, monolithic user interface offering hardware control and downloading via emulators or debug cables.

Tools available from Xilinx include the following:

  • ISE is a set of design tools for HDL-centric field-programmable gate array (FPGA) designers that gives fast compile times and high performance. It includes design entry, simulation, and place and route
  • The PAVE interface is an API for programming FPGAs in VxWorks embedded systems. The interface encapsulates the design work into a set of commands covering configuration, read-back, and utilities for verification.

Celoxica has produced DK1, a design suite that allows Wind River's customers to create traditional C software content for FPGAs.

Stuart Newton is business development manager for the platforms group of Wind River Systems Inc. (Alameda, CA). David Vornholt is marketing manager for IRL solutions at Xilinx (San Jose, CA).

Copyright © 2001 Medical Electronics Manufacturing