1 Abstract 2 Entwicklung von SystemC

1 Abstract
SystemC ist eine Systembeschreibungssprache auf Basis von C++. In ihren Anfängen war
SystemC nur eine neue Hardwarebeschreibungssprache auf RTL Niveau sowie gleichzeitig
Simulator für diese Sprache. Durch die Forderung nach neuen produktiveren Sprachen
zum Design für elektronische Systeme entwickelte sich SystemC jedoch zu einer echten
system-design language. Während Sprachen auf Register-Transfer-Level die Funktionalität einer Schaltung durch Signalüsse und logische Operatoren zwischen diesen darstellen,
ist die Abstraktion von SystemC höher. Software- wie auch Hardwarekonzepte werden
beherrscht.
Moderne Systeme, vor allem SoC und embedded Applikationen, bestehen zu groÿen
Teil sowohl aus Hardware- wie auch Softwarekomponenten. SystemC ermöglicht die
gleichzeitige Modellierung der Komponenten in der Art wie sie im realen System
letztendlich miteinander agieren würden, und dies auf hohem Abstraktionsnivau. Obwohl die Modellierung analoger oder mechanischer Komponenten nicht speziziert ist,
spricht nichts dagegen dies mittels SystemC Konstrukten oder Co-Simulationtechniken
zu vollziehen.[2]
2 Entwicklung von SystemC
Die Entwicklung und Förderung von SystemC unterliegt der Open SystemC Initiative (OSCI), einer unabgängingen gemeinnützigen Organisation der die führenden EDA
Unternehmen sowie Universitäten angehören.[6]
Als Referenz dient das IEEE1666-2005 Open SystemC Language Reference Manual
welches frei zugänglich ist.
1
1
http://standards.ieee.org/getieee/1666/download/1666-2005.pdf
1
Abbildung 1: Vergleich von HDL
3 Unterschied zu anderen HDL
Bei SystemC handelt es sich streng genommen um eine Klassenbibliothek in C++. Sowohl Hardware als auch Software werden in einer einheitlichen Sprache, C++, modelliert.
Sie erweitert die Sprache C++ mittels Makros und Funktionen um die notwendigen Mittel, um typische Eigenschaften von Hardware modellieren zu können. Dazu zählen zum
Beispiel Synchronisation, Parallelität und Interprozesskommunikation. Dieses bringt SystemC den Nachteil eines syntaktischen Overheads ein, den Hardwarebeschreibungssprachen nicht haben. Dafür ist der Entwickler deutlich freier im Ausdruck.[7] Eine Übersicht
zur möglichen Modellierung und des Abstraktionsniveau zeigt Abbildung 1. Nach Übersetzung dieses Codes erhält man ein funktionales Modell, dass das Systemverhalten beinhaltet und genau simuliert und getestet werden kann. Damit ergibt sich die Möglichkeit,
das System auf Performanz sowie Verhalten und Zusammenspiel der Komponenten zu
untersuchen [5].
Zudem unterstützt SystemC das Transaction-level modeling (TLM).
2 Das zugrunde lie-
gende Konzept ist, nur in benötigter Detailtiefe zu modellieren um schon in möglichst
frühen Entwurfsphasen ausführbare Modelle zu erhalten. Nähere Informationen sind in
[2, 3, 8].
2
ein Standard wird gerade durch die OSCI ausgearbeitet
2
Abbildung 2: Aufbau von SystemC[5, S. 5]
4 Sprachkonstrukte
Den Aufbau von SystemC zeigt Abbildung 2. Selbige Quelle liefert zudem eine schlank
gehaltene Einführung.
Zu den Sprachkonstrukten zählen:
•
Module
(SC_MODULE)
Modules sind die einzelnen Blöcke einer Design Hierarchy. Ein SystemC Model
besteht typischerweise aus mehreren Blöcken die über Ports kommunizieren.
•
Ports
Ports ermöglichen die Kommunikation von Module Interna mit anderen Modulen.
•
Prozesse
Prozesse sind nebenläuge Konstrukte. Sie dienen hauptsächlich als Berechnungselemente.
•
Channels
Channels sind die Kommunikationselemente von SystemC. Sie sind sowohl als einfache Drähte wie auch komplexe Mechanismen denk- und modellierbar.
3
SystemC – Sprachelemente II
Module:

SC_MODULE
Jedes SystemC-Modul ist von dieser Basisklasse abgeleitet und erbt dessen Methoden und
Daten.
Ports und Signale:

sc_in<Datentyp>
Eingabeport eines Moduls.

sc_out<Datentyp>
Ausgabeport eines Moduls.

sc_Signal<Datentyp>
Signale verbinden Ports und sorgen für den Datenaustausch zwischen Modulen. Man kann
ein Signal mit der Funktion read() lesen und mit write() schreiben. Der Operator „=“ wurde
so überladen, das auch eine direkte Zuweisung ohne read() oder write() möglich ist.
Konstruktoren:

SC_CTOR()
Standardkonstruktor für ein SystemC-Modul

SC_HAS_PROCESS
Notwendig, wenn man einen individuellen Konstruktor für ein Modul definieren möchte,
welches SC_METHOD oder SC_THREAD Prozesse enthält
Prozesse:

SC_METHOD
Prozess wird als Methode des Moduls definiert. Methoden werden durch Ereignisse, also
die Änderung eines Signals, aktiviert. Methoden können mehrfach ausgeführt werden.

sensitive
Damit lassen sich Sensivity Lists erstellen, die die Signale enthalten, auf deren Änderung
eine Methode reagieren soll.

dont_initialize()
Verhindert das automatische Aufrufen einer Methode beim Start der Simulation.

SC_THREAD
Ist ein Prozess eines Moduls als SC_THREAD definiert, wird er zu Beginn der Simulation
gestartet. Er läuft also nur einmal während jeder Simulation und wird daher oft mit einer
Endlosschleife implementiert. Threads können mit der Funktion wait() angehalten werden.
Simulation und Hauptprogramm

sc_main()
Hauptroutine eines SystemC-Programms.

sc_start()
Startet die Simulation.

sc_stop()
Stoppt die Simulation.
3a
Kombinatorik
Halbaddierer
An diesem Beispiel soll die grundlegende Struktur der SystemC Elemente dargestellt
werden. Dabei handelt es sich um einen Halbaddierer mit dem dargestellten Schema. Er
besteht aus einem Modul, welches die Eingangsports a und b sowie die Ausgangsports
sum und carry besitzt. Die Funktionalität ist modulintern durch ein XOR und ein AND
Gatter realisiert.
a
b
=1
sum
&
carry
Das Codebeispiel zu dem beschriebenen Halbaddierer:
Halfadder.h
Headerdatei
mit
der
Modulbeschreibung
#include
"systemc.h"
// I n k l u d i e r e n der SystemC B i b l i o t h e k
SC_MODULE
( halfadder ){
// D e k l a r a t i o n e i n e s SystemC Moduls durch SC_MODULE
s c _ i n <b o o l > a ,
b;
// I n p u t p o r t s
s c _ o u t<b o o l > sum ,
carry ;
// O u t p u t p o r t s
void
prc_halfadder ( ) ;
// D e k l a r a t i o n d e s P r o z e s s e s p r c _ h a l f a d d e r
SC_CTOR
( halfadder ){
// i d e n t i s c h e r Name wie SC_MODULE
// D e k l a r a t i o n e i n e s P r o z e s s e s f ü r d i e
4
// V e r h a l t e n s b e s c h r e i b u n g
SC_METHOD( p r c _ h a l f a d d e r ) ;
// u n u n t e r b r e c h b a r e r P r o z e s s
sensitive
<<
a << b ;
// S e n s i t i v i t ä t s l i s t e ( Änderung von a oder b
// f ü h r t z u r Ausführung d e s P r o z e s s e s )
}
};
Halfadder.cpp
// D a t e i mit der D e f i n i t i o n d e s P r o z e s s e s
#include
void
" halfadder .h"
halfadder : : prc_halfadder (){
sum =
a
^
b;
// Berechnung der Ausgabewerte
carry
=
a
& b;
// Zuweisung e r f o l g t nach einem $\ Delta$ −Delay
}
5
Mathematische Funktion
Ihre Aufgabe ist die Implementierung der im Blockschaltbild dargestellten mathematischen Funktion(result
= (a + c) ∗ (b − c))
in SystemC.
Als Hilfestellung zur Umsetzung der verschiedenen Instanzen ist folgendes Konzept vorgegeben:
// i n f u n c . h
SC_MODULE( modulname )
// add / sub / mult
{
sc_in<
s c _ i n t <16> >
in1 ;
sc_in<
s c _ i n t <16> >
in2 ;
s c _ o u t<
void
s c _ i n t <16> >
out ;
prozessname ( ) ;
SC_CTOR( modulname )
{
SC_THREAD( p r o z e s s n a m e ) ;
sensitive
}
<<
in1
<<
in2 ;
// SC_CTOR
{
while
(
true
)
{
out . w r i t e (
in1 . read ( )
wait ( ) ;
}
}
} ; // SC_MODULE
6
−/ ∗ i n 2 . read ( ) ) ;
+/
// i n f u n c . cpp
void
modulname : : p r o z e s s n a m e ( )
while
(
true
{
)
{
port . write ( port . read ( )
operator
port . read ( ) ) ;
// P o r t s c h r e i b e n /− l e s e n ü b e r p o r t . w r i t e ( ) / p o r t . read
wait ( ) ;
}
}
7
Endlicher Zustandautomat
Zur Steuerung eines Kassettenspielers wurde folgender Moore-Automat entworfen. Dabei
läuft die Kassette bis zum jeweiligen Ende des Bandes und kehrt danach in die andere
Richtung um. Bei Betätigung der Stopptaste hält das Gerät an und speichert die Abspielrichtung, sodass beim Fortsetzen die Richtung der zuletzt gewählten entspricht.
Abbildung 3: Abspielsteuerung Kassettenspieler
Die Signale haben folgende Bedeutung:
•
x0 - linkes Bandende
•
x1 - rechtes Bandende
•
x2 - Wiedergabe
•
y0 - Bandbetrieb in linker Richtung
•
y1 - Bandbetrieb in rechter Richtung
Ihre Aufgabe ist es, zu dem Automaten eine Realisierung in SystemC zu erstellen.
8
Lösung
Mathematische Funktion
Func.h Datei
#include
<s y s t e m c . h>
∗tracefile
sc_trace_file
;
SC_MODULE( add )
{
sc_in<
s c _ i n t <16> >
in1 ;
sc_in<
s c _ i n t <16> >
in2 ;
s c _ o u t<
void
s c _ i n t <16> >
out ;
prc_add ( ) ;
SC_CTOR( add )
{
SC_THREAD( prc_add ) ;
sensitive
}
};
<<
in1
<<
in2 ;
// SC_CTOR
// SC_MODULE
SC_MODULE( s u b )
{
sc_in<
s c _ i n t <16> >
in1 ;
sc_in<
s c _ i n t <16> >
in2 ;
s c _ o u t<
void
s c _ i n t <16> >
out ;
prc_sub ( ) ;
SC_CTOR( s u b )
{
SC_THREAD( p r c _ s u b ) ;
sensitive
}
};
<<
in1
<<
// SC_CTOR
// SC_MODULE
SC_MODULE( m u l t )
{
9
in2 ;
sc_in<
s c _ i n t <16> >
in1 ;
sc_in<
s c _ i n t <16> >
in2 ;
s c _ o u t<
void
s c _ i n t <16> >
out ;
prc_mult ( ) ;
SC_CTOR( m u l t )
{
SC_THREAD( p r c _ m u l t ) ;
sensitive
}
};
<<
in1
<<
in2 ;
// SC_CTOR
// SC_MODULE
SC_MODULE( t o p l e v e l )
{
sc_in<
s c _ i n t <16> >
a;
sc_in<
s c _ i n t <16> >
b;
sc_in<
s c _ i n t <16> >
c ;
s c _ o u t<
s c _ i n t <16> >
result ;
sc_signal<
s c _ i n t <16> >
tmp1 ;
sc_signal<
s c _ i n t <16> >
tmp2 ;
// sub components
add
adder ;
sub
subtracter ;
mult
void
multiplier ;
prc_toplvl ( ) ;
SC_CTOR( t o p l e v e l )
"Adder" ) ,
" Subtracter " ) ,
m u l t i p l i e r ( " Multiplier " )
:
adder (
subtracter (
{
SC_THREAD( p r c _ t o p l v l ) ;
sensitive
<<
a << b <<
adder . in1 ( a ) ;
adder . in2 ( c ) ;
a d d e r . o u t ( tmp1 ) ;
subtracter . in1 (b ) ;
10
c ;
subtracter . in2 ( c ) ;
s u b t r a c t e r . o u t ( tmp2 ) ;
m u l t i p l i e r . i n 1 ( tmp1 ) ;
m u l t i p l i e r . i n 2 ( tmp2 ) ;
m u l t i p l i e r . out ( r e s u l t ) ;
}
};
sc_trace ( t r a c e f i l e ,
tmp1 ,
sc_trace ( t r a c e f i l e ,
tmp2 ,
// SC_CTOR
// SC_MODULE
11
"TMP1" ) ;
"TMP2" ) ;
Func.cpp Datei
// f u n c . cpp
"func.h"
#include
void
add : : prc_add ( )
{
while
(
true
)
{
out . w r i t e (
in1 . read ( )
+
in2 . read ( )
);
in1 . read ( )
−
in2 . read ( )
);
in1 . read ( )
∗
in2 . read ( )
);
wait ( ) ;
// w h i l e
// prc_add
}
}
void
sub : : prc_sub ( )
{
while
(
true
)
{
out . w r i t e (
wait ( ) ;
// w h i l e
// prc_sub
}
}
void
mult : : prc_mult ( )
while
{
(
true
)
{
out . w r i t e (
wait ( ) ;
// w h i l e
// prc_mult
}
}
void
t op l ev e l : : prc_toplvl ()
while
(
true
{
)
{
wait ( ) ;
// w h i l e
// t o p l v l
}
}
12
FSM
Fsm.h Datei
#include
"systemc.h"
SC_MODULE
( fsm )
{
s c _ i n <b o o l > x2 ,
s c _ o u t<b o o l > y1 ,
enum
state_type
x1 ,
x0 ,
reset ;
y0 ;
{ z0 ,
z1 ,
s c _ s i g n a l <s t a t e _ t y p e >
void
void
clk ,
z2 ,
z3 } ;
state ;
states ();
output ( ) ;
SC_CTOR
( fsm )
{
SC_METHOD
( states );
sensitive_pos
SC_METHOD
<<
clk ;
( output ) ;
sensitive_pos
<<
// S e q u e n t i e l l e r T e i l
state ;
}
};
13
// K o m b i n a t o r i s c h e r T e i l
Fsm.cpp Datei
#include
void
"fsm.h"
fsm : : s t a t e s ( )
if
{
( reset )
// Synchroner Reset
state
else
=
z2 ;
// A n f a n g s z u s t a n d z2 oder z3
switch
( state )
case
{
z0 :
if
( ! x2 )
else if
else if
case
break
z1 :
if
case
=
z0 ;
( x 2 && x 0 )
state
=
state
=
z1 ;
( x 2 &&
state
=
z3 ;
! x1 )
z1 ;
( x 2 && x 1 )
state
=
z0 ;
else
state
=
z2 ;
break
state
=
z0 ;
state
=
z3 ;
state
=
z1 ;
break
z3 :
state
z2 ;
! x0 )
( ! x2 )
else if
z2 :
=
;
else if
case
state
( x 2 &&
if
if
;
( ! x2 )
;
( ! x2 )
else
break
}
}
14
;
void
fsm : : o u t p u t ( )
switch
{
( state )
case
case
case
case
{
z0 :
y0
=
1;
break
y1
=
0;
y0
=
0;
y1
=
break
1;
y0
=
0;
break
y1
=
0;
y0
=
0;
y1
=
0;
;
z1 :
;
z2 :
;
z3 :
break
;
}
}
15
Literatur
[1] David C. Black and Jack Donovan. SystemC: From The Ground Up. Kluwer Academic
Publishers, Boston, 2004.
[2] David C. Black and Jack Donovan. SystemC: From the Ground Up. Springer-Verlag
New York, Inc., Secaucus, NJ, USA, 2005.
[3] Frank Ghenassia. Transaction-Level Modeling with Systemc: Tlm Concepts and App-
lications for Embedded Systems. Springer-Verlag New York, Inc., Secaucus, NJ, USA,
2006.
[4] Thorsten Grötker, Stan Liao, Grant Martin, and Stuart Swan. System Design with
SystemC. Kluwer Academic Publishers, Dordrecht, 2002.
[5] Martin Hirsch. Das Entwurfssystem SystemC. Hauptseminar, Fachgebiet Rechnerarchitektur, TU Ilmenau, 2004.
[6] The Open SystemC Initiative. The Open SystemC Initiative Website.http://www.systemc.org/
[7] Wikipedia, the free encyclopedia. SystemC.
[8] Wikipedia, the free encyclopedia. Transaction level modeling.
[9] Heinz-Dietrich Wuttke and Karsten Henke. Schaltsysteme. Pearson Studium, München, 2003.
16