SystemC provides hardware-oriented constructs within the context of C++ as a class library implemented in standard C++. Its use spans design and verification from concept to implementation in hardware and software. SystemC provides an interoperable modeling platform which enables the development and exchange of very fast system-level C++ models. It also provides a stable platform for development of system-level tools.
This overview was first published on April 21, 2009, and describes SystemC and its tools as they stood then. Later changes are in the dated section at the end.
SystemC in plain words
Verilog and VHDL describe hardware at the level of registers and gates. That is exactly what you need to build a chip, but it is slow to simulate and too detailed when you are still deciding what the chip should be. SystemC adds hardware ideas (modules, ports, signals, clocks, concurrent processes) to ordinary C++. You compile your model with a normal C++ compiler and link it with the SystemC library, and the result is a program that simulates your system.
Because it is C++, the same language can describe the software and the hardware, and a model can start as a plain function and be refined step by step toward hardware.
Why it matters: transaction-level modeling
One of the major benefits of SystemC is the ability to model at the transaction level (TLM), where the use of simple function calls in communication modeling brings gains in both coding productivity and simulation speed. Instead of toggling every wire of a bus on every clock, a processor model simply calls write(address, data) on a memory model. This is what lets software teams run their code on a "virtual platform" of a chip long before the silicon exists.
By 2009 the TLM standard was here and being adopted. The OSCI TLM interface standard extended the practical value of the SystemC class library by providing a standard modeling kit for the construction of TLM interfaces, reducing the work needed to construct new interfaces and increasing the opportunities for interoperability. At the same time, version 2.1 of the SystemC class library added new features which extended the utility of SystemC for transaction-level modeling. The open source proof-of-concept SystemC 2.1 library and the TLM library had both been updated.
Who looked after SystemC in 2009
The Open SystemC Initiative (OSCI) was an independent not-for-profit organization composed of a broad range of companies, universities and individuals dedicated to supporting and advancing SystemC as an open source standard for system-level design. Its specific purposes included:
- Building a rich system-level design language and open source implementation based on C++ class libraries, called "SystemC".
- Encouraging availability and adoption of intellectual property (IP), tools and methodologies based on SystemC.
- Providing the mechanisms that enable the continued growth of the SystemC community.
- Defining interoperability criteria for IP and tools based on SystemC.
- Delivering updates to the SystemC Language Reference Manual (LRM) and open source implementation.
- Standardizing the SystemC language via the IEEE.
SystemC and its downloads are now maintained by Accellera: see the Accellera SystemC standards and downloads page.
Success stories from STMicroelectronics, Intel, IBM, Qualcomm, Texas Instruments and Conexant were given in session 22 of the 2004 Design Automation Conference (DAC).
The 2009 tool and model landscape
A SystemC model of the AMBA bus
A SystemC specification of the AMBA bus was available free of charge. The specification is a fully cycle-accurate representation of the AMBA AHB protocol, including the AHB-Lite protocol that is widely adopted for high-performance bus-matrix architectures. The AMBA specification is an established, open methodology that serves as a framework for SoC designs, providing the interconnect that binds IP cores together. The specification had been downloaded by more than 12,000 design engineers and implemented in hundreds of ASIC designs. The AMBA AHB cycle-level modeling specification was available for download from ARM's AMBA overview page (archived copy).
Synthesis from SystemC
Synthesis of SystemC could be performed using the Agility Compiler from Celoxica (archived product page). The compiler synthesizes SystemC directly to high-density FPGA and programmable SoC logic and generates RTL VHDL and Verilog for SoC design. SoC designers using SystemC can keep the C level of design abstraction throughout the design process while taking advantage of simulation speeds that are orders of magnitude faster than RTL. Thus whole systems can be verified using the same testbench at all stages of the design process.
Forte Design Systems offered Cynthesizer (archived product page), a synthesis tool that delivers an implementation path from SystemC to RTL, verification and co-simulation. Cynthesizer automatically generates optimized RTL code from a C++/SystemC algorithmic description. It can also be used to explore architectural trade-offs such as area and performance.
System-level design to implementation
CoWare, Inc. partnered with Forte to provide the first integrated SystemC-based solution for electronic system-level (ESL) design to implementation. The integration of CoWare's SystemC-based ConvergenSC system-on-chip (SoC) design tools and Forte's Cynthesizer SystemC behavioral synthesis product unites system architecture, simulation and synthesis in one flow. Users can explore and validate a design's system architecture in ConvergenSC, then synthesize to RTL using Cynthesizer, and verify the RTL in a system context with the same SystemC model.
CoWare also integrated its SPW digital signal processing application design tool with the Cadence Virtuoso custom design platform, so that wireless product design teams could reduce schedule risk through an evolutionary change of their methodology. SPW reference models had been used in the tapeout of thousands of wireless designs. The flow enables broader reuse of the reference models by RF and analog designers. Starting from the SPW front end, users select the parts of the system used as the reference or testbench and mark them for export. SPW then creates an optimized simulation model with interfaces based on SystemC signals and data types. SPW was enhanced with technology from the CoWare ConvergenSC platform design tool, and Cadence's Virtuoso platform uses the same SystemC technology, based on the Cadence/CoWare technology alliance, to import the newly created SPW model. RF designers do not need to be familiar with SPW to benefit from the flow.
University access in 2009
CoWare provided its tools to universities through its university program (UniversityProgram@CoWare.com). For U.S. universities there was no charge for ConvergenSC and LISATek, and up to 300 licenses of SPW could be obtained for an annual fee of $500. For European universities and non-profit research, CoWare participated in the EUROPRACTICE program.
In India, IIT Delhi and IIT Kharagpur used ConvergenSC and LISATek to support courses on system-level modeling, system synthesis and architecture design space exploration.
A free online SystemC tutorial, SCOTT, was hosted at the University of Ulm at the time.
Deep dive: the numbers and details
This part holds a minimal SystemC example, the abstraction levels SystemC is used at, and a dated record of the standards and companies since 2009. Skip it if the overview is all you need.
A minimal SystemC module
A D flip-flop with a testbench, in SystemC. The SC_METHOD process runs on every rising clock edge, just like an always @(posedge clk) block in Verilog.
#include <systemc.h>
SC_MODULE(dff) {
sc_in<bool> clk;
sc_in<bool> d;
sc_out<bool> q;
void step() { q.write(d.read()); }
SC_CTOR(dff) {
SC_METHOD(step);
sensitive << clk.pos();
}
};
int sc_main(int argc, char* argv[]) {
sc_clock clk("clk", 10, SC_NS); // 10 ns period
sc_signal<bool> d, q;
dff u0("u0");
u0.clk(clk); u0.d(d); u0.q(q);
d = 1;
sc_start(25, SC_NS);
std::cout << "q = " << q.read() << " at " << sc_time_stamp() << std::endl;
return 0;
}
The pieces map directly to HDL concepts: SC_MODULE is a module, sc_in and sc_out are ports, sc_signal is a wire, sc_clock is a clock generator, and sc_start runs the simulation for a given time.
The abstraction levels
| Level | What is modeled | Typical use |
|---|---|---|
| Untimed functional | Algorithm only, no clocks | Checking the algorithm, reference model |
| Loosely timed TLM | Transactions as function calls with rough timing | Virtual platforms for software development |
| Approximately timed TLM | Transactions split into phases with timing | Architecture and performance studies |
| Cycle-accurate / RTL | Every signal on every clock | Hardware verification, input to synthesis |
Each step down the table adds detail and costs simulation speed. The 2009 claim, quoted above for Celoxica, of speeds "orders of magnitude faster than RTL" refers to models at the upper levels of this table.
What happened next
| Date | Event | Source |
|---|---|---|
| June 6, 2008 | TLM-2.0 released; TLM-2.0.1 with its reference manual followed on July 23, 2009 | Accellera SystemC downloads |
| March 23, 2010 | Synopsys completes its acquisition of CoWare | Design & Reuse |
| December 5, 2011 | Accellera and OSCI merge to form Accellera Systems Initiative | Accellera FAQ |
| 2011 | IEEE 1666-2011 SystemC Language Reference Manual | Accellera SystemC downloads |
| February 5, 2014 | Cadence announces a definitive agreement to acquire Forte Design Systems | Design & Reuse |
| 2016 | IEEE 1666.1-2016, SystemC Analog/Mixed-Signal Extensions | Accellera SystemC downloads |
| 2023 | IEEE 1666-2023, the current SystemC Language Reference Manual | Accellera SystemC downloads |
Accellera's page lists the IEEE 1666 standards as available free of charge through the IEEE, and the open source SystemC reference implementation, now in the 3.0 series, as including TLM.


Your comments will be moderated before it appears here.