UE SYSTEMC – Cours 5 SystemC + Logiciel embarqué [email protected]...

UE SYSTEMC – Cours 5

SystemC + Logiciel embarqué

[email protected]

[email protected]

mailto:[email protected]



Cheminement des paquets (1)

initiateur0

cible0

InterconnectVGMN

VirtualGenericMicro

Network(Latence variable)

initiateur1

Initiateur émetUne requêteCMDVAL=1@, etc


initiateur0

cible0Interconnect

initiateur1

L’interconnect litL’adresse, et détermineLe composant VCI cible


initiateur0

cible0Interconnect

initiateur1

La cible reçoit le paquetCommande, fait sonTravail et génère un paquetRéponse (SRCID)


initiateur0

cible0Interconnect

initiateur1Le paquet réponseTransite par l’interconnect


initiateur0

cible0Interconnect

initiateur1

…et revient versL’initiateur

Table des segments

reset 0xBFC00000 = 1011 1111 1100 0000 0000 0000 0000 0000

text 0x00400000 = 0000 0000 0100 0000 0000 0000 0000 0000

excep 0x80000000 = 1000 0000 0000 0000 0000 0000 0000 0000

data 0x10000000 = 0001 0000 0000 0000 0000 0000 0000 0000

timer 0xB0200000 = 1011 0000 0010 0000 0000 0000 0000 0000

tty 0xC0200000 = 1100 0000 0010 0000 0000 0000 0000 0000

mask 0x00300000 = 0000 0000 0011 0000 0000 0000 0000 0000

8 bitsfor targetdecoding

2 bitsfor cacheability

0 = reset0xBF

1 = timer0xB0

2 = tty0xC0

0 = excep0x80

0 = data0x10

0 = text0x00

0xFF

Platform address space =Mapping table

U

C

C

C

C

U

Même approche pour les réponses (SRCID)

soclib_vci_iss.h• https://www-asim.lip6.fr/trac/sesi-systemc/attachment/wiki/cours3/

REQ_IFETCH RSP_IFETCH

CMDACK=1

CMDACK=0

RSPVAL=1

RSPVAL=0

DECODE&

EXEC

REQ_LOADRSP_LOAD

CMDACK=0

CMDACK=1

RSPVAL=0

RSPVAL=1

Code de l’ISS MIPScase ISS_DECODE_AND_EXECUTE :{

int opcod=(IR>>26)&0x3F;int rs,rt,rd,func,imm;

switch (opcod){

case OP_ADDI:rs=(IR>>21)&0x1F;rt=(IR>>16)&0x1F;imm=(IR&0xFFFF);if (imm & 0x8000)

imm |= 0xFFFF0000;GPR[rt]=GPR[rs] + imm;PC=PC+4;ISS_FSM=ISS_REQ_IFETCH;break;

case OP_ORI:rs=(IR>>21)&0x1F;rt=(IR>>16)&0x1F;imm=(IR&0xFFFF);if (imm & 0x8000)

imm |= 0xFFFF0000;GPR[rt]=GPR[rs] | imm;PC=PC+4;ISS_FSM=ISS_REQ_IFETCH;break;

Processeur scalaire simple : ISS MIPS32

MIPS32 (0)

RAMInterconnect

MIPS32 (1)

Schéma extrêmement peu efficace

@I, @D

I, D

PerformanceLe temps passé à attendre une réponse de la mémoire (attente mémoire) a un impact fondamental sur le temps d'exécution d'un programme:

Temps d'exécution = (# cycles d'exécution + # cycles d'attente mémoire) Temps de cycle

La pénalité d'accès est le temps (nombre des cycles) nécessaire pour transférer une donnée de la mémoire au processeur.

Cycles d'attente mémoire = # accès Pénalité d'accès = # instructions # accès par instruction Pénalité d'accès

Le cache est un moyen de réduire la pénalité d'accès.

lslwww.epfl.ch/~tempesti/UNIL/Semaine09.ppt

Cache mémoire

MIPS32

RAMInterconnect

MIPS32

Antémémoire, près du processeur, accessible en 1 cycle d’horloge

@LI, @LD

LI, LD

CacheMIPS32(0)

CacheMIPS32(1)

@I, @D

I, D

Localité des référencesObservation: les références aux données et surtout aux instructions ne sont pas, d'habitude, indépendantes. Les programmes ont tendance à réutiliser les données et les instructions qu'ils ont utilisées récemment.

• Localité spatiale: les éléments dont les adresses sont proches les unes des autres auront tendance à être référencés dans un temps rapproché (p.ex. instructions, images).

• Localité temporelle: les éléments auxquels on a eu accès récemment seront probablement accédés dans un futur proche (p.ex. boucles).


QuestionsÀ cause de la localité spatiale, les données et les instructions sont transférées de la mémoire principale au cache en petits blocs de 2-8 mots mémoire. Plusieurs questions s'imposent:

•Où peut-on placer un bloc dans le cache?Placement de bloc

•Comment trouver un bloc s'il est présent dans le cache? Identification de bloc

•Quel bloc doit être remplacé en cas d'échec? Remplacement de bloc

•Qu'arrive-t-il lors d'une écriture? Stratégie d'écriture


Placement de bloc - Stratégie ISi chaque bloc a uniquement une seule place possible dans le cache, celui-ci est appelé à correspondance directe (direct-mapped). La correspondance est généralement la suivante:

numéro de bloc mod nombre de blocs dans le cache

Cette stratégie de placement est la plus simple à mettre en œuvre, mais aussi la moins performante.

0000000000111111111122222222223301234567890123456789012345678901

01234567

MÉMOIRE PRINCIPALECACHE À

CORRESPONDANCE DIRECTE

BLOC 12 12 mod 8 = 4


Structure d’un cache

courses.cs.tamu.edu/cpsc321/walker/lectures/lec12.ppt

PROCESSEURDonnées entrantes ÉtiquetteDéplacement

Identification de blocUn répertoire est associé à chaque cache associatif. Le répertoire contient le numéro (adresse) de chaque bloc dans le cache, appelé étiquette. Toute les étiquettes dans le répertoire sont examinées en parallèle.Pour un cache totalement associatif, chaque adresse contient donc une étiquette et un déplacement dans le bloc.

RÉPERTOIRE MÉMOIRE CACHE


Stratégie d'écriture (1)La stratégie d'écriture est fondamentale pour la performance du cache de données (environ 25% des accès à ce cache sont des écritures). Deux stratégies sont couramment employées:

Étiquette


DéplacementPROCESSEUR

Données sortantesDonnées entrantes

MÉMOIREPRINCIPALE

• L'écriture simultanée ou rangement simultané (write-through) consiste à écrire simultanément dans le bloc de cache et dans la mémoire principale.


Stratégie d'écriture (2)La recherche de données en mémoire principale lors d'un échec de lecture dans le cache est prioritaire par rapport à l'écriture. Cette dernière peut donc être suspendue en utilisant un tampon d'écriture (write buffer).Cependant, les tampons d'écriture compliquent les choses car ils peuvent contenir des valeurs modifiées d'un bloc qui fait l'objet d'un échec en lecture.

TAMPOND'ÉCRITURE

Étiquette


DéplacementPROCESSEUR

Données sortantesDonnées entrantes

MÉMOIREPRINCIPALE

Bit modifié


Cache mémoire

MIPS32

RAMInterconnect

MIPS32

Antémémoire, près du processeur, accessible en 1 cycle d’horlogeLes périphériques ne sont pas cachés!

@LI, @LD

LI, LD

CacheMIPS32(0)

CacheMIPS32(1)

@I, @D

I, D

Exemple de plateforme compliquée

2.4 GHz communication channel

MIPS

Cache ICU Timer Serdes

Interconnect

TXRX

RAMSeismicsensor

I2CCtrl

Seismic perturbation generator

MIPS


Interconnect

TXRX

RAMSeismicsensor

I2CCtrlNode 0 Node 3

…

Digital, BCA, SocLib

Analog, SystemC-AMS TDF, Physics, ΣΔ

Analog, SystemC-AMS ELN, Electrical, Bus

Analog, SystemC-AMS TDF, RF

Embedded software

SOFT SOFT

N3N2

N0 N1

(xe,ye)

Plateforme simplifiée

MIPS


Interconnect

RAM

MIPS


Interconnect

RAMNode 0 Node 1

…

SOFT SOFT

ICU : Interrupt Controller UnitSERDES/UART : Serialiseur, Déserialiseur

TTY TTY

Les périphériques sont accessibles à des adresses mémoire qui correspondentà des registres. Pour le logiciel, agir sur un périphérique consiste à faire un LW ou un SW sur le registre correspondant.

ISS APIvoid reset()

resets the ISS.

void getInstructionRequest(uint32_t &address)returns the next initiator PC address

void getDataRequest(uint32_t &type, uint32_t &address, uint32_t &wdata)returns the next initiator Data type, address and wdata

void setInstruction(bool error, uint32_t val)assigns the ISS IR register with cache instruction

void setRdata(bool error, uint32_t rdata)assigns the ISS data register with cache read word

void setIrq(uint32_t irq)assigns the ISS irq register with pending interrupt lines

void step()executes one ISS step

MEM_NONE MEM_LB MEM_LBU MEM_LH MEM_LHU MEM_LW MEM_SB MEM_SH MEM_SW MEM_INVAL

getInstructionRequest

setInstruction

getDataRequest

setRdata

Xcacheinstruction

Xcachedata

getInstructionRequest

setInstruction

getDataRequest

setRdata

Xcacheinstruction

Xcachedata

stepstep

r_pc

r_npc

r_mem

r_gp

ISS MIPS32

• soclib/soclib/iss

• Avec une API

VciICUThis VCI target is a memory mapped peripheral implementing vectorized interrupt

controller. It can concentrate up to 32 independent interrupt lines p_irq_in[i] to a single p_irq interrupt line.

The active state is high, and the output interrupt is the logical OR of all input interrupts. Each input interrupt can be individually masked through a programmable register.

This component can be addressed to return the index of the highest priority active interrupt p_irq_[i]. The priority scheme is fixed : The lower indexes have the highest priority.

This hardware component checks for segmentation violation, and can be used as a default target.

This component contains 5 memory mapped registers: ICU_INT Each bit in this register reflects the state of the corresponding interrupt line. This is

read-only. ICU_MASK Each bit in this register reflects the state of the enable for the corresponding

interrupt line. This is read-only. ICU_MASK_SET Each bit set in the written word will be set in the ICU MASK. (ICU_MASK =

ICU_MASK | written_data). This is write-only. ICU_MASK_CLEAR Each bit set in the written word will be reset in the ICU MASK.

(ICU_MASK = ICU_MASK & ~written_data). This is write-only. ICU_IT_VECTOR This register gives the number of the highest-priority active interrupt. If no

interrupt is active, (-1) is returned. This is read-only.

Exemple de code#include "soclib/icu.h"

static const volatile void* icu_address = 0xD0200000;

static icu_test(){ // Getting / setting interrupt mask uint32_t current_interrupt_mask = soclib_io_get(

icu_address, ICU_MASK );

// Enabling IRQ #5 soclib_io_set( icu_address, ICU_MASK_SET, 1<<5 ); // Disabling IRQ #0 soclib_io_set( icu_address, ICU_MASK_CLEAR, 1<<0 );

// When interrupt is raised, you may do: int irq_to_serve = soclib_io_get( icu_address, ICU_IT_VECTOR ); // This should be equivalent to (see man 3 ffs) int irq_to_serve = ffs( soclib_io_get( icu_address, ICU_IT_VECTOR ) & soclib_io_get( icu_address, ICU_MASK ) );}

VciTimerThis VCI target is a memory mapped peripheral that can control up to 256 software

controlled timers. Each timer can optionally generate an independent periodic interrupt. The memory segment allocated to this component must be aligned on 4K bytes boundary.

Each timer contains 4 memory mapped registers: TIMER_VALUE This 32 bits register is unconditionally incremented at each cycle. A read request returns

the current time contained in this register. A write request sets a new value in this register.

TIMER_MODE This register contains two flags: Bit 0: TIMER_RUNNING. When 1, the associated timer will decrease on each cycle Bit 1: TIMER_IRQ_ENABLED: When 1, the associated IRQ line will be activated if the

timer underflows. TIMER_PERIOD This 32 bits register defines the period between two successive interrupts. It may be read

or written to. When written to, the new period is immediatly taken into account. TIMER_RESETIRQ Any write request in this Boolean register will reset the pending IRQ. A read request

returns the zero value when there is no pending interrupt, and returns a non zero value if there is a pending interrupt.

Exemple de code#include "soclib/timer.h"

static const volatile void* timer_address = 0xc0000000;

static timer_test(const size_t timer_no){ // Getting / setting timer current value soclib_io_set( timer_address,

TIMER_SPAN*timer_no + TIMER_VALUE, 0x2a00 ); uint32_t foo = soclib_io_get(

timer_address, TIMER_SPAN*timer_no + TIMER_VALUE );

// Enabling timer and interrupt soclib_io_set( timer_address, TIMER_SPAN*timer_no + TIMER_MODE,

TIMER_RUNNING | TIMER_IRQ_ENABLED );

// Getting IRQ status, and resetting IRQ if ( soclib_io_get( timer_address, TIMER_SPAN*timer_no +

TIMER_RESETIRQ ) ) soclib_io_set( timer_address, TIMER_SPAN*timer_no +

TIMER_RESETIRQ, 0 );}

SERDES/UART

B0 B1 B31 PARSTOP

BR (en nb de cycles)

BR/2

TX

UART_DATAUART_BRUART_CTRL

…

SERDES/UART, FSM émetteur

B0 B1 B31 PARSTOP

UA

RT

_TX

_ID

LE

TX

UA

RT

_TX

_ST

AR

T

UA

RT

_TX

_BIT

UA

RT

_TX

_PA

RIT

Y

UA

RT

_TX

_ST

OP

…

SERDES/UART, FSM Récepteur

B0 B1 B31 PARSTOP

BR

TX

UA

RT

_RX

_ID

LE

UA

RT

_RX

_ST

AR

T

UA

RT

_RX

_BIT

UA

RT

_RX

_WA

ITF

OR

NE

XT

BIT

UA

RT

_RX

_PA

RIT

YU

AR

T_R

X_W

AIT

FO

RS

TO

PB

IT

UA

RT

_RX

_ST

OP

UA

RT

_RX

_WA

ITF

OR

EN

D

On attendLe front montant

…

Etude de la plateforme matérielle

VciMultiTty 1

VciIcu 4

VciVgmn

VciXCacheWrapper

VciRam

timerBASE=0xD0200000SIZE=0x00000100

U

ttyBASE=0xC0200000SIZE=0x00000040

UresetBASE=0xBFC00000SIZE=0x00010000

C

excepBASE=0x80000000SIZE=0x00010000

C

textBASE=0x00400000SIZE=0x00050000

C

dataBASE=0x10000000SIZE=0x00020000

C

0

0 VciTimer 3 VciUart 2

RXTX

timerBASE=0xB1200000SIZE=0x00000040

UuartBASE=0xB0200000SIZE=0x00000040

U

irq0irq1

typedef soclib::caba::VciParams<4,6,32,1,1,1,8,1,1,1> vci_param;

cell_size = 4 * 8 = 32 bits

plen_size = 64 words

addr_size = 32 bits

rerror_size = 1 bit

clen_size = 1 bit

rflag_size = 1 bit

srcid_size = 8 bits

pktid_size = 1 bit

trdid_size = 1 bit

wrplen_size = 1 bit

VciTimer

timerBASE=0xB0200000SIZE=0x00000100

U

VciVgmn

soclib::caba::VciSignals<vci_param> signal_vci_vcitimer("signal_vci_vcitimer");

Etude du logiciel embarqué

• Programme principal– Configuration des périphériques– Boucle infinie

• ISR (Interrupt Service Routine)– Si IRQ UART, lire et afficher caractère– Si IRQ Timer, compter et acquitter interruption

Building the embedded application

*.c MIPS32 *.s

mipsel-soclib-elf-unknown-gcc

*.o ldscript

bin.soft(elf format)

mipsel-soclib-elf-unknown-as

mipsel-soclib-elf-unknown-ld

Sectionreset (0xBFC00000)

Sectionexcep (0x80000000)

Sectiontext (0x00400000)

Sectiondata (0x10000000)

Application binarycomposed of sections

Building the embedded application

*.c MIPS32 *.smipsel-soclib-elf-unknown-gcc -S

*.c *.omipsel-soclib-elf-unknown-gcc -c

*.s *.omipsel-soclib-elf-unknown-as

*.o exec ELFmipsel-soclib-elf-unknown-ld

ldscript

GCC

AS

LD

Structure d’un ldscriptSECTIONS{ . = 0x80000000; .excep : {

*(.excep)*(.excep.*)

}

. = 0xbfc00000; .reset : {

*(.reset)*(.reset.*)

}

. = 0x00400000; .text : { *(.text) }...

On crée dans le fichier ELFUne section .excep

Qui va contenir toutes lesSections .excep des fichiers .o

Le code C standard généréPar Gcc est mis dans uneSection .text. On assembleEnsemble ces sections .textEt on en crée une nouvelle, commune

UE SYSTEMC – Cours 5 SystemC + Logiciel embarqué [email protected]...

Documents

Transcript of UE SYSTEMC – Cours 5 SystemC + Logiciel embarqué [email protected]...