Channels and Interfaces in SystemC

Dr.
Zhonghai Lu
KTH Royal Institute of Technology
C++ Basics
SystemC
Introduction
and Get
Started
Modules
and
Processes
Concurrency
and Time
Channels
and
Interfaces
Transaction
Level
Modeling
KTH IL2452 System Design Languages
SystemC
Data Types
and
Debugging
SystemC
Summary
Aim
Understand communication concepts in SystemC

and know how to use it for design
Content
Primitive channels and interfaces

How to use primitive channels?
How to design my own channels?
Ports (used by modules to access channels)
Hierarchical channels
How to design and use my own hierarchical
channels?
Concept
for communication
Channel categories
Primitive channels
Hierarchical channels
In SystemC, channels model communication enabling

the ESL design concepts.
Separate communication from computation while
offering interface.
Refine communication while keeping the interfaces
untouched.
Fast simulation using function calls for communication.
An example
CPU
ASIC
Abstract Bus
MEM
Arbiter
I/O
An interface is declared as a set of methods (pure virtual

functions), like APIs (Application Programming Interfaces) for
hardware and software.
An interface is an abstract base class of the channel.
A channel implements an interface.
A module calls interface methods via a port. Note that, within in
a module, accessing a channel can be done without using ports.
The port definition specifies the type of interface required by the
module in order to access the channel.
Interface
Primitive
channels
Implement one or more interfaces

Derived from sc_prim_channel
Have access to the update phase of the scheduler
Examples
sc_signal<>, sc_signal_resolved<>
sc_buffer<>
sc_fifo<>
sc_mutex, sc_semaphore
To
understand the built-in primitive

channels, we need to know their associated
events and ports altogether.
7
Primitive channel
Event
Port
sc_signal<T>
sc_buffer<T>
change in value
write()
sc_in, sc_out, sc_inout
sc_fifo<T>
write() or read()
sc_fifo_in, sc_fifo_out
sc_mutex
sc_semaphore
sc_signal vs. sc_buffer
sc_buffer is derived from sc_signal, and thus shares all the

same methods and specialized port types.
They differ in what constitutes an event. For sc_signal, an
event is a change in the value of the signal; With sc_buffer,
every call to the write() method causes an event, whether or
not the value of the sc_buffer changes.
sc_signal for modeling hardware wire or bus
(sc_signal_resolved), sc_buffer for modeling data flow where
each new input data will be sampled irrespective of if it is the
same or different from the previous sample.
Primitive channel
Event
Port
sc_signal<T>
sc_buffer<T>
change in value
write()
sc_in, sc_out, sc_inout
sc_fifo<T>
write() or read()
sc_fifo_in, sc_fifo_out
sc_mutex
sc_semaphore
sc_fifo
is a first-in-first-out buffer, widely

used in untimed functional modeling.
sc_mutex vs. sc_semaphore
Used to synchronzize accesses to shared
resources.
Sc_mutex is for a single shared resource while
sc_semaphore is more general, used for multiple
shared resources.
Modeling operating systems and software.
Template class
Interface methods
Bounded FIFO with a

default depth 16,
minimum depth 1
Infinite FIFO defined in
tlm::tlm_fifo
Nonblocking read and
write
Blocking read and
write
Specialized ports for

accessing SC_FIFO,
without using ->
operator
sc_fifo<T> fifo(fifo, 5)
bool fifo.nb_read(T&); //false if empty

bool fifo.nb_write(const T&); //false if full
void fifo.read(T&); //wait if empty
void fifo.write(const T&); //wait if full
sc_fifo_out<int> fifo_out; //for write
sc_fifo_in<int> fifo_in; //for read
sc_fifo_in<T> is equivalent to sc_port<sc_fifo_in_if<T>, 0> >

10
SC_MODULE (Producer) {
sc_fifo_out<int> fifo_out;
.
fifo_out.write(data);
.
};
Top
SC_MODULE (Consumer) {
sc_fifo_in<int> fifo_in;
.
fifo_in.read(data);
Specialized port
.
};
. operator
sc_fifo
Producer
Consumer
SC_MODULE (Top) {
Producer p;
Consumer c;
sc_fifo<int> fifo;
SC_CTOR(Top): p(p), c(c), fifo(fifo,5){
p.fifo_out(fifo);
c.fifo_in(fifo);
.
};
Step1:
11
Declare an abstract interface class
derived from sc_interface

Virtual inheritance to allow multiple inheritance
Pure virtual functions because it is mandatory for
users to supply the implementation
Example: Queue
class queue_write_if : virtual public sc_interface {
public: virtual void write (int c) = 0;};
class queue_read_if : virtual public sc_interface {
public: virtual int read () = 0;};
class queue_if : public queue_write_if, public queue_read_if { };
12
Declare the queue class as

our own channel
#include queue_if.h
The interface class is

declared but does nothing.
It is the channels
responsibility to override
the pure virtual methods
and describe functionality.
Derived from sc_object.
Since the queue channel is

neither a hierarchical nor a
primitive channel, it is
recommended that such
channels are at least derived
from sc_object so that they
own attributes such as a
hierarchical name and a
position in the module
hierarchy.
sc_object is the base class for
all objects in the module
hierarchy.
class Queue : public queue_if, public sc_object {

public:
Queue(char *_nm, int _size): sc_object(_nm),
size(_size) {
data = new int[size];
w=r=n=0;
}
private:
int* data;
int size, w, r, n;
};
13
Class sc_object is
the base class for
all objects in the
module hierarchy.
sc_module
+kind
get_child_objects
w: write pointer
r: read pointer
n: number of data
in the queue
void write(int c);

int read();
sc_object
+name
+kind
get_child_objects
get_parent_objects
sc_prim_channel
+kind
sc_port_base
sc_process*
+kind
+kind
+get_child_objects
14
Define interface methods
With the same interface

declaration, definitions
may be different.
#include queue_if.h
void Queue :: write(int c) {
if (n < size) {
n++;
data[w++] = c;
if (w == size) w = 0;
}
};
int Queue::read(){
int c = 0;
if (n > 0) {
n--;
c = data[r++];
if (r == size) r = 0;
}
return c;
}
15
We
write a module to
test the functionality
of the channel.
use port-less channel

access, i.e. access the
channel without
declaring ports.
Port-less channel access
class Test : public sc_module {

public:
Queue queue;
SC_CTOR(Test): queue(queue, 10){
SC_THREAD(testing);
}
void testing(){
for(int i=0; i<10; i++)
queue.write(i);
for(int i=0; i<10; i++)
std::cout << queue.read();
}
};
16
Class sc_port, a class template with three parameters, is

the base class for all ports in SystemC.
Interface type
The max. number of channels to which the port may be bound
(0 means no limit, default is 1).
Port binding policy (optional) with respect to unbounded ports.
sc_port<my_interface, N, policy> if1, if2, ;
Port definitions can use the class sc_port directly or use a

port specialization, which is a class dervied from sc_port,
for example, sc_in, sc_fifo_in.
template <class T>

class sc_in : public sc_port<sc_signal_in_if<T>, 1> { };
template<class T>
class sc_fifo_in : public sc_port<sc_fifo_in_if<T>, 0> { };
17
Channel: interface + implementation

Module uses ports to access the channel interface
Required interface: sif
Module
Offered interface: sif
Process
channel
sc_port<sif> port;
port->method();
Inherit sc_module if
hierarchical channel
struct channel: sif, sc_object {

void method() { }
};
struct sif: virtual sc_interface {

virtual void method() = 0;};
The port is declared with interface sif, so a process may call the method method()
through the port.
Note that the port is typed using the name of the interface, not the channel. Thus, any
channel that implements the interface sif may be bound to the port.
18
Define interface-typed ports

Define a process to call an interface method
Through the typed port out, call the write() method offered by
a queue_write_if. Which channel (queue) to use is decided by
the Port-to-Channel binding.
queue_write_if queue_read_if
Top
Producer
Consumer
queue
SC_MODULE(Producer){
public:
sc_port<queue_write_if> out;
void write_chan();
void Producer :: write_chan(){

for(int i=0; i<10; i++)
out -> write(i);
}
SC_CTOR(Producer){
SC_THREAD(write_chan); }
};
Interface method call (IMC)

Overloaded operator ->
19
The syntax for binding sc_port instances to channels is the

same as we would use for one of the standard signal ports,
like binding sc_in, sc_out ports to sc_signals.
queue_write_if queue_read_if
Top
Producer
Consumer
out
queue
SC_MODULE(Top){
Queue queue;
Producer producer;
Consumer consumer;
SC_CTROR(Top):queue(queue, 5){
producer.out(queue);
consumer.in(queue);
}
in
Channel instance
Module instance
Port to channel binding
};
20
Besides
functional methods, one can add

debug facilities to an interface.
For example, add a dump() method that writes

out the content of the queue at a time instance.
class queue_debug_if : virtual public sc_interface {

public:
virtual void dump const() = 0;
};
class Queue : public queue_if, public queue_debug_if, public sc_object {
public:
void write(int c);
int read();
void dump() const;
};
21
Different
from primitive channels,

hierarchical channels are modules which may
have ports and sub-modules.
Used to model complex communication, such
as network on chip.
The distinction between module and channel
becomes fuzzy because of hierarchial
channels, but any channel must have well
defined interfaces.
22
Define the channel interface

Implement the channel
Port creation: Create ports (interface-typed) at
the user module
1.
2.
3.
eg. sc_port<queue_write_if> out;

The user module uses the interface method call
eg. out->write(i);
Port-to-Channel binding: Bind ports of the user

module to the channel instance
4.
Example: A stack channel
Define a write and a read interface, using

nonblocking method.
23
Define
a write and a read interface, using

nonblocking method.
#ifndef STACK_IF_H
#define STACK_IF_H
#include <systemc>
class stack_write_if : virtual public sc_interface {
public:
virtual bool nb_write(char) = 0; //write a character
virtual void reset()=0;
//empty the stack
};
class stack_read_if : virtual public sc_interface {
public:
virtual bool nb_read(char&) = 0; //read a character
};
#endif
24
The
stack channel implements the methods.
#ifndef STACK.H
#define STACK.H
#include <systemc>
#include stack.h
class stack : pubic sc_module, public stack_read_if, stack_write_if {
private:
char data[100];
int top; //top of the stack
public:
stack(sc_module_nm nm) : sc_module(nm), top(0){ }
bool nb_write(char c) {
if (top<100) { data[top++] = c; return true;}
return false; }
void reset(){ top = 0;}
bool nb_read(char& c){
if (top > 0) { c = data[--top]; return true;}
return false;}
};
#endif
25
To use the stack, it must be instantiated. We use

again a producer and a consumer.
#ifndef PRODUCER.H
#define PRODUCER.H
#include <systemc>
#include stack_if.h
class producer : pubic sc_module {
public:
sc_port<stack_write_if> out; //declare a port that interfaces to the stack
sc_in<bool> clock;
void write_stack(){
int i=0; char* TestString=Hello world;
while true {
wait(); //wait for clock edge
if (out->nb_write(TestString[i]) //write to the stack via the port calling nb_write() method
cout << Write stack << TestString[i] << at << sc_time_stamp() <<endl;
i=(i+1)%32;}}
SC_CTOR(producer){
SC_THREAD(write_stack);
sensitive << clock.pos(); }
#endif
26
#include systemc.h
#include producer.h
#include consumer.h
#include stack.h
int sc_main(int argc, char* argv[]){
sc_clock ClkFast(ClkFast, 100, SC_NS);
sc_clock ClkSlow(ClkSlow, 50, SC_NS);
stack Stack1(Stack 1);
producer P1(Producer 1);
P1.out(Stack1);
P1.clock(ClkFast);
consumer C1(Consumer 1);
C1.in(Stack1);
C1.clock(ClkSlow);
sc_start(5000, SC_NS);
return 0;
}
Processes
27
communicate with channels
Channels inside the module: directly calling the

channel methods (port-less access)
Channels outside the module: indirectly calling
via port(s) of the module
Create Interface-typed port

Use interface method call
28
SystemC concepts in C++
Interfaces
Channels
Class implementation of interfaces
Ports
Abstract class
Template class sc_port<IF>

Specialized ports: sc_in<>, sc_out<>, sc_fifo_in<>, sc_fifo_out<>
Channels
Primitive channels: sc_signal, sc_fifo, sc_buffer.

Hierarchical channels are essentially modules but with interfaces
We can follow well-defined steps to build own channels with
appropriate interfaces.
Homework:
Try the example of creating own channel Queue.
29
TLM
whitepaper Transaction Level Modeling

in SystemC by Rose, Swan et al.
Download TLM-1.0 package for TLM
examples.
30
www.systemc.org,
www.accelera.org
www.doulos.com
SystemC:
From the Ground Up by D. C. Black,

J. Donovan, B. Bunton, and A. Keist.
System Design with SystemC by T. Grtker, S.
Liao, G. Martin, and S. Swan
Others
31

Channels and Interfaces in SystemC

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Channels and Interfaces in SystemC

Încărcat de

Drepturi de autor:

Formate disponibile

Dr.

KTH IL2452 System Design Languages

Understand communication concepts in SystemC

Primitive channels and interfaces

KTH IL2452 System Design Languages

In SystemC, channels model communication enabling

KTH IL2452 System Design Languages

An interface is declared as a set of methods (pure virtual

KTH IL2452 System Design Languages

Implement one or more interfaces

understand the built-in primitive

KTH IL2452 System Design Languages

sc_in, sc_out, sc_inout

sc_signal vs. sc_buffer

sc_buffer is derived from sc_signal, and thus shares all the

sc_in, sc_out, sc_inout

is a first-in-first-out buffer, widely

KTH IL2452 System Design Languages

Bounded FIFO with a

Specialized ports for

bool fifo.nb_read(T&); //false if empty

sc_fifo_in<T> is equivalent to sc_port<sc_fifo_in_if<T>, 0> >

Declare an abstract interface class

derived from sc_interface

Declare the queue class as

The interface class is

Since the queue channel is

class Queue : public queue_if, public sc_object {

KTH IL2452 System Design Languages

void write(int c);

KTH IL2452 System Design Languages

Define interface methods

With the same interface

KTH IL2452 System Design Languages

use port-less channel

Port-less channel access

KTH IL2452 System Design Languages

class Test : public sc_module {

Class sc_port, a class template with three parameters, is

Port definitions can use the class sc_port directly or use a

template <class T>

KTH IL2452 System Design Languages

Channel: interface + implementation

Offered interface: sif

struct channel: sif, sc_object {

struct sif: virtual sc_interface {

Define interface-typed ports

void Producer :: write_chan(){

Interface method call (IMC)

KTH IL2452 System Design Languages

The syntax for binding sc_port instances to channels is the

Port to channel binding

functional methods, one can add

For example, add a dump() method that writes

class queue_debug_if : virtual public sc_interface {

from primitive channels,

KTH IL2452 System Design Languages

Define the channel interface

eg. sc_port<queue_write_if> out;

Port-to-Channel binding: Bind ports of the user

Example: A stack channel

Define a write and a read interface, using

a write and a read interface, using

stack channel implements the methods.