Why the hardware emulation operating system is like a computer system

// php echo do_shortcode (‘[responsivevoice_button voice=”US English Male” buttontext=”Listen to Post”]’)?>

Charley Selvidge, director of engineering at Mentor, a Siemens company, has a lowly, unassuming demeanor that contradicts a sharp intellect and a scholarly ability to explain complex concepts in easy-to-understand terms.

All of this is useful when explaining the landscape of hardware emulation, something he knows a thing or two about. In the late 1990s, Charley was one of the founders of Virtual Machine Works, which was located a stone’s throw from MIT in Cambridge, Massachusetts. VMW, as it was called, was acquired by IKOS Systems in 1998, which then became part of Mentor in 2002.

Through all of the changes, including a cross-country move to California, Charley continued to design new and improved emulators. He is the brains behind the latest version of the Veloce Emulation Platform, a user-friendly emulation platform for data centers called Veloce Strato.

Lately, Charley has thought that the operating system for a hardware emulator is a natural evolution of the way software systems are built for emulators.

To illustrate, he uses the analogy of a computer system. “In the early days of computing, computers did not have an operating system. Programmers quickly determined that it would be useful to have off-the-shelf software between low-level computer hardware operations and the high-level tasks or programs they wanted to run on the computer. A layered approach would provide a cohesive set of services and facilitate the production of applications and programs, avoiding the need to reinvent or replicate common underlying capabilities, such as opening files or other interactions with the computer.

He shifts his analogy to emulators and notes, “They consist of a hardware execution platform at the bottom to run a digital chip model and a set of application-oriented tasks to run on the emulator. These tasks often have high-level goals, such as characterizing the amount of power consumed by a chip or processing a software application that runs on a processor inside the chip. In either case, the entire chip should be seen as part of the job.

Undeniably, he adds, these are complex, high-level tasks that an emulator performs on a regular basis. A standard set of intermediary services for emulation within an operating system could isolate high-level tasks from the machine-specific low-level details associated with emulation.

For this reason, says Charley, operating systems are an interesting concept for an emulator.

Hardware and software scalability in hardware emulation
All emulators are based on some sort of modeling component; that is, a device capable of modeling a piece of a chip. A multitude of these modeling components are assembled in small, medium, or large numbers to build systems of varying sizes. In addition to this underlying hardware is a software compilation system. An emulation compiler reads a database or model of an integrated circuit and writes a data stream that configures the network of modeling components in the emulator to form an image of the chip.

Typically, integrated circuits are designed through computer programs that perform a circuit description written in one of a few computer languages, generically referred to as hardware description languages ​​(HDL). The most commonly used HDLs are Verilog, SystemVerilog, and VHDL. The circuit description defines the behavior of the circuit. These descriptions are synthesized in a real integrated circuit and compiled into a model that runs on an emulator.

According to Charley, with a chip model, the designer would load it onto the emulator, a machine-specific task performed by the emulator’s operating system software. The operating system performs several other tasks, including running and stopping clocks, accessing design visibility data or applying a stimulus to the emulated model and collecting its responses. It should be noted, he adds, that the task of verifying the functional design is to write data to the device, extract data from it, decide if it is correct, and interact with it.

These basic tasks are common to most of the higher level tasks that an emulator can perform. It offers a few examples, including power characterization, software execution, and a number of other activities. They in turn bring various elements of the underlying services into play to perform them. Charley suggests extracting visibility data to establish energy consumption as an example. This involves running the design in a test environment, extracting the data, processing it, and feeding it into more software for power computing.

Software complexity scaling is a dimension of scaling and another good example. It is useful to have an operating system to provide a basic set of functions and services used by more complex tasks managed at a higher level of abstraction – in other words, the way programming works. computer science. Charley adds, “Designers don’t want to program in assembly language. They don’t want to have to write their own file service routines. Instead, they use standard compilers and capabilities like file service access.

The second aspect of scaling an emulator’s operating system is its ability to model devices of a wide variety of sizes. At one end of the spectrum, a designer may choose to model an intellectual property (IP) block that can be small and fit into a small set of emulation hardware resources. In contrast to the spectrum, a designer could model a complete system-on-chip (SoC) design, such as a processor or a large internet switch chip. This creates a set of software-oriented challenges to develop suitable software capabilities to handle small models as well as large models.

“It’s harder to manage large designs, but even harder to develop the right tradeoffs to cover a wide range of sizes,” he admits. Once the software challenges are tamed, it would help to store the solution in a standard location. This place is in an operating system.

Providing services inside an operating system for features like visibility can support capabilities suitable for small designs as well as large designs without designers knowing what might be hiding. behind the ability to evolve effectively.

“In these two dimensions, an operating system is a relevant software organizational strategy for developing the software for an emulator,” explains Charley.

Hardware emulation applications
All of this leads Charley to a new wrinkle in hardware emulation. It joins the world of “applications”, such as PCs or mobile phones, facilitated by the implementation of the services used by these applications in the same way that software works for these consumer devices.

When it comes to application-specific problems, such as “applications” and software development to solve them, it helps to have lower-level services packaged in such a way that the software does not have to. need to be in writing to accomplish these tasks. These services can be provided in a form accessible by an operating system through a set of application programming interfaces (APIs), an approach that allows higher-level applications to access the underlying services.

By implementing this type of software organization, that is, an operating system and applications, designers can stabilize the operating system software and define an efficient and consistent set of APIs. This approach provides an efficient method for developing applications without worrying about lower level details and for working across different generations of the hardware emulation platform.

Another aspect of using an operating system is its ability to isolate higher level software elements such as applications from changes in the underlying hardware by providing adaptation layers that provide transparency. With this approach, designers can create applications that do not change as the hardware platform evolves, protecting the original investment and the operator in the future. Instead of recreating old software to run on new platforms, designers can invest energy in creating new software that runs on multiple generations of platforms.

“Such an approach to organizing the operating system and software applications is unique and advantageous for designers,” he concludes. And with that, we leave Charley to return to thinking about operating systems and, perhaps, the next-gen hardware emulator. In the meantime, we still have to consider the possibilities of hardware emulation of the future.

Dr Lauro Rizzatti is a verification consultant and industry expert on hardware emulation (www.rizzatti.com). Previously, Dr Rizzatti held management, product marketing, technical marketing and engineering positions. He can be contacted at [email protected]

Similar Items:

Gordon K. Morehouse