SystemC
Aleksandar Milenkovic
The University of Alabama in Huntsville
Email: milenka@ece.uah.edu
Outline
n Introduction
n Data Types
n Modeling Combinational Logic
n Modeling Synchronous Logic
n Misc
LaCASA A. Milenkovic 2/x
Data Types and Declarations
n Variable // variable
type variable_name1, variable_name2, ...;
n Signal int myint;
n Port // signal, sc_signal declaration
// used for interprocess communication and for
// connecting module instances
sc_signal<type> signal_name1, signal_name2, ...;
// port
sc_in<type> input_name1, input_name2, ...;
sc_out<type> output_name1, output_name2, ...;
sc_inout<type> inout_name1, inout_name2, ...;
LaCASA A. Milenkovic 3/x
SystemC Data Types
n SystemC programs may use any C++ type along with
any of the built-in ones for modeling systems
n SystemC Built-in Types
n sc_bit, sc_logic
n Two- (0, 1) and four-valued (0, 1, X, Z) single bit
n sc_int, sc_uint
n 1 to 64-bit signed and unsigned integers
n sc_bigint, sc_biguint
n arbitrary (fixed) width signed and unsigned integers
n sc_bv, sc_lv
n arbitrary width two- and four-valued vectors
n sc_fixed, sc_ufixed
n signed and unsigned fixed point numbers
LaCASA A. Milenkovic 4/x
C++ Types for RTL SystemC
n bool
n int, unsigned int, long, unsigned long
n signed char, unsigned char
n short, unsigned short
n enum
n struct
LaCASA A. Milenkovic 5/x
Sc_bit type
n Operators supported
n {&, |, ^, ~} - bitwise {AND, OR, XOR, NOT}
n {=, &=, |=, ^=} assignment,
compound {AND, OR, XOR}
n {==, !=} equality, inequality
n sc_bit type can be mixed with operands of
type bool
sc_signal<sc_bit> flag;
bool ready;
flag = sc_bit(0); // assigns the value 0
ready = ready & flag; // 0 eqs false
if (ready == flag) // ok to do this
LaCASA A. Milenkovic 6/x
Sc_bv type
n Arbitrary bit vector
n Rightmost index of the vector is 0 (LSB)
n Examples
sc_bv<8> ibus; // variable ibus
sc_out<sc_bv<4> > abus; // port abus
sc_bv<4> mbus; // variable mbus
sc_bv<8> all_ones(1);
ibus = 00110010;
mbus = 010; // zero extended to 0010
mbus = 10011; // truncated 0011
// to print a value of a bit vector use variable
cout << The value of ibus is << ibus << endl;
LaCASA A. Milenkovic 7/x
Sc_bv operators
n Operators supported
n {&, |, ^, ~} - bitwise {AND, OR, XOR, NOT}
n {<<, >>} bitwise shift {left, right}
n {=, &=, |=, ^=} assignment,
compound {AND, OR, XOR}
n {==, !=} equality, inequality
n [ ] bit selection
n (,) concatenation
n Method
n range() range selection
n and_reduce() reduction AND
n or_reduce() reduction OR
n xor_reduce() reduction XOR
LaCASA A. Milenkovic 8/x
Sc_bv operators: Examples
sc_bv<8> ibus;
sc_out<<sc_bv<4> > abus;
sc_bv<4> mbus;
ibus = 00110000;
mbus = 1011;
ibus[5] = 0; // ibus = 00010000
ibus.range(0,3) = ibus.range(7,4); // 00011000
mbus = (ibus[0], ibus[0], ibus[0], ibus[1]); // mbus=0000
ibus[0] = ibus.and_reduce();
ibus[1] = mbus.or_reduce();
LaCASA A. Milenkovic 9/x
Sc_bv operators (contd)
n Bit selection and the range() method
can be applied only to variables
(not to ports and signals)
n use temporary variables for ports and signals
sc_signal<sc_bv<4> > dval;
sc_in<sc_bv<8> > addr;
sc_bv<4> var_dval;
sc_bv<8> var_addr;
sc_bit ready;
// read bit 2 of input addr
var_addr = addr.read();
ready = var_addr[2];
// assign 011 to a range of signal dval
var_dval = dval;
var_dval.range(0,2) = 011;
dval = var_dval;
LaCASA A. Milenkovic 10/x
Sc_bv operators (contd)
n No arithmetic operations are allowed
on the bit vector types
n convert to signed or unsigned integer, perform
operations, and convert back to a bit vector
sc_in<sc_bv<4> > pha1;
sc_signal<sc_bv<6> > pha2;
sc_uint<4> uint_pha1;
sc_uint<6> uint_pha2;
uint_pha1 = pha1; // overloaded assignment
uint_pha2 = pha2;
uint_pha2 = uint_pha2 uint_pha1;
pha2 = uint_pha2; // overloaded assingment
LaCASA A. Milenkovic 11/x
Logic Type
n Four values
n 0, SC_LOGIC_0
n 1, SC_LOGIC_1
n X, SC_LOGIC_X
n Z, SC_LOGIC_Z
n Operators
n {&, |, ^, ~} - bitwise {AND, OR, XOR, NOT}
n {<<, >>} bitwise shift {left, right}
n {=, &=, |=, ^=} assignment,
compound {AND, OR, XOR}
n {==, !=} equality, inequality
LaCASA A. Milenkovic 12/x
Sc_lv Type
n Arbitrary Width Logic Type
n Bit selection, range(), arithmetic
(see notes for bit vectors)
sc_lv<4> dbus; // variable dbus
sc_signal<sc_lv<8> > cnt; // signal, cnt(7 downto 0)
sc_out<sc_lv<16> > sensor; // port
sc_lv<8> allzs(SC_LOGIC_Z);
sc_lv<8> allxs(SC_LOGIC_X);
dbus = 0011;
sensor = 1011X0X01100ZZZZ;
dbus[2] = X; // dbus = 0X11
dbus[0] = dbus[3]; // dbus = 0X10
cnt = (dbus[3], dbus[3], dbus[3], dbus[3], dbus[3],
dbus[2], dbus[1], dbus[0]); // concatenation
LaCASA A. Milenkovic 13/x
Sc_lv Type (contd)
n Assignments are overloaded to allow translation to
and from a logic vector and an integer type
n Bit vector type and logic vector type can be assinged
to each other
n If a logic vector contains X or Z,
the result of translation is undefined and a runtime
warning is issued
sc_uint<4> driver;
sc_int<8> q_array;
driver = dbus;
q_array = dbus; // zeros are filled as dbus is unsigned
sensor = q_array; // q_array is signed => sign extended
dbus = driver;
cout << Data bus has value = << dbus << endl;
LaCASA A. Milenkovic 14/x
Sc_int: Signed Integer Types
n Precision limited to 64 bits
n 2s complement representation
n All operations are performed using 64 bits
and the result is truncated to the target size
LaCASA A. Milenkovic 15/x
Sc_int: Operators & Methods
n Operators
n {&, |, ^, ~} - bitwise {AND, OR, XOR, NOT}
n {<<, >>} Arithmetic shift {left, right}
n {+, -, *, /, %} Addition, Subtraction, Multiply, Divide,
Modulus
n {=, &=, |=, ^=, +=, -=, *=, /=, %=} assignment, compound
{AND, OR, XOR}, compound {+,-,*,/,%}
n {==, !=} equality, inequality
n {<, <=, >, >=} less than, less than equal, ...
n {++, --} increment, decrement
n [ ] bit selection
n (,) concatenation
n Methods
n range()
LaCASA A. Milenkovic 16/x
Sc_uint
n Unsigned integer
n Fixed precision integer type to 64 bits
n The same set of operators as sc_int
n Can be converted to sc_int and vice versa
LaCASA A. Milenkovic 17/x
Arbitrary Precision
Signed/Unsigned Integer
n sc_bigint<WIDTH>, sc_biguint<WIDTH>
n Used when a precision
of more than 64 bits is required
n Format parameters for to_string()
n SC_BIN, SC_OCT, SC_HEX, SC_DEC(default)
sc_bigint<100> comp, big_reg; // variables
// decimal format
cout << The value of big_reg is << big_reg.to_string() << endl;
// hexadecimal format
cout << The value of big_reg is << big_reg.to_string(SC_HEX) << endl;
LaCASA A. Milenkovic 18/x
Resolved Types
Resolution Table
// resolved logic scalar port type
sc_out_resolved 0 1 X Z
sc_inout_resolved
0 0 X X 0
// resolved logic vector type
1 X 1 X 1
sc_out_rv<WIDTH>
sc_inout_rv<WIDTH>
X X X X X
// resolved logic scalar signal type Z 0 1 X Z
sc_signal_resolved
//resolved logic vector signal type
sc_signal_rv<WIDTH>
LaCASA A. Milenkovic 19/x
User-defined Data Types
n Can be created using the enum and the struct
types
n A signal can be declared to be of such a type
n Four overloaded functions that operate on the
new data type have to be provided
n Operator = (assignment)
n Operator == (equality)
n Operator << (stream output)
n sc_trace()
LaCASA A. Milenkovic 20/x
User-defined Data Types: An Example
// micro_bus.h
#include systemc.h
const int ADDR_WIDTH = 16;
const int DATA_WIDTH = 8;
struct micro_bus {
sc_uint<ADDR_WIDTH> address;
sc_uint<DATA_WIDTH> data;
bool read, write;
micro_bus& operator= (const micro_bus&);
bool operator== (const micro_bus&) const;
}
// to be continued
LaCASA A. Milenkovic 21/x
User-defined Data Types: An Example
inline micro_bus&
micro_bus::operator= (const micro_bus& arg) {
address = arg.addresses;
data = arg.data;
read = arg.read;
write = arg.write;
return (*this);
}
inline bool
micro_bus::operator== (const micro_bus& arg) const {
return (
(address == arg.address) && (data == arg.data) &&
(read == arg.read) && (write == arg.write) );
}
// to be continued
LaCASA A. Milenkovic 22/x
User-defined Data Types: An Example
inline ostream&
operator<< (ostream& os, const micro_bus& arg){
os << address= << arg.address <<
data= << arg.data << read= << arg.read <<
write= << arg.write << endl;
return os;
}
inline void sc_trace (sc_trace_file *tf,
const micro_bus& arg, const sc_string& name) {
sc_trace (tf, arg.address, name+.address);
sc_trace (tf, arg.data, name+.data);
sc_trace (tf, arg.read, name+.read);
sc_trace (tf, arg.write, name+.write);
}
// how to declare two signals of this type
sc_signal<micro_bus> bus_a, bus_b;
LaCASA A. Milenkovic 23/x
Recommendations for SystemC RTL
n For one bit use bool data type
n For vectors and unsigned arithmetic use
sc_uint<n>
n For signed arithmetic use sc_int<n>
n For big vectors use
sc_bigint<n>, sc_biguint<n>
n Use sc_logic and sc_lv<m> types only for
signals that will carry four logic values
n Use resolution types only when resolution is
required such as when a port or a signal has
multiple drivers
LaCASA A. Milenkovic 24/x
Outline
n Introduction
n Data Types
n Modeling Combinational Logic
n Modeling Synchronous Logic
n Misc
LaCASA A. Milenkovic 25/x
