L'architecture qui rend le silicium capable de penser en signal

Hardware — Von Neumann vs Harvard

Un processeur a besoin de deux choses pour exécuter une instruction : le code de l'instruction lui-même (qui est en mémoire programme), et les données sur lesquelles cette instruction opère (qui sont en mémoire données). La question architecturale fondamentale est : ces deux mémoires partagent-elles le même bus, ou ont-elles chacune leur autoroute ? La réponse sépare le monde en deux familles.

CISC vs RISC — la philosophie du jeu d'instructions

Une autre division architecturale, orthogonale à Von Neumann/Harvard, concerne la nature des instructions que le processeur sait exécuter. Faut-il un grand vocabulaire (mots complexes, expressifs, mais lents à articuler) ou un petit vocabulaire (mots simples qu'on enchaîne à grande vitesse) ?

Anatomie du CPU — UAL + UC + Registres

Le CPU se décompose en trois sous-unités reliées par des bus internes. Chacune a un rôle précis dans le cycle Fetch → Decode → Execute que tout processeur, du Z80 au C6713, répète des milliards de fois par seconde.

Le cycle Fetch–Decode–Execute en pratique

Considère cette séquence d'instructions, typique d'un programme assembleur :

LOAD  R1, 0x100   ; charger en R1 la valeur stockée à l'adresse 0x100
ADD   R1, R2      ; R1 ← R1 + R2
STORE R1, 0x100   ; écrire R1 à l'adresse 0x100

Pour LOAD R1, 0x100, le CPU :

1. Fetch — l'UC va chercher l'instruction en mémoire programme, à l'adresse pointée par le compteur programme (PC).
2. Decode — l'UC analyse les bits : opcode = LOAD, opérande source = adresse 0x100, opérande destination = R1.
3. Execute — l'UC envoie un signal lecture sur le bus de contrôle, l'adresse 0x100 sur le bus d'adresses ; la mémoire renvoie la donnée sur le bus de données ; l'UC l'écrit dans R1.

Les types de registres

Mémoires & Bus internes

La cache, ou comment cacher la lenteur de la RAM

La RAM principale est lente par rapport au CPU (typiquement 100× plus lente). La parade : intercaler une mémoire petite mais ultra-rapide près du CPU, qui garde une copie des données et instructions récemment utilisées. C'est la cache.

• L1 : la plus petite, la plus rapide, intégrée au CPU.
• L2 : plus grande, légèrement plus lente. Sur le C6713, on aura L1P (programme) + L1D (données) + L2 (mixte).

Les trois bus

Un bus, c'est juste un faisceau de pistes électriques partagé. Il y en a trois :

• Bus d'adresses — unidirectionnel (CPU → mémoire). « Je veux lire/écrire à cette adresse. »
• Bus de données — bidirectionnel. Transporte la donnée elle-même.
• Bus de contrôle — transporte les signaux read/write, interruptions, synchronisation.

Lecture d'une donnée en mémoire : (1) adresse sur le bus d'adresses, (2) signal « read » sur le bus de contrôle, (3) la mémoire pose la donnée sur le bus de données.

Classification des mémoires non-volatiles

Architecture logicielle — du C au binaire

Un programme est une séquence d'instructions ; une instruction est une opération élémentaire. Chaque µp a son propre jeu d'instructions, encodées en binaire (le langage machine), illisibles pour un humain.

Pour rendre cela écrivable, on utilise des couches d'abstraction :

Une instruction binaire se découpe en deux parties :

• Code opération (opcode) — ce que le µp doit faire (ADD, MOV, etc.).
• Code opérande — sur quoi il doit le faire (les registres, les valeurs, les adresses).

Instruction simple vs complexe

Modes d'adressage — comment l'opérande est désigné

L'indirect est crucial : c'est ce qui permet aux pointeurs et aux boucles. Sans lui, impossible de parcourir un tableau.

Le pipeline — exécuter plusieurs instructions à la fois

L'idée est volée à l'industrie automobile : une chaîne de montage où chaque poste fait une tâche pendant que les autres font les leurs. Au lieu d'exécuter Fetch → Decode → Execute séquentiellement pour chaque instruction, on dédie un étage à chaque phase et on les fait tourner en parallèle.

Pourquoi le parallélisme — SISD, SIMD, MIMD, VLIW

Un processeur classique exécute une instruction sur une donnée à la fois (SISD). Pour aller plus vite sans monter en fréquence — ce qui coûte cher en chaleur et en énergie — il faut faire plusieurs choses à la fois. Plusieurs stratégies existent :

VLIW — la clé du C6x

L'architecture VLIW est la spécificité du TMS320C6x. Au lieu de demander au CPU de découvrir dynamiquement quelles instructions peuvent s'exécuter en parallèle (ce que font les CPUs « superscalaires » comme x86), VLIW délègue ce travail au compilateur. Le compilateur regroupe lui-même les instructions parallélisables en un mot long, et le matériel les distribue mécaniquement.

Exemple d'un mot d'instruction VLIW : ADD R1,R2,R3 | MUL R4,R5,R6 | LOAD R7,[R8] — trois opérations indépendantes, exécutées en un seul cycle par trois unités fonctionnelles différentes.

Familles TI & l'architecture VelociTI

Texas Instruments commercialise plusieurs familles de DSP, classées par arithmétique (virgule fixe / flottante) et largeur de registres :

Tous les C6x partagent la même architecture de base baptisée VelociTI, dérivée du VLIW classique mais modifiée pour autoriser plusieurs paquets d'exécution dans un seul paquet de lecture — souplesse qu'on détaille en §4.6.

Figure 4 — L'architecture VelociTI du C6000 : deux chemins de données symétriques, chacun avec 4 unités fonctionnelles.

Deux chemins de données symétriques

Le CPU se divise en deux moitiés (DP1 et DP2), chacune contenant :

• 16 registres 32 bits (A0–A15 pour DP1, B0–B15 pour DP2).
• 4 unités fonctionnelles spécialisées :
  • .L — ALU (arithmétique & logique)
  • .S — Décalages, branchements, manipulation de bits, ALU
  • .M — Multiplication
  • .D — Load/Store : mouvement de données mémoire ↔ registres

Soit 8 unités fonctionnelles au total (L1, S1, M1, D1, L2, S2, M2, D2). Le CPU peut donc lancer jusqu'à 8 instructions en parallèle par cycle.

TMS320C6713 — anatomie complète

Le C6713 est le membre virgule flottante de la famille C67x. C'est lui qu'on programme typiquement dans les TPs.

Figure 5 — Block diagram interne du C6713 : CPU au centre, cache L1/L2 à droite, périphériques série/parallèle/temporels à gauche.

Spécifications clés

Hiérarchie mémoire & cartographie

Cache à deux niveaux

• L1P — 4 KB, cache programme de niveau 1.
• L1D — 4 KB, cache données de niveau 1, set-associative à 2 voies.
• L2 — 256 KB, partagé programme + données, organisé en :
  • 64 KB de cache (divisé en 4 blocs de 16 KB)
  • 192 KB de SRAM

La répartition L2 cache/SRAM est configurable via le registre L2CFG. C'est rare et puissant : tu peux dédier plus de SRAM si tu veux contrôler manuellement le placement, ou plus de cache si tu fais confiance au hardware.

Figure 6 — La memory map du C6713 (datasheet TI). Quatre régions principales.

Espace adressable — 4 GB

Le bus d'adresses fait 32 bits, donc 2³² = 4 GB théoriques. Cartographiés ainsi :

Les unités fonctionnelles L, S, M, D

Chaque chemin de données contient quatre spécialistes. Voici leur fiche de poste précise :

Fetch Packet (FP) & Execute Packet (EP)

VelociTI raffine le VLIW. Avant lui, un mot VLIW était aussi un paquet d'exécution. C'était rigide : si tu ne pouvais pas paralléliser 8 instructions, tu gaspillais des slots avec des NOP.

VelociTI dissocie deux notions :

• Fetch Packet (FP) — l'unité de lecture mémoire. Toujours 8 instructions de 32 bits = 256 bits.
• Execute Packet (EP) — un sous-ensemble d'instructions du FP qui s'exécutent réellement en parallèle.

Un FP contient au minimum 1 EP (8 instr en parallèle → cas idéal) et au maximum 8 EP (8 instructions séquentielles, comme si pas de parallélisme).

Le bit P — le marqueur de fin de paquet

Comment le hardware sait-il qu'un EP se termine ? Le LSB de chaque instruction (le bit P, noté ||) le dit :

• bit P = 1 → l'instruction suivante fait partie du même EP (parallèle).
• bit P = 0 → l'instruction suivante démarre un nouvel EP (séquentiel).

La dernière instruction d'un FP a toujours bit P = 0 (un EP ne peut pas déborder sur le FP suivant).

Figure 7 — Un FP de 8 instructions contenant 2 EP : EP1 (ADD, ADD, …) puis EP2 (STW, STW, ADDK, NOP). Les flèches indiquent vers quelle unité chaque instruction est dispatchée.

Le pipeline C6x — Fetch (4), Decode (2), Execute (1 à 10)

On revient au pipeline, mais cette fois à l'échelle du C6x. Au lieu des 3 étages génériques F/D/E, chaque étage est décomposé en sous-phases, pour maximiser le débit.

Étage Fetch — 4 phases

Étage Decode — 2 phases

Étage Execute — 1 à 10 phases

L'exécution se déroule en une phase E1 pour la plupart des instructions en virgule fixe (latence = 1 cycle). Mais certaines opérations sont plus lentes et bloquent leur unité pendant plusieurs phases :

Le nombre total de phases peut donc atteindre 6 en virgule fixe (E1…E6) et 10 en virgule flottante (E1…E10).

Figure 8 — Au cycle 7, six FP sont simultanément dans le pipeline : E1, DC, DP, PR, PW, PS, PG. C'est ça, « l'effet pipeline ».

Registres & chemins croisés (1X, 2X, T1, T2)

32 registres généraux

Deux files de 16 registres 32 bits chacune : A0–A15 pour le chemin A, B0–B15 pour le chemin B. Chaque registre peut servir indifféremment :

• De donnée — ADD .L1 A1, A2, A3 → A3 = A1 + A2
• De pointeur d'adresse — LDW .D1 *A4++, A5 → charge ce que pointe A4 dans A5, puis incrémente A4
• De condition — [B0] B label → branche à label si B0 ≠ 0

Largeurs supportées

Un registre peut traiter des données de plusieurs tailles :

• 16 bits (SHORT) — paquet d'octets
• 32 bits (INT ou SP — simple précision flottante)
• 40 bits (LONG) — usage interne, paires de registres
• 64 bits (Double LONG ou DP — double précision flottante)

Pour 40 ou 64 bits, on utilise une paire de registres : LSB dans un registre d'index pair, MSB dans l'index impair suivant. Combinaisons valides : A1:A0, A3:A2, A5:A4… et B1:B0, B3:B2, B5:B4… etc.

Usages spéciaux

• A0, A1 et B0, B1, B2 — peuvent être utilisés comme registres de condition pour les instructions conditionnelles. Exemple : [B1] B .S1 Loop (saute à Loop si B1 ≠ 0).
• A4–A7 et B4–B7 — utilisés pour l'adressage circulaire.

Chemins croisés 1X et 2X

Figure 9 — Les chemins croisés autorisent une unité d'un côté à lire un registre de l'autre côté.

Par défaut, les unités du chemin A ne peuvent lire que les registres A, et symétriquement pour B. Mais TI a ajouté deux ponts (cross paths) pour souplesse :

• 1X — autorise L1, S1, M1 à lire les registres B.
• 2X — autorise L2, S2, M2 à lire les registres A.

Limite : une seule lecture croisée par chemin par cycle (donc 2 instructions en parallèle utilisant les cross paths, maximum).

Exemple : MPY .M1X A5, B5, A5 — le suffixe X signale qu'on traverse le chemin croisé pour lire B5.

Chemins croisés mémoire T1 et T2

Sur le côté mémoire, il existe deux bus d'adresses : DA1 (T1) et DA2 (T2). Cela permet de charger d'un côté tout en stockant de l'autre, dans le même cycle. Exemple :

LDW .D1T1 *A0, B5      ; charge *A0 dans B5 via T1
|| STW .D2T1 A5, *B5   ; stocke A5 à l'adresse pointée par B5 via T1

Registres de contrôle — CSR, PCE1, AMR

À côté des 32 registres généraux, le C6x possède une banque de registres de contrôle qui pilotent le comportement global du processeur. Accès uniquement via l'unité .S2, avec l'instruction spécialisée MVC (Move Control).

PCE1 — Program Counter phase E1

Contient l'adresse du FP actuellement en phase E1 du pipeline. Utile pour le debug et la gestion des exceptions.

MVC .S2 PCE1, A0   ; copie l'adresse courante dans A0

CSR — Control Status Register

Registre 32 bits qui regroupe plusieurs flags critiques :

• PWRD — Power Down mode
• SAT — Saturation après opération arithmétique
• EN — Endianness (Big- ou Little-Endian)
• PCC / DCC — Program / Data Cache Control
• GIE / PGIE — Global Interrupt Enable (et son état précédent)

AMR — Addressing Mode Register

Spécifie pour chacun des registres A4–A7 et B4–B7 s'ils opèrent en mode linéaire ou circulaire, et contient la taille du tampon circulaire (BK) avec la formule : taille = 2^(N+1) octets, N étant codé sur 5 bits → tailles de 2 à 4096 octets. On peut sélectionner deux tailles différentes : BK0 et BK1.

Périphériques & système d'interruptions

Communications & interconnexions

Services système

• Timers 32 bits — mesure de durée, comptage d'événements, génération d'impulsions et d'interruptions, synchronisation du DMA. Source d'horloge interne (Fosc/4) ou externe via le pin TINP, sortie via TOUT.
• PLL Controller — synchronise les horloges des périphériques.
• Power Down — mise hors tension quand le CPU est inactif.
• Boot Configuration — choix du mode de démarrage (mémoire externe, HPI, etc.).

Le système d'interruptions

Figure 10 — 16 sources potentielles, multiplexées vers 12 vecteurs CPU. La table d'ISR commence à l'adresse ISTB ; chaque entrée fait 32 octets (8 instructions, soit un FP entier).

Une interruption force le CPU à abandonner sa tâche pour exécuter une routine appelée ISR (Interrupt Service Routine). Le C6713 propose 16 sources d'interruption : 2 timers, 4 IRQ externes, 4 du McBSP, 4 du DMA. Un sélecteur les multiplexe vers 12 entrées CPU (INT4 à INT15) — plus RESET et NMI.

Chaque interruption a une adresse de vecteur espacée de 0x20 (32 octets, soit un FP) à partir de l'ISTB (Interrupt Service Table Base). Par exemple, INT15 est à ISTB+0x1E0. On y place typiquement un B ISR15 + 5 NOP (à cause du délai de branch), puis la vraie routine se trouve à ISR15.

Flot de compilation

Trois portes d'entrée vers le binaire :

• .c — code C, compilé puis assemblé. Productif, portable, mais le compilateur peut laisser des slots inutilisés.
• .asm — assembleur natif. Contrôle total, mais tu gères toi-même les latences et les unités.
• .sa — linear assembly. Style assembleur mais sans devoir choisir les unités et les latences ; un optimiseur s'en occupe. Souvent le meilleur compromis.

Toutes ces sources convergent vers un fichier exécutable .out.

Modes d'adressage du C6713

Deux familles sur l'architecture C6713 :

Adressage indirect / linéaire

Disponible sur tous les registres. Quatre variantes selon comment le pointeur est mis à jour :

Adressage circulaire — le killer feature DSP

Disponible seulement sur A4–A7 (via .D1) et B4–B7 (via .D2). Le hardware traite le pointeur modulo une taille de buffer : dès qu'il atteint la fin, il revient automatiquement au début. Zéro test logiciel.

Le format des instructions assembleur

Une ligne d'assembleur C6x suit cette structure (jusqu'à 7 champs) :

Label: || [condition] Instruction .Unit Operands ; commentaire

Note : l'assembleur C6x n'est pas case-sensitive. ADD ≡ add ≡ Add.

Exemples d'instructions usuelles

Arithmétique

ADD .L1 A1, A2, A3      ; A3 = A1 + A2
SUB .L2 B1, B2, B3      ; B3 = B1 − B2
MPY .M1 A4, A5, A6      ; A6 = A4 × A5 (16×16 bits)

Load / Store

   LDH .D2 *B2++, B7        ; B7 ← mem[B2] (16 bits), B2 ← B2+2
|| LDH .D1 *A2++, A7        ; en parallèle : A7 ← mem[A2], A2++
   STW .D1 A3, *A7           ; mem[A7] ← A3 (32 bits)
   LDW *++A4(20), A1        ; pré-incr de 20 mots (80 bytes), charge A1

LDH charge un half-word (16 bits). LDW charge un mot complet (32 bits) — il occupe simultanément les deux chemins D1 et D2.

Branchement & Move

MV  .L1  A1, A2             ; A2 ← A1 (copie)
MVK .S1  42, A1             ; A1 ← 42 (16 bits bas)
MVKH .S1 0, A1              ; charge les 16 bits hauts (ici 0)
[B1] B .S1 Loop                ; saute à Loop si B1 ≠ 0

Notes : une constante 32 bits ne peut pas être chargée d'un coup ; on utilise MVK (16 bits bas) suivi de MVKH (16 bits hauts).

Exemple complet — programme de produit scalaire

On veut calculer somme = Σ c[i] × x[i] pour i = 0…9, avec deux vecteurs entiers signés. Voici le squelette :

; --- Section données ---
        .data
result: .word 0                    ; mot 32 bits initialisé à 0

; --- Section code ---
        .text
        .global main
main:
        MVK  .S1 42, A1            ; A1 = 42 (LSB)
        MVKH .S1 0,  A1            ; A1 = 0x0000_002A
        MVK  .S2 58, A2
        MVKH .S2 0,  A2            ; A2 = 58

        ADD  .L1 A1, A2, A3        ; A3 = 100

        MVKL .S1 result, A4        ; adresse de 'result' (16 bits bas)
        MVKH .S1 result, A4        ; 16 bits hauts
        STW  .D1 A3, *A4           ; *result = A3

        B    .S2 $                  ; boucle infinie ($ = adresse courante)
        NOP  5                      ; 5 NOP requis après branch

Directives d'assembleur

Les directives ne sont pas des instructions du CPU — elles s'adressent à l'assembleur pour structurer le fichier source.

Sections

Symboles

Initialisation de constantes

Le compromis Linear Assembly

Le linear assembly (extension .sa) est un langage intermédiaire :

• Syntaxe proche de l'assembleur classique.
• Mais : tu utilises des noms symboliques de variables, pas les registres physiques.
• Tu ne précises ni les unités fonctionnelles, ni les NOP de latence.
• Un optimizer fait le placement et la planification.

Tu obtiens un code plus efficace qu'en C, plus rapide à écrire qu'en assembleur. Le meilleur des deux mondes quand tu n'as pas le temps d'optimiser à la main.

La plateforme DSK C6713

Le DSK (DSP Starter Kit) est une carte de développement autonome, bon marché, conçue par TI pour qu'on puisse évaluer et développer rapidement des applications C67xx. C'est la référence matérielle pour le C6713.

Composants principaux

• DSP TMS320C6713 cadencé à 225 MHz (au lieu de 300 MHz max — pour la robustesse industrielle de la carte).
• Codec stéréo AIC23 — entrée/sortie audio.
• 16 MB de DRAM synchrone (mémoire de travail).
• 512 KB de mémoire FLASH non volatile (256 KB utilisables par défaut).
• 4 LEDs et 4 commutateurs DIP accessibles par l'utilisateur — typique pour signaler l'état ou changer le mode d'exécution.
• Configuration logicielle via registres CPLD.
• Options de boot configurables.
• Connecteurs d'extension pour cartes filles.
• Émulateur JTAG embarqué avec interface USB hôte (debug intégré, plus besoin de boîtier externe).

Codec AIC23, McBSP, HPI, EDMA

AIC23 — la passerelle audio

Le codec AIC23 est ce qui permet de faire du DSP utile : il convertit l'audio analogique en numérique (CAN) et inversement (CNA). Il dialogue avec le DSP via le port série McBSP. C'est ce composant qui te donne accès à des entrées Line-in / Mic, et des sorties Line-out / Headphone.

McBSP — le canal série synchrone

Le Multichannel Buffered Serial Port :

• Full-duplex (lecture et écriture simultanées).
• Registres de données double-buffered — pendant qu'un échantillon est traité, le suivant est déjà reçu.
• Horloges et signaux d'encadrage indépendants pour TX et RX.
• Interface directe avec les codecs et autres composants A/N et N/A connectés en série.

HPI — la porte d'entrée d'un hôte

Le Host Port Interface est un port parallèle qui permet à un processeur hôte (typiquement un microcontrôleur de la carte mère, ou un PC) d'accéder directement à la mémoire du DSP. Pratique pour charger un programme sans passer par JTAG, ou échanger des données à haut débit.

EDMA — la mémoire qui se déplace toute seule

L'Enhanced Direct Memory Access transfère des blocs de données entre régions de la memory map sans intervention du CPU. Tu programmes la source, la destination, la taille — le DMA fait le travail en parallèle. Pendant ce temps, le CPU peut continuer à calculer.

Les 10 points qui résument tout

1. Harvard ≠ Von Neumann : bus séparés programme/données → 2 accès simultanés. Tous les DSP sont en Harvard (modifié).
2. RISC + VLIW : instructions courtes & uniformes, et un mot d'instruction qui pilote plusieurs unités en parallèle. C'est la combinaison gagnante du C6x.
3. C6713 = 8 unités fonctionnelles : L1, S1, M1, D1 sur le chemin A ; L2, S2, M2, D2 sur le chemin B. Chacune sa spécialité : L=ALU, S=shift/branch, M=mul, D=load/store.
4. 32 registres : A0–A15 et B0–B15, 32 bits chacun. Cross paths 1X/2X permettent à une unité de lire un registre de l'autre côté (limité à 1 traversée par chemin par cycle).
5. Mémoire : L1P 4KB + L1D 4KB + L2 256KB (mixte). Espace adressable 4 GB.
6. FP & EP : un Fetch Packet = 8 instr × 32 bits = 256 bits ; il contient 1 à 8 Execute Packets. Le bit P (LSB) marque la fin d'un EP.
7. Pipeline en 3 étages, mais décomposé : Fetch (PG, PS, PW, PR) → Decode (DP, DC) → Execute (E1…E6 fixe, E1…E10 flottant).
8. NOP obligatoires en assembleur : 1 après MPY, 4 après LDH/LDW, 5 après B.
9. Adressage circulaire sur A4–A7 et B4–B7 : parfait pour buffers de filtres RIF. Géré en hardware, taille définie par AMR.
10. Périphériques clés : EMIF (mémoire externe), DMA/EDMA (transferts autonomes), McBSP (série, audio), HPI (accès parallèle hôte), Timers, 16 sources d'interruption multiplexées vers INT4–INT15.