4/4
🔌 Hardware
Arhitectura Sistemelor de Calcul
Curs de Arhitectura Sistemelor de Calcul¶
Comunicarea dintre componente, sisteme embedded (ARM) și calculatoare moderne (x86)¶
Cuprins¶
- Introducere — structura generală a unui sistem de calcul
- Procesorul (CPU) — perspectivă arhitecturală
- Sistemul de memorie
- Magistrale și protocoale de interconectare
- Subsistemul de intrare/ieșire (I/O)
- Chipset-ul și topologia modernă
- Secvența de boot și inițializare
- Sistemul de întreruperi — perspectivă de sistem
- Accesul direct la memorie (DMA)
- Memoria virtuală și unitatea MMU
- Sistemul de ceas, alimentare și reset
- Arhitectura sistemelor embedded (ARM SoC)
- Arhitectura calculatoarelor moderne (x86/x64)
- Comunicația inter-procesor și sisteme multi-core
- Interfețe externe și standarde de comunicație
- Studii de caz comparative
1. Introducere — structura generală a unui sistem de calcul¶
1.1 Modelul abstract¶
Orice sistem de calcul, de la un microcontroler de 8 biți la un server multi-socket, urmează același model fundamental: un procesor execută instrucțiuni, citind și scriind date într-o memorie, comunicând cu lumea exterioară prin periferice. Toate aceste componente sunt interconectate prin magistrale (busuri).
┌─────────────────────────────────────────────────────────────┐
│ SISTEM DE CALCUL │
│ │
│ ┌─────────┐ ┌──────────┐ ┌──────────────────────┐ │
│ │ │ │ │ │ Periferice │ │
│ │ CPU │◄──►│ Memorie │ │ ┌──────┐ ┌───────┐ │ │
│ │ │ │ (RAM, │ │ │ UART │ │ GPIO │ │ │
│ │ │ │ ROM) │ │ └──────┘ └───────┘ │ │
│ └────┬────┘ └────┬─────┘ │ ┌──────┐ ┌───────┐ │ │
│ │ │ │ │ SPI │ │ Timer │ │ │
│ │ │ │ └──────┘ └───────┘ │ │
│ ▼ ▼ │ ┌──────┐ ┌───────┐ │ │
│ ┌─────────────────────────┐ │ │ I²C │ │ ADC │ │ │
│ │ Magistrală de sistem │◄──►│ └──────┘ └───────┘ │ │
│ │ (System Bus / Fabric) │ └──────────────────────┘ │
│ └─────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
1.2 Componentele fundamentale¶
| Componentă | Rol | Exemple |
|---|---|---|
| CPU | Execuție instrucțiuni, control | ARM Cortex-M4, Intel Core i7 |
| Memorie | Stocare program și date | SRAM, DRAM, Flash, ROM |
| Magistrală | Interconectare, transport date/adrese/control | AHB, AXI, PCIe, FSB |
| I/O Controller | Interfațare cu perifericele | UART, SPI, USB, Ethernet controller |
| Ceas (Clock) | Sincronizare globală | Oscilator cu cuarț, PLL |
| Alimentare | Furnizare tensiuni | LDO, SMPS, PMIC |
| Reset | Inițializare la pornire sau eroare | Power-on reset, watchdog |
1.3 Diferențe structurale: embedded vs. desktop¶
| Aspect | Sistem embedded (MCU/SoC ARM) | Calculator modern (x86/x64) |
|---|---|---|
| Integrare | Totul pe un chip (SoC) | CPU + chipset + module separate |
| Memorie | SRAM/Flash on-chip (KB–MB) | DRAM externă (GB), SSD/HDD (TB) |
| Magistrale | AHB/APB/AXI on-chip | PCIe, DDR, DMI, USB |
| Sistem de operare | Bare-metal sau RTOS | OS complex (Linux, Windows) |
| Boot | Direct din Flash internă | BIOS/UEFI → Bootloader → OS |
| Consum | mW – W | 15W – 300W |
| Cost | $0.50 – $20 | $100 – $1000+ |
| Timp real | Deterministm garantat | Best-effort (fără RTOS) |
2. Procesorul (CPU) — perspectivă arhitecturală¶
2.1 Microarhitectura vs. ISA¶
ISA (Instruction Set Architecture) este contractul software-hardware — definește instrucțiunile, registrele, modurile de adresare și modelul de memorie. Programatorul scrie cod conform ISA-ului.
Microarhitectura este implementarea fizică a ISA-ului — pipeline-ul, cache-urile, unitățile de execuție, predictorul de branch. Două procesoare pot implementa aceeași ISA cu microarhitecturi complet diferite.
ISA x86-64 (aceeași):
├── Intel Skylake (microarhitectură A)
├── Intel Alder Lake (microarhitectură B, hetero P+E cores)
├── AMD Zen 4 (microarhitectură C)
└── AMD Zen 5 (microarhitectură D)
ISA ARMv8-A (aceeași):
├── Cortex-A53 (in-order, eficient energetic)
├── Cortex-A78 (out-of-order, performanță)
├── Apple Firestorm (OoO agresiv, lățime mare)
└── Qualcomm Oryon (OoO custom)
2.2 Procesor embedded tipic — ARM Cortex-M4¶
┌──────────────────────────────────────────────────┐
│ ARM Cortex-M4 Core │
│ │
│ ┌───────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ Pipeline │ │ Registre │ │ NVIC │ │
│ │ 3 etaje │ │ R0-R15 │ │ Controller │ │
│ │ (IF/ID/EX) │ │ CPSR,MSP │ │ întreruperi │ │
│ └───────────┘ │ PSP │ └──────────────┘ │
│ └──────────┘ │
│ ┌───────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ ALU │ │ MPU │ │ FPU │ │
│ │ + Barrel │ │ Memory │ │ (opțional) │ │
│ │ Shifter │ │ Protect │ │ single-prec. │ │
│ └───────────┘ └──────────┘ └──────────────┘ │
│ │
│ ┌────────────────────────────────────────────┐ │
│ │ Bus Matrix (AHB-Lite master ports) │ │
│ │ I-Code | D-Code | System │ │
│ └────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────┘
Caracteristici: pipeline scurt (3 etaje), execuție deterministă (fără OoO), latența întreruperilor garantată (12 cicluri), MPU pentru protecția memoriei (fără MMU/memorie virtuală).
2.3 Procesor desktop tipic — nucleu x86 modern¶
┌────────────────────────────────────────────────────────┐
│ Nucleu x86-64 (ex. Zen 4) │
│ │
│ ┌──────────┐ ┌──────────────┐ ┌─────────────────┐ │
│ │ L1 I$ │ │ Branch │ │ Instruction │ │
│ │ 32KB │ │ Predictor │ │ Fetch & Decode │ │
│ │ 8-way │ │ TAGE + BTB │ │ 4-wide decode │ │
│ └──────────┘ └──────────────┘ │ x86 → μops │ │
│ └─────────────────┘ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ Out-of-Order Engine │ │
│ │ Rename → Dispatch → Schedule → Execute → Retire │ │
│ │ ROB: 320 entries, RS: 120+ entries │ │
│ └──────────────────────────────────────────────────┘ │
│ │
│ ┌─────────┐ ┌─────────┐ ┌────────┐ ┌──────────────┐ │
│ │ ALU ×4 │ │ AGU ×3 │ │ FPU ×2 │ │ SIMD/AVX │ │
│ │ (Int) │ │ (Addr) │ │(Float) │ │ 256-bit ×2 │ │
│ └─────────┘ └─────────┘ └────────┘ └──────────────┘ │
│ │
│ ┌──────────┐ ┌───────────────────────────────────┐ │
│ │ L1 D$ │ │ L2 Cache 1 MB, 8-way │ │
│ │ 32KB │ │ (privat per nucleu) │ │
│ │ 8-way │ └───────────────────────────────────┘ │
│ └──────────┘ │
└────────────────────────────────────────────────────────┘
Caracteristici: pipeline lung (19+ etaje), execuție out-of-order pe 6+ unități, decodificare x86 → micro-operații RISC, cache-uri multi-nivel, predictor de branch sofisticat, SIMD (SSE, AVX).
3. Sistemul de memorie¶
3.1 Clasificarea memoriilor într-un sistem de calcul¶
┌─────────────────┐
│ Registre CPU │ ← cele mai rapide
├─────────────────┤
│ Cache L1 I+D │ 32-64 KB
├─────────────────┤
│ Cache L2 │ 256KB-1MB/nucleu
├─────────────────┤
│ Cache L3 (LLC) │ 4-64 MB partajat
├─────────────────┤
│ RAM principală │ SRAM (emb.) / DRAM (desktop)
├─────────────────┤
│ Stocare │ Flash (emb.) / SSD-HDD (desktop)
└─────────────────┘ ← cele mai lente, cele mai mari
3.2 Memoria în sisteme embedded¶
Flash internă (program):
Stochează codul firmware-ului. Accesibilă direct de CPU prin magistrala I-Code. Tipic 64 KB – 2 MB. Caracteristici: nevolatilă, citire rapidă (0–2 wait states la 72 MHz), scriere lentă (ms per pagină), durabilitate limitată (10⁴–10⁵ cicluri).
SRAM internă (date):
Memorie de lucru (variabile, stivă, heap). Tipic 16 KB – 512 KB. Acces rapid fără wait states. Volatilă (se pierde la oprirea alimentării).
Harta memoriei tipică STM32F4:
0x0000 0000 ┌───────────────────┐
│ Alias (Boot-dep.) │ Mapare configurabilă
0x0800 0000 ├───────────────────┤
│ Flash (1 MB) │ Program (cod + constante)
0x0810 0000 ├───────────────────┤
│ ... │
0x1FFF 0000 ├───────────────────┤
│ System Memory │ ROM bootloader ST
0x2000 0000 ├───────────────────┤
│ SRAM (192 KB) │ Date, stivă, heap
0x2003 0000 ├───────────────────┤
│ ... │
0x4000 0000 ├───────────────────┤
│ Periferice APB1 │ UART, SPI, I²C, Timer
0x4001 0000 ├───────────────────┤
│ Periferice APB2 │ ADC, USART1, SPI1
0x4002 0000 ├───────────────────┤
│ Periferice AHB1 │ GPIO, DMA, CRC
0x4002 4000 ├───────────────────┤
│ Periferice AHB2 │ USB OTG, Camera
0x5000 0000 ├───────────────────┤
│ Periferice AHB3 │ FSMC (memorie externă)
0xE000 0000 ├───────────────────┤
│ Cortex-M internals│ NVIC, SysTick, SCB, MPU, FPU
0xE010 0000 ├───────────────────┤
│ ... │
0xFFFF FFFF └───────────────────┘
3.3 Memoria în calculatoare moderne¶
Ierarhia completă x86:
Registre (< 1 ns)
│
▼
L1 I-Cache 32KB + L1 D-Cache 32KB (1-2 ns, per nucleu)
│
▼
L2 Cache 256KB-1MB (3-10 ns, per nucleu)
│
▼
L3 Cache (LLC) 4-64MB (10-30 ns, partajat între nuclee)
│
▼
Controler de memorie DDR (integrat în CPU)
│ ┌──────────────────────┐
└───────────────────►│ DRAM DDR5 │
50-100 ns │ 2-4 canale × 16GB │
│ 4800-7200 MT/s │
└──────────────────────┘
Controlerul de memorie DDR:
Integrat direct în die-ul CPU-ului (de la Intel Nehalem / AMD K8). Gestionează:
- Refresh-ul DRAM (periodic, la fiecare 64 ms)
- Scheduling-ul comenzilor (activare rând, citire/scriere coloană, precharge)
- Timing-urile (CAS Latency, tRCD, tRP, tRAS)
- Interleaving pe canale, ranguri și bank-uri pentru maximizarea throughput-ului
Exemplu timing DDR5-5600 CL36:
CAS Latency (CL): 36 cicluri
tRCD: 36 cicluri (Row-to-Column Delay)
tRP: 36 cicluri (Row Precharge)
tRAS: 76 cicluri (Row Active Time)
Latența reală ≈ CL / frecvență = 36 / 2800MHz ≈ 12.86 ns
3.4 Accesarea memoriei — perspectivă de programator¶
Embedded (bare-metal, memory-mapped I/O):
@ ARM Cortex-M: totul este accesat prin adrese de memorie
@ Citire registru periferic = LDR de la adresa perifericului
.equ GPIOA_ODR, 0x40020014 @ Adresa registrului Output Data
LDR R0, =GPIOA_ODR @ Încarcă adresa
LDR R1, [R0] @ Citește valoarea curentă
ORR R1, R1, #(1 << 5) @ Setează bitul 5
STR R1, [R0] @ Scrie înapoi
Desktop (memorie virtuală, pagini):
; x86-64: accesul la memorie trece prin MMU
; Adresele din program sunt VIRTUALE, traduse în fizice de hardware
mov rax, [rdi] ; citire memorie virtuală
; Intern:
; 1. CPU generează adresă virtuală
; 2. TLB caută traducerea (virtual → fizic)
; 3. Dacă TLB miss → page table walk (4 niveluri pe x86-64)
; 4. Dacă Page Fault → OS alocă pagina
; 5. Accesul continuă cu adresa fizică → verificare cache
4. Magistrale și protocoale de interconectare¶
4.1 Concepte fundamentale¶
O magistrală (bus) este un canal de comunicație partajat sau dedicat care transportă date între componente. Parametri cheie:
- Lățime (width): câți biți se transferă simultan (8, 16, 32, 64, 128, 256 biți)
- Frecvență (clock): viteza de operare în Hz
- Throughput (bandwidth): lățime × frecvență × transferuri/ciclu
- Latență: timpul de la inițierea transferului până la primirea datelor
- Protocol: regulile de comunicare (handshake, arbitrare, adresare)
- Topologie: bus partajat, punct-la-punct, crossbar, ring, mesh
4.2 Tipuri de transfer pe magistrală¶
Citire (Read):
Master ──► Adresă + Control(RD) ──► Slave
Master ◄── Date ◄────────────────── Slave
Scriere (Write):
Master ──► Adresă + Date + Control(WR) ──► Slave
Master ◄── Confirmare (opțional) ◄──────── Slave
Burst Transfer (multiple date la adrese consecutive):
Master ──► Adresă start + Lungime + Control ──► Slave
Master ◄── Dată₁ ◄── Dată₂ ◄── Dată₃ ◄── ... ── Slave
Split Transaction:
Master ──► Cerere (adresă) ──► Slave
(magistrala e liberă pentru alte transferuri)
Master ◄── Răspuns (date) ◄── Slave (când e gata)
4.3 Magistrale în sisteme embedded ARM — AMBA¶
ARM a definit familia de protocoale AMBA (Advanced Microcontroller Bus Architecture), care este standardul universal pentru SoC-uri:
Evoluție AMBA:
AMBA 1 (1996): ASB
AMBA 2 (1999): AHB (Advanced High-performance Bus)
AMBA 3 (2003): AHB-Lite, APB v2, AXI (Advanced eXtensible Interface)
AMBA 4 (2010): AXI4, AXI4-Lite, AXI4-Stream, ACE (coherent)
AMBA 5 (2013): CHI (Coherent Hub Interface)
Structura tipică bus SoC ARM (STM32):
┌──────────┐
│ Cortex-M │
│ Core │
└──┬───┬───┘
I-Code │ │ D-Code/System
bus │ │ bus
┌──▼───▼───┐
│ Bus │
│ Matrix │
│ (AHB) │
└──┬───┬───┘
│ │
┌─────────────┤ ├─────────────┐
▼ ▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌───────────────┐
│ Flash │ │ SRAM │ │ AHB Periph. │
│ Memory │ │ │ │ (DMA, GPIO, │
│ Interface│ │ │ │ USB, Ethernet)│
└──────────┘ └──────────┘ └───────────────┘
│
┌─────┴──────┐
│ AHB→APB │
│ Bridge │
└─────┬──────┘
│
┌─────────────┼─────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ APB1 │ │ APB2 │ │ APB1 │
│ UART2-5 │ │ USART1 │ │ Timers │
│ SPI2-3 │ │ SPI1 │ │ TIM2-7 │
│ I²C1-3 │ │ ADC1-3 │ │ DAC │
│ CAN1-2 │ │ TIM1,8 │ │ PWR, BKP │
└──────────┘ └──────────┘ └──────────┘
AHB (Advanced High-performance Bus):
Magistrala principală de mare viteză. Conectează CPU, memorie, DMA, periferice rapide (USB, Ethernet, GPIO).
Caracteristici:
- Sincronă (un singur ceas)
- Pipeline: adresă într-un ciclu, date în următorul
- Burst transfers (INCR, WRAP de 4, 8, 16 beats)
- Un singur master activ la un moment dat (arbitrare)
Semnalele principale AHB:
HCLK — ceas
HRESETn — reset activ LOW
HADDR[31:0] — adresă
HTRANS[1:0] — tip transfer (IDLE, BUSY, NONSEQ, SEQ)
HWRITE — direcție (1=scriere, 0=citire)
HSIZE[2:0] — dimensiune transfer (byte, halfword, word)
HBURST[2:0] — tip burst
HWDATA[31:0]— date scrise (de la master)
HRDATA[31:0]— date citite (de la slave)
HREADY — slave-ul e gata (1) sau inserează wait states (0)
HRESP — răspuns slave (OK sau ERROR)
Exemplu de transfer AHB — citire word:
Ciclu 1 (Adresă): HADDR=0x40020014, HTRANS=NONSEQ, HWRITE=0, HSIZE=010
Ciclu 2 (Date): HRDATA=0x00000020, HREADY=1, HRESP=OK
APB (Advanced Peripheral Bus):
Magistrală secundară de viteză mai mică, concepută pentru periferice care nu necesită throughput mare (UART, SPI, I²C, Timere, ADC). Conectată la AHB prin un bridge.
Avantaje: consum redus, simplitate, nu necesită pipeline sau burst. Dezavantaj: acces mai lent (minim 2 cicluri per transfer).
Semnale principale APB:
PCLK — ceas (de obicei HCLK/2 sau HCLK/4)
PRESETn — reset
PADDR — adresă
PSEL — selectare slave
PENABLE — faza a doua a transferului
PWRITE — direcție
PWDATA — date scrise
PRDATA — date citite
PREADY — slave gata (extensie APB3/APB4)
AXI (Advanced eXtensible Interface):
Magistrala premium din AMBA, folosită în SoC-urile ARM de înaltă performanță (Cortex-A, FPGA).
Caracteristici superioare:
- Canale separate: Read Address, Read Data, Write Address, Write Data, Write Response — permit transfer simultan citire+scriere
- Out-of-order transactions: răspunsurile pot reveni în altă ordine decât cererile
- Multiple outstanding transfers: mai multe cereri emise fără a aștepta răspuns
- Burst de până la 256 beats
- Quality of Service (QoS): prioritizarea traficului
AXI Channels:
┌──────────────┐
Write Address ──►│ │
Write Data ──►│ Slave │
Write Response◄──│ │
Read Address ──►│ │
Read Data ◄──│ │
└──────────────┘
Fiecare canal are semnalele proprii VALID/READY (handshake):
- VALID: sursa indică date valide
- READY: destinația acceptă datele
- Transfer efectiv: când VALID=1 ȘI READY=1 simultan
4.4 Matricea de magistrală (Bus Matrix)¶
Într-un SoC cu multiple mastere (CPU, DMA1, DMA2, USB, Ethernet) și multiple slave-uri (Flash, SRAM, periferice), o matrice de magistrală (crossbar) permite transferuri simultane pe căi diferite:
Slave 0 Slave 1 Slave 2 Slave 3
(Flash) (SRAM1) (SRAM2) (Periph)
│ │ │ │
Master 0 ─────┼────────────┼───────────┼───────────┤ CPU I-Code
(CPU I) │ │ │ │
│ │ │ │
Master 1 ─────┼────────────┼───────────┼───────────┤ CPU D-Code
(CPU D) │ │ │ │
│ │ │ │
Master 2 ─────┼────────────┼───────────┼───────────┤ DMA1
(DMA1) │ │ │ │
│ │ │ │
Master 3 ─────┼────────────┼───────────┼───────────┤ DMA2
(DMA2) │ │ │ │
Transferuri simultane posibile:
- CPU I-Code citește din Flash (Master 0 → Slave 0)
- DMA1 scrie în SRAM2 (Master 2 → Slave 2)
- CPU D-Code citește SRAM1 (Master 1 → Slave 1)
Toate trei se pot întâmpla ÎN ACELAȘI CICLU DE CEAS.
Conflictele apar doar când doi masteri accesează același slave simultan — atunci intervine arbitrul (round-robin sau prioritate fixă).
4.5 Magistrale în calculatoare moderne — topologie x86¶
Arhitectura modernă x86 a abandonat bus-ul partajat (FSB) în favoarea conexiunilor punct-la-punct:
┌────────────────────────────────────────────────────────────┐
│ CPU Die │
│ │
│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │Core 0│ │Core 1│ │Core 2│ │Core 3│ ← Nuclee CPU │
│ │L1+L2 │ │L1+L2 │ │L1+L2 │ │L1+L2 │ │
│ └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘ │
│ └────────┴────────┴────────┘ │
│ │ Ring Bus / Mesh │
│ ┌────────┴────────────────────┐ │
│ │ L3 Cache (partajat) │ │
│ └────────┬────────────────────┘ │
│ │ │
│ ┌───────────┼──────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────┐ ┌──────┐ ┌──────────┐ │
│ │ IMC │ │ PCIe │ │ DMI/ │ │
│ │(DDR)│ │ Root │ │ Chipset │ │
│ │ │ │Complex│ │ Link │ │
│ └──┬──┘ └──┬───┘ └────┬────┘ │
└────┼────────┼────────────┼─────────────────────────────────┘
│ │ │
▼ ▼ ▼
┌──────┐ ┌──────┐ ┌────────────────────────────────┐
│ DRAM │ │ GPU │ │ Chipset (PCH) │
│ DDR5 │ │(PCIe │ │ ┌─────┐ ┌────┐ ┌────┐ ┌────┐ │
│ DIMM │ │ x16) │ │ │USB │ │SATA│ │NVMe│ │Net │ │
└──────┘ └──────┘ │ │3.2 │ │ │ │SSD │ │ │ │
│ └─────┘ └────┘ └────┘ └────┘ │
│ ┌─────┐ ┌────┐ ┌──────────┐ │
│ │Audio│ │WiFi│ │ PCIe x1 │ │
│ │ │ │ 6E │ │ slots │ │
│ └─────┘ └────┘ └──────────┘ │
└────────────────────────────────┘
4.6 PCIe (PCI Express) — magistrala universală modernă¶
PCIe este o conexiune serială punct-la-punct de mare viteză. A înlocuit complet busurile paralele PCI și AGP.
Structura fizică:
- Lane: o pereche diferențială TX + o pereche diferențială RX
- Link: 1, 2, 4, 8, 16 sau 32 lane-uri agregate (x1, x2, x4, x8, x16, x32)
- Generații:
| Generație | Rată per lane | Codificare | Throughput x16 |
|---|---|---|---|
| PCIe 1.0 | 2.5 GT/s | 8b/10b | 4 GB/s |
| PCIe 2.0 | 5 GT/s | 8b/10b | 8 GB/s |
| PCIe 3.0 | 8 GT/s | 128b/130b | 15.75 GB/s |
| PCIe 4.0 | 16 GT/s | 128b/130b | 31.5 GB/s |
| PCIe 5.0 | 32 GT/s | 128b/130b | 63 GB/s |
| PCIe 6.0 | 64 GT/s | 1b/1b (PAM4) | 128 GB/s |
Ierarhia PCIe:
Root Complex (în CPU)
├── PCIe x16: GPU
├── PCIe x4: NVMe SSD
├── PCIe x1: Network card
└── DMI/OPI: Chipset (PCH)
├── PCIe x4: NVMe SSD #2
├── PCIe x1: WiFi card
├── USB 3.2 controller
├── SATA controller
└── Audio (HDA)
Protocol PCIe — stiva de nivele:
┌───────────────────┐
│ Transaction Layer │ TLP (Transaction Layer Packets)
│ (cereri, răsp.) │ Memory Read/Write, I/O, Config, Messages
├───────────────────┤
│ Data Link Layer │ DLLP: CRC, secvențiere, retry
│ (integritate) │ Garantează livrarea fără erori
├───────────────────┤
│ Physical Layer │ Codificare (128b/130b), serializare
│ (semnale) │ Scrambling, egalizare, lane training
└───────────────────┘
4.7 DMI / OPI — legătura CPU–Chipset¶
DMI (Direct Media Interface) la Intel / Infinity Fabric la AMD conectează CPU-ul de chipset (PCH/FCH).
Intel DMI 4.0: echivalent PCIe 4.0 x8 (15.75 GB/s bidirecțional). Acesta este adesea un bottleneck când se accesează simultan multe periferice conectate la chipset.
4.8 Inter-CPU: QPI, UPI, Infinity Fabric¶
În sisteme multi-socket (servere), procesoarele comunică între ele:
- Intel UPI (Ultra Path Interconnect): 2-3 link-uri per CPU, 10.4-16 GT/s per lane, 20 lane-uri per link. Suportă coerența cache-ului între sockete.
- AMD Infinity Fabric: interconectare internă (între chiplet-uri CCD pe același pachet) și externă (între sockete). Frecvență legată de memoria DDR (FCLK).
5. Subsistemul de intrare/ieșire (I/O)¶
5.1 Memory-Mapped I/O vs. Port-Mapped I/O¶
Memory-Mapped I/O (ARM, MIPS, RISC-V):
Registrele perifericelor sunt mapate în spațiul de adresare al memoriei. Accesul se face cu aceleași instrucțiuni LDR/STR ca pentru memorie.
@ ARM: configurare GPIO ca ieșire
.equ RCC_AHB1ENR, 0x40023830
.equ GPIOA_MODER, 0x40020000
.equ GPIOA_BSRR, 0x40020018
@ Activare ceas GPIOA
LDR R0, =RCC_AHB1ENR
LDR R1, [R0]
ORR R1, R1, #1 @ Bit 0 = GPIOAEN
STR R1, [R0]
@ PA5 = output
LDR R0, =GPIOA_MODER
LDR R1, [R0]
BIC R1, R1, #(3 << 10)
ORR R1, R1, #(1 << 10) @ MODER5 = 01
STR R1, [R0]
@ Set PA5 HIGH (folosind registrul atomic BSRR)
LDR R0, =GPIOA_BSRR
MOV R1, #(1 << 5) @ BS5 = 1
STR R1, [R0] @ operație atomică (un singur STR)
Port-Mapped I/O (x86):
Spațiu de adresare I/O separat (64K porturi), accesat prin instrucțiuni speciale IN/OUT. Folosit pentru dispozitive legacy.
; x86: programare timer PIT 8253/8254 (legacy)
; Frecvența de intrare: 1.193182 MHz
; Dorim 1000 Hz → divisor = 1193
mov al, 00110110b ; Canal 0, mode 3, binary
out 0x43, al ; Command port
mov ax, 1193 ; Divisor
out 0x40, al ; Low byte → Channel 0 data
mov al, ah
out 0x40, al ; High byte → Channel 0 data
; x86: citire status tastatură (port 0x64)
in al, 0x64 ; Status register tastatura 8042
test al, 0x01 ; Bit 0 = Output Buffer Full
jz no_key ; Dacă nu e tastă, nu citi
in al, 0x60 ; Citire scancode
no_key:
x86 modern — totul devine Memory-Mapped:
Dispozitivele moderne PCIe folosesc BAR (Base Address Register) pentru a-și mapa registrele în spațiul de memorie. Port I/O rămâne doar pentru compatibilitate legacy. MMIO oferă acces mai rapid, suportă caching (sau uncached dacă e nevoie), și funcționează cu DMA.
5.2 Registre periferice — anatomia unui periferic¶
Un periferic tipic expune mai multe registre la adrese consecutive:
Exemplu: UART/USART (STM32)
Offset Registru Funcție
0x00 SR Status Register (TXE, RXNE, ORE, FE, PE...)
0x04 DR Data Register (date TX/RX)
0x08 BRR Baud Rate Register (divisor)
0x0C CR1 Control Register 1 (UE, TE, RE, RXNEIE, TXEIE...)
0x10 CR2 Control Register 2 (STOP bits, LIN, clock)
0x14 CR3 Control Register 3 (DMA, flow control)
0x18 GTPR Guard Time / Prescaler
Adresa completă = USART2_BASE + offset
USART2_BASE = 0x40004400 (pe APB1)
@ Exemplu: transmitere caracter 'A' pe USART2
.equ USART2_SR, 0x40004400
.equ USART2_DR, 0x40004404
tx_char:
LDR R0, =USART2_SR
.Lwait_txe:
LDR R1, [R0]
TST R1, #(1 << 7) @ Bit TXE (Transmit Empty)
BEQ .Lwait_txe @ Așteaptă până e gol
LDR R0, =USART2_DR
MOV R1, #'A'
STR R1, [R0] @ Scrie caracterul
BX LR
5.3 Accesul la registre volatile — bariere de memorie¶
CPU-urile moderne reordonează accesele la memorie pentru performanță. Pentru registrele perifericelor, ordinea trebuie păstrată strict.
@ ARM: bariere de memorie
DSB @ Data Synchronization Barrier — finalizează toate accesele anterioare
DMB @ Data Memory Barrier — ordonează accesele (fără a garanta finalizarea)
ISB @ Instruction Synchronization Barrier — flush pipeline instrucțiuni
@ Exemplu: după scrierea unui registru de control, asigurăm-ne că
@ efectul e vizibil înainte de a citi un registru de stare
STR R1, [R0] @ Scrie registru control
DSB @ Asigură finalizarea scrierii
LDR R2, [R3] @ Citire registru stare — garantat după scriere
; x86: bariere de memorie
mfence ; Full memory fence (ordonează toate load+store)
sfence ; Store fence (ordonează doar store-urile)
lfence ; Load fence (ordonează doar load-urile)
; x86 este „strongly ordered" — mai puțin nevoie de bariere
; dar SSE/string operations pot fi reordonate
6. Chipset-ul și topologia modernă¶
6.1 Ce este chipset-ul?¶
Chipset-ul (PCH — Platform Controller Hub la Intel, FCH — Fusion Controller Hub la AMD) este circuitul integrat complementar CPU-ului care gestionează perifericele „lente” și oferă conectivitate I/O diversificată.
6.2 Componente integrate în chipset-ul modern (Intel 600/700 Series)¶
┌──────────────────────────────────────────────────────┐
│ PCH (Platform Controller Hub) │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │
│ │ PCIe │ │ USB 3.2 │ │ SATA III │ │
│ │ Gen 3/4 │ │ Gen 2x2 │ │ 6 Gbps │ │
│ │ până la │ │ până la │ │ până la │ │
│ │ 28 lanes │ │ 12 porturi│ │ 8 porturi │ │
│ └──────────┘ └──────────┘ └──────────────────┘ │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │
│ │ Intel HD │ │ Intel │ │ SPI Controller │ │
│ │ Audio │ │ GbE/2.5G │ │ (pentru BIOS │ │
│ │ (HDA) │ │ Ethernet │ │ Flash chip) │ │
│ └──────────┘ └──────────┘ └──────────────────┘ │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │
│ │ SMBus / │ │ Intel ME │ │ GPIO / LPC / │ │
│ │ I²C │ │ (Manag. │ │ eSPI │ │
│ │ │ │ Engine) │ │ │ │
│ └──────────┘ └──────────┘ └──────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ DMI 4.0 (link către CPU) │ │
│ └──────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────┘
6.3 Ce s-a mutat din chipset în CPU¶
De-a lungul anilor, componente care erau în chipset au migrat în die-ul CPU:
| Componentă | Locație veche | Locație modernă |
|---|---|---|
| Controler memorie DDR | Northbridge | CPU (din 2008+) |
| PCIe Root Complex | Northbridge | CPU |
| GPU integrat | Northbridge/separat | CPU |
| Controler USB 3/4 | Chipset | CPU (parțial) |
| Thunderbolt controller | Chip separat | CPU (Intel 12th+) |
| NPU / AI accelerator | — | CPU (Intel 14th+, AMD) |
6.4 SoC ARM — tot pe un chip¶
Într-un SoC embedded sau mobil ARM, echivalentul „chipset-ului” este integrat pe același die:
┌──────────────────────────────────────────────────────┐
│ SoC ARM (ex. STM32H7, Qualcomm Snapdragon)│
│ │
│ ┌─────────────┐ ┌─────────────────────────────┐ │
│ │ CPU Cluster │ │ GPU / NPU / DSP │ │
│ │ (1-8 cores) │ │ │ │
│ └──────┬──────┘ └──────────────┬──────────────┘ │
│ │ │ │
│ ┌──────┴────────────────────────┴──────────────┐ │
│ │ Interconnect (AXI/NoC) │ │
│ └──┬──────┬──────┬──────┬──────┬──────┬────────┘ │
│ │ │ │ │ │ │ │
│ ┌──┴─┐ ┌──┴──┐ ┌─┴──┐ ┌┴───┐ ┌┴───┐ ┌┴──────┐ │
│ │SRAM│ │Flash│ │DDR │ │DMA │ │USB │ │Ethernet│ │
│ │ │ │ │ │Ctrl│ │ │ │OTG │ │ MAC │ │
│ └────┘ └─────┘ └────┘ └────┘ └────┘ └───────┘ │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────────────┐ │
│ │UART │ │SPI │ │I²C │ │CAN │ │ADC/DAC/Comp.│ │
│ │×8 │ │×6 │ │×4 │ │FD×2 │ │ │ │
│ └─────┘ └─────┘ └─────┘ └─────┘ └─────────────┘ │
│ ┌─────┐ ┌─────┐ ┌──────┐ ┌──────┐ ┌────────────┐ │
│ │Timer│ │PWM │ │WDT │ │RTC │ │Crypto/Hash │ │
│ │×16 │ │ │ │ │ │ │ │AES/SHA │ │
│ └─────┘ └─────┘ └──────┘ └──────┘ └────────────┘ │
│ ┌──────────────────────────────────────────────┐ │
│ │ Sistem ceas: HSI, HSE, PLL×3, prescalere │ │
│ │ Sistem alimentare: LDO intern, domenii putere │ │
│ └──────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────┘
7. Secvența de boot și inițializare¶
7.1 Boot-ul unui microcontroler ARM Cortex-M¶
Procesul este simplu și determinist:
1. Power-on / Reset
│
▼
2. Hardware citește din Flash la adresa 0x00000000:
- [0x00000000]: Valoarea inițială a MSP (Main Stack Pointer)
- [0x00000004]: Adresa Reset_Handler (prima instrucțiune)
│
▼
3. CPU încarcă SP ← [0x00], PC ← [0x04]
Execuție începe de la Reset_Handler
│
▼
4. Reset_Handler (startup code, scris în assembly):
a) Copiază .data din Flash în SRAM
b) Inițializează .bss cu zerouri în SRAM
c) Configurează ceasul (HSE, PLL)
d) Apelează SystemInit() (HAL/CMSIS)
e) Apelează main()
│
▼
5. main() — aplicația utilizatorului
@ Startup code tipic Cortex-M (simplificat)
.section .isr_vector, "a"
.word _estack @ SP inițial
.word Reset_Handler @ Adresa de start
.section .text
.thumb
.global Reset_Handler
Reset_Handler:
@ Copiază .data (variabile inițializate) din Flash → SRAM
LDR R0, =_sdata @ start destinație (SRAM)
LDR R1, =_edata @ end destinație
LDR R2, =_sidata @ start sursă (Flash)
.Lcopy_data:
CMP R0, R1
BGE .Lcopy_done
LDR R3, [R2], #4 @ citește din Flash, post-increment
STR R3, [R0], #4 @ scrie în SRAM, post-increment
B .Lcopy_data
.Lcopy_done:
@ Zero-izează .bss (variabile neinițializate)
LDR R0, =_sbss
LDR R1, =_ebss
MOV R2, #0
.Lzero_bss:
CMP R0, R1
BGE .Lbss_done
STR R2, [R0], #4
B .Lzero_bss
.Lbss_done:
@ Apelează funcțiile de inițializare
BL SystemInit @ Configurare ceas, Flash wait states
BL main @ Aplicația
B . @ Buclă infinită (dacă main returnează)
7.2 Boot-ul unui PC x86 modern¶
Procesul este incomparabil mai complex, cu mai multe stadii:
1. Power-on
│
▼
2. Power supply → semnalul POWER_GOOD
│
▼
3. CPU pornește în Real Mode (16-bit, adresare 1MB)
CS:IP = 0xF000:0xFFF0 (mapată la ROM SPI Flash)
│
▼
4. UEFI/BIOS SEC Phase (Security)
- Verificare integritate firmware
- Inițializare minimală CPU (cache as RAM)
│
▼
5. UEFI PEI Phase (Pre-EFI Initialization)
- Detectare și inițializare RAM (SPD, training)
- Inițializare chipset de bază
│
▼
6. UEFI DXE Phase (Driver Execution Environment)
- Încărcare drivere hardware (PCIe, USB, storage, video)
- Enumerare dispozitive PCIe
- Inițializare SATA/NVMe controllers
│
▼
7. UEFI BDS Phase (Boot Device Selection)
- Citire variabile NVRAM boot
- Selectare dispozitiv de boot (SSD, USB, Network)
│
▼
8. UEFI încarcă bootloader-ul (GRUB, Windows Boot Manager)
- Tranziție la Protected/Long Mode (64-bit)
│
▼
9. Bootloader încarcă kernelul OS
│
▼
10. OS kernel:
- Inițializare MMU, page tables
- Detectare hardware (ACPI, device tree)
- Încărcare drivere
- Pornire procese utilizator (init/systemd)
│
▼
11. Spațiu utilizator (login, GUI, aplicații)
7.3 Comparație directă boot¶
| Etapă | Cortex-M | x86 UEFI |
|---|---|---|
| Timp tipic boot | < 10 ms | 5–30 secunde |
| Prima instrucțiune | Reset_Handler din Flash | 0xFFFFFFF0 din SPI Flash |
| Inițializare RAM | Nu e nevoie (SRAM on-chip) | Complex (DDR training, 100+ ms) |
| Modul CPU inițial | Thumb-2 | Real Mode 16-bit |
| Tranziții mod | Niciuna | Real → Protected → Long Mode |
| Enumerare dispozitive | Predefinite (memory map fix) | PCIe enumeration, ACPI |
| Linker script | Definește memory layout | UEFI gestionează memoria |
8. Sistemul de întreruperi — perspectivă de sistem¶
8.1 Fluxul complet al unei întreruperi hardware¶
Dispozitiv periferic generează cerere IRQ
│
▼
Controller de întreruperi (NVIC/APIC) primește cererea
│
▼
Controller verifică prioritatea vs. prioritatea curentă
│
├── Prioritate mai mică → cerere pendinte (în așteptare)
│
└── Prioritate mai mare → preemptează:
│
▼
CPU finalizează instrucțiunea curentă
│
▼
Salvare context automat (registre pe stivă)
│
▼
Citire vector întrerupere → adresa ISR
│
▼
Execuție ISR (Interrupt Service Routine)
│
▼
ISR confirmă/curăță sursa întreruperii
│
▼
Restaurare context (de pe stivă)
│
▼
Reluare program întrerupt
8.2 NVIC — ARM Cortex-M (detaliat)¶
@ Registre NVIC (adrese fixe în System Control Space)
@ 0xE000E100: NVIC_ISER[0-7] — Interrupt Set Enable
@ 0xE000E180: NVIC_ICER[0-7] — Interrupt Clear Enable
@ 0xE000E200: NVIC_ISPR[0-7] — Interrupt Set Pending
@ 0xE000E280: NVIC_ICPR[0-7] — Interrupt Clear Pending
@ 0xE000E300: NVIC_IABR[0-7] — Interrupt Active Bit
@ 0xE000E400: NVIC_IPR[0-59] — Interrupt Priority (8 biți/întrerupere)
@ Exemplu complet: configurare USART2 receive interrupt
.equ NVIC_ISER1, 0xE000E104 @ ISER pentru IRQ 32-63
.equ NVIC_IPR_BASE, 0xE000E400
.equ USART2_IRQn, 38 @ Numărul IRQ al USART2
.equ USART2_CR1, 0x4000440C
.equ USART2_SR, 0x40004400
.equ USART2_DR, 0x40004404
configure_usart2_irq:
PUSH {R0-R3, LR}
@ 1. Setează prioritatea (ex. 2, din 0-15)
LDR R0, =NVIC_IPR_BASE
ADD R0, R0, #USART2_IRQn @ Registru prioritate pt USART2
MOV R1, #(2 << 4) @ Prioritate 2 (shiftată în biții [7:4])
STRB R1, [R0]
@ 2. Activează întreruperea în NVIC
LDR R0, =NVIC_ISER1
MOV R1, #(1 << (USART2_IRQn - 32)) @ Bit 6 în ISER1
STR R1, [R0]
@ 3. Activează întreruperea RXNE în USART2
LDR R0, =USART2_CR1
LDR R1, [R0]
ORR R1, R1, #(1 << 5) @ RXNEIE = 1 (RX Not Empty IE)
STR R1, [R0]
POP {R0-R3, PC}
@ ISR — apelat automat de hardware la recepție caracter
.global USART2_IRQHandler
.thumb_func
USART2_IRQHandler:
PUSH {R0-R2, LR}
@ Citește statusul
LDR R0, =USART2_SR
LDR R1, [R0]
TST R1, #(1 << 5) @ RXNE?
BEQ .Lusart2_exit
@ Citește data (și curăță automat RXNE)
LDR R0, =USART2_DR
LDRB R1, [R0]
@ Procesează caracterul (ex. stochează în buffer circular)
LDR R0, =rx_buffer
LDR R2, =rx_head
LDR R2, [R2]
STRB R1, [R0, R2]
ADD R2, R2, #1
AND R2, R2, #0xFF @ Mască circulară (buffer 256 bytes)
LDR R0, =rx_head
STR R2, [R0]
.Lusart2_exit:
POP {R0-R2, PC} @ Return din ISR
Salvarea contextului pe Cortex-M: hardware-ul salvează automat R0-R3, R12, LR, PC, xPSR (8 registre, 32 bytes) la intrarea în ISR și le restaurează la ieșire. Aceasta se numește stacking și durează 12 cicluri.
8.3 APIC — x86 modern¶
Sistemele x86 moderne folosesc LAPIC (Local APIC) — câte unul per nucleu, integrat în CPU — și I/O APIC — în chipset, colectează IRQ-urile de la periferice.
Periferice → I/O APIC → (mesaje pe bus intern) → LAPIC (per core)
│
▼
CPU Core
; x86: LAPIC este memory-mapped la 0xFEE00000 (implicit)
; Registre importante:
; 0xFEE00020: LAPIC ID
; 0xFEE00080: Task Priority Register (TPR)
; 0xFEE000B0: End-Of-Interrupt (EOI)
; 0xFEE000F0: Spurious Interrupt Vector
; 0xFEE00300: Interrupt Command Register (ICR) — pt. IPI
; Confirmare întrerupere (EOI):
mov dword [0xFEE000B0], 0 ; Scrie orice valoare la EOI register
8.4 MSI/MSI-X — întreruperi moderne PCIe¶
Dispozitivele PCIe nu folosesc fire IRQ fizice. În schimb, generează Message Signaled Interrupts — un simplu write la o adresă MMIO specifică care declanșează întreruperea:
Dispozitiv PCIe scrie la adresa LAPIC → întrerupere generată
Fără fire dedicate, fără partajare IRQ, fiecare vector e unic
MSI: până la 32 vectori per dispozitiv
MSI-X: până la 2048 vectori per dispozitiv
9. Accesul direct la memorie (DMA)¶
9.1 De ce DMA?¶
Fără DMA, CPU-ul trebuie să execute o buclă pentru fiecare byte transferat între periferic și memorie. Cu DMA, un controller hardware dedicat realizează transferul independent, eliberând CPU-ul.
Fără DMA: Cu DMA:
CPU: LDR R0, [UART_DR] CPU: Configurează DMA
CPU: STR R0, [buffer+0] CPU: Face altceva (calcule, sleep)
CPU: LDR R0, [UART_DR] ...
CPU: STR R0, [buffer+1] DMA: Transfer automat UART→SRAM
... ...
CPU: (ocupat 100% cu transferul) DMA: Generează întrerupere TC
CPU: Procesează bufferul complet
9.2 Arhitectura DMA pe STM32¶
┌─────────────────────────────────────────────────────┐
│ DMA Controller │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Stream 0│ │ Stream 1│ ... │ Stream 7│ │
│ │ │ │ │ │ │ │
│ │ NDTR │ │ NDTR │ │ NDTR │ Num. items │
│ │ PAR │ │ PAR │ │ PAR │ Periph Addr│
│ │ M0AR │ │ M0AR │ │ M0AR │ Memory Addr│
│ │ CR │ │ CR │ │ CR │ Control │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ ┌────┴───────────┴───────────────┴─────────────┐ │
│ │ Arbiter (prioritate) │ │
│ └──────────────────┬───────────────────────────┘ │
│ │ │
│ ┌──────────────────┴───────────────────────────┐ │
│ │ FIFO (4×32-bit per stream) │ │
│ └──────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────┘
│ │
┌────┴────┐ ┌────┴────┐
│ AHB │ │ AHB │
│ Periph │ │ Memory │
│ Port │ │ Port │
└─────────┘ └─────────┘
@ Exemplu complet: DMA transfer USART2 RX → SRAM buffer
@ STM32F4, DMA1 Stream 5, Channel 4 = USART2_RX
.equ DMA1_BASE, 0x40026000
.equ DMA1_S5CR, DMA1_BASE + 0x88 @ Stream 5 Config
.equ DMA1_S5NDTR, DMA1_BASE + 0x8C @ Nr. items
.equ DMA1_S5PAR, DMA1_BASE + 0x90 @ Peripheral address
.equ DMA1_S5M0AR, DMA1_BASE + 0x94 @ Memory address
.equ DMA1_HIFCR, DMA1_BASE + 0x0C @ Clear flags
.equ USART2_DR, 0x40004404
.equ BUFFER_SIZE, 256
.data
dma_buffer: .space BUFFER_SIZE
.text
configure_dma_usart2_rx:
PUSH {R0-R3, LR}
@ 1. Dezactivează stream-ul (obligatoriu înainte de configurare)
LDR R0, =DMA1_S5CR
MOV R1, #0
STR R1, [R0]
DSB @ Asigură finalizarea scrierii
@ 2. Curăță flag-urile
LDR R0, =DMA1_HIFCR
MOV R1, #(0x3D << 6) @ Curăță toate flag-urile Stream 5
STR R1, [R0]
@ 3. Adresa perifericului (sursă)
LDR R0, =DMA1_S5PAR
LDR R1, =USART2_DR
STR R1, [R0]
@ 4. Adresa memoriei (destinație)
LDR R0, =DMA1_S5M0AR
LDR R1, =dma_buffer
STR R1, [R0]
@ 5. Numărul de elemente
LDR R0, =DMA1_S5NDTR
MOV R1, #BUFFER_SIZE
STR R1, [R0]
@ 6. Configurare stream
@ Channel 4 (CHSEL=4), Periph→Mem, Circular,
@ Byte transfers, Memory increment, Transfer Complete IE
LDR R0, =DMA1_S5CR
LDR R1, =(4 << 25) @ CHSEL = 4
ORR R1, R1, #(0 << 6) @ DIR = 00 (Periph to Memory)
ORR R1, R1, #(1 << 8) @ CIRC = 1 (Circular mode)
ORR R1, R1, #(1 << 10) @ MINC = 1 (Memory increment)
ORR R1, R1, #(0 << 11) @ MSIZE = 00 (Byte)
ORR R1, R1, #(0 << 13) @ PSIZE = 00 (Byte)
ORR R1, R1, #(1 << 4) @ TCIE = 1 (Transfer Complete IE)
ORR R1, R1, #(1 << 0) @ EN = 1 (Enable stream)
STR R1, [R0]
POP {R0-R3, PC}
9.3 DMA pe x86 — Bus Mastering¶
Pe sistemele x86 moderne, DMA-ul clasic 8237 este obsolet. Dispozitivele PCIe sunt bus master — pot iniția transferuri direct pe magistrala PCIe fără asistența unui controller DMA extern:
NVMe SSD → PCIe → Memory Controller → DRAM
(bus mastering — dispozitivul inițiază transferul)
OS-ul alocă buffere DMA în memorie fizică și programează dispozitivul cu adresele fizice (sau IOMMU/adrese virtuale I/O).
IOMMU (VT-d la Intel, AMD-Vi):
- Traduce adresele DMA virtuale → fizice
- Izolează dispozitivele (securitate: un dispozitiv nu poate
accesa memoria altuia)
- Esențial pentru virtualizare (passthrough GPU la VM)
10. Memoria virtuală și unitatea MMU¶
10.1 Cortex-M: MPU (Memory Protection Unit)¶
Cortex-M nu are MMU (fără memorie virtuală, fără paginare), dar are un MPU care permite definirea a 8–16 regiuni de memorie cu permisiuni:
@ Configurare MPU: protejează stiva de overflow
.equ MPU_BASE, 0xE000ED90
.equ MPU_RNR, MPU_BASE + 0x08 @ Region Number
.equ MPU_RBAR, MPU_BASE + 0x0C @ Region Base Address
.equ MPU_RASR, MPU_BASE + 0x10 @ Region Attribute and Size
configure_mpu:
@ Regiunea 0: Flash (Read-Only, Executable)
MOV R1, #0
LDR R0, =MPU_RNR
STR R1, [R0] @ Selectează regiunea 0
LDR R0, =MPU_RBAR
LDR R1, =0x08000000 @ Adresa de bază Flash
STR R1, [R0]
LDR R0, =MPU_RASR
@ Size=20 (2^(20+1)=2MB), AP=110 (RO priv+user), XN=0, Enable
LDR R1, =(20 << 1) | (0x6 << 24) | (0 << 28) | 1
STR R1, [R0]
@ Regiunea 1: Periferice (Read-Write, No Execute)
MOV R1, #1
LDR R0, =MPU_RNR
STR R1, [R0]
LDR R0, =MPU_RBAR
LDR R1, =0x40000000 @ Adresa de bază periferice
STR R1, [R0]
LDR R0, =MPU_RASR
@ Size=29 (512MB), AP=011 (Full access), XN=1 (No Execute), Enable
LDR R1, =(29 << 1) | (0x3 << 24) | (1 << 28) | 1
STR R1, [R0]
@ Activare MPU
LDR R0, =MPU_BASE
MOV R1, #(1 << 0) | (1 << 2) @ ENABLE + PRIVDEFENA
STR R1, [R0]
DSB
ISB
BX LR
10.2 Cortex-A / x86: MMU completă¶
Traducere pe 4 niveluri (x86-64, 48-bit virtual):
Adresă virtuală (48 biți):
┌──────┬──────┬──────┬──────┬──────────┐
│ PML4 │ PDP │ PD │ PT │ Offset │
│ 9 b │ 9 b │ 9 b │ 9 b │ 12 b │
└──┬───┴──┬───┴──┬───┴──┬───┴──────────┘
│ │ │ │
│ │ │ └─► Page Table Entry → Cadru fizic 4KB
│ │ └────────► Page Directory Entry
│ └───────────────► Page Directory Pointer Entry
└──────────────────────► PML4 Entry
CR3 register → adresa fizică a tabelei PML4
; x86-64: structura unei intrări de pagină (PTE)
; 63 62:52 51:12 11:0
; ┌──┬───────────┬─────────────┬──────────┐
; │NX│ Disponibil│ Adresă fizică│ Flags │
; │ │ (OS use) │ (40 biți) │P,R/W,U/S │
; └──┴───────────┴─────────────┴──────────┘
;
; Bit 0: Present (pagina e în RAM)
; Bit 1: Read/Write (0=read-only, 1=read-write)
; Bit 2: User/Supervisor (0=kernel only, 1=user accessible)
; Bit 5: Accessed (hardware setează la acces)
; Bit 6: Dirty (hardware setează la scriere)
; Bit 63: NX (No Execute — prevenire execuție cod din date)
10.3 TLB (Translation Lookaside Buffer)¶
TLB-ul este un cache specializat pentru traducerile virtual → fizic. Fără TLB, fiecare acces la memorie ar necesita 4 accese suplimentare (table walk).
Acces memorie → TLB Lookup
│
┌───────┴───────┐
│ │
TLB Hit TLB Miss
(1 ciclu) │
│ Page Table Walk
│ (100+ cicluri)
│ │
└───────┬───────┘
│
▼
Acces cache/memorie cu adresa fizică
TLB-uri tipice:
- L1 ITLB: 64–128 intrări (instrucțiuni)
- L1 DTLB: 64–128 intrări (date)
- L2 TLB: 512–4096 intrări (unificat)
- Suport pentru pagini de 4KB, 2MB și 1GB (hugepages reduc presiunea pe TLB)
11. Sistemul de ceas, alimentare și reset¶
11.1 Arborele de ceas într-un SoC ARM¶
┌───────────┐
Cristal extern──►│ HSE │ 8-25 MHz
(cuarț) │ Oscillator│
└─────┬─────┘
│
┌─────▼─────┐
Oscilator RC───►│ HSI │ 16 MHz (intern, mai puțin precis)
intern │ Oscillator│
└─────┬─────┘
│
┌─────▼─────┐
│ PLL │ Multiplicator de frecvență
│ ×N /M /P │ HSE × N / M / P = ex. 168 MHz
└─────┬─────┘
│
┌────────────────┼────────────────────────┐
▼ ▼ ▼
┌───────────┐ ┌───────────┐ ┌───────────┐
│ SYSCLK │ │ HCLK │ │ Peripheral│
│ 168 MHz │ │ (AHB bus) │ │ clocks │
└─────┬─────┘ │ = SYSCLK │ │ │
│ │ /AHB_PRE │ │ PCLK1=/2 │
│ └───────────┘ │ PCLK2=/1 │
│ │ USB=48MHz │
│ │ I2S=exact │
│ └───────────┘
▼
┌───────────┐
│ SysTick │ 168 MHz / 8 = 21 MHz (sau HCLK direct)
│ Timer │ Generează tick OS la 1 ms
└───────────┘
@ Configurare PLL pe STM32F4 (HSE 8 MHz → SYSCLK 168 MHz)
.equ RCC_CR, 0x40023800
.equ RCC_PLLCFGR,0x40023804
.equ RCC_CFGR, 0x40023808
.equ FLASH_ACR, 0x40023C00
configure_clock_168mhz:
PUSH {R0-R2, LR}
@ 1. Activare HSE
LDR R0, =RCC_CR
LDR R1, [R0]
ORR R1, R1, #(1 << 16) @ HSEON
STR R1, [R0]
.Lwait_hse:
LDR R1, [R0]
TST R1, #(1 << 17) @ HSERDY?
BEQ .Lwait_hse
@ 2. Configurare Flash wait states (5 WS la 168 MHz)
LDR R0, =FLASH_ACR
MOV R1, #5 @ 5 wait states
ORR R1, R1, #(1 << 8) @ Prefetch enable
ORR R1, R1, #(1 << 9) @ I-Cache enable
ORR R1, R1, #(1 << 10) @ D-Cache enable
STR R1, [R0]
@ 3. Configurare PLL: HSE(8MHz) * 336 / 8 / 2 = 168 MHz
LDR R0, =RCC_PLLCFGR
LDR R1, =(8) @ PLLM = 8
ORR R1, R1, #(336 << 6) @ PLLN = 336
ORR R1, R1, #(0 << 16) @ PLLP = 0 (÷2)
ORR R1, R1, #(1 << 22) @ PLLSRC = HSE
ORR R1, R1, #(7 << 24) @ PLLQ = 7 (USB: 336/7=48MHz)
STR R1, [R0]
@ 4. Activare PLL
LDR R0, =RCC_CR
LDR R1, [R0]
ORR R1, R1, #(1 << 24) @ PLLON
STR R1, [R0]
.Lwait_pll:
LDR R1, [R0]
TST R1, #(1 << 25) @ PLLRDY?
BEQ .Lwait_pll
@ 5. Configurare prescalere bus
LDR R0, =RCC_CFGR
LDR R1, =(0x2 << 0) @ SW = PLL ca SYSCLK
ORR R1, R1, #(0x0 << 4) @ AHB prescaler = /1 (168 MHz)
ORR R1, R1, #(0x5 << 10) @ APB1 prescaler = /4 (42 MHz)
ORR R1, R1, #(0x4 << 13) @ APB2 prescaler = /2 (84 MHz)
STR R1, [R0]
@ 6. Verificare comutare reușită
.Lwait_sw:
LDR R1, [R0]
AND R1, R1, #(0x3 << 2) @ SWS bits
CMP R1, #(0x2 << 2) @ PLL used as SYSCLK?
BNE .Lwait_sw
POP {R0-R2, PC}
11.2 Ceasul pe x86 modern¶
Referință externă: cristal de cuarț 100 MHz (BCLK — Base Clock)
│
┌───────────────┼───────────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ CPU PLL │ │ Mem PLL │ │ PCIe PLL │
│ BCLK× │ │ BCLK× │ │ 100 MHz │
│ ratio │ │ ratio │ │ ref clk │
│ =4.5GHz │ │ =2800MHz│ │ │
└──────────┘ └──────────┘ └──────────┘
CPU Frequency = BCLK × Ratio = 100 MHz × 45 = 4.5 GHz
(ratio variabil per P-state / turbo boost)
DDR Frequency = BCLK × Memory Ratio
PCIe: clock distribuit pe placa de bază, 100 MHz fix
11.3 Moduri de economisire a energiei¶
ARM Cortex-M:
@ Sleep mode: CPU oprit, periferice active
WFI @ Wait For Interrupt — CPU doarme
@ Se trezește la orice întrerupere activă
@ Stop mode: majoritatea ceasurilor oprite, SRAM păstrată
@ Deep Sleep mode: doar RTC și backup SRAM active
x86 — C-states și P-states:
| C-State | Descriere | Latență trezire | Consum |
|---|---|---|---|
| C0 | Activ (execuție) | 0 | Maxim |
| C1 | Halt (ceas CPU oprit) | ~1 μs | Redus |
| C3 | Sleep (cache L1/L2 flush) | ~50 μs | Foarte redus |
| C6 | Deep Sleep (tensiune redusă) | ~100 μs | Minim |
| C10 | Package C10 (cel mai adânc) | ~1 ms | Aproape zero |
P-states: variază frecvența și tensiunea CPU (DVFS — Dynamic Voltage and Frequency Scaling). P0 = performanță maximă, P1-Pn = frecvențe progresiv mai mici.
12. Arhitectura sistemelor embedded (ARM SoC)¶
12.1 Studiu de caz: STM32F407 (Cortex-M4)¶
Specificații:
- CPU: ARM Cortex-M4F, 168 MHz, FPU single-precision
- Flash: 1 MB
- SRAM: 192 KB + 4 KB backup
- Periferice: 3×SPI, 3×I²C, 4×USART, 2×UART, 2×CAN,
3×ADC 12-bit, 2×DAC 12-bit, USB OTG HS+FS,
Ethernet MAC, Camera interface, 17 timere,
2×DMA (16 streamuri total), RNG, CRC, RTC
- GPIO: 140 pini I/O cu alternate functions
- Alimentare: 1.8V-3.6V, consum < 150 mA la 168 MHz
12.2 Studiu de caz: Raspberry Pi 4 SoC (Broadcom BCM2711)¶
┌──────────────────────────────────────────────────────┐
│ BCM2711 SoC │
│ │
│ ┌───────────────────────────┐ ┌─────────────────┐ │
│ │ 4× Cortex-A72 @ 1.5 GHz │ │ VideoCore VI │ │
│ │ 32KB L1I + 48KB L1D each │ │ GPU @ 500 MHz │ │
│ │ 1 MB L2 shared │ │ H.265 decode │ │
│ └─────────────┬─────────────┘ └────────┬────────┘ │
│ │ │ │
│ ┌─────────────┴──────────────────────────┴────────┐ │
│ │ AXI Bus Fabric │ │
│ └──┬──────┬──────┬──────┬──────┬──────┬───────────┘ │
│ │ │ │ │ │ │ │
│ ┌──┴─┐ ┌──┴─┐ ┌──┴──┐ ┌┴───┐ ┌┴───┐ ┌┴──────┐ │
│ │LPDDR│ │PCIe│ │USB │ │GbE │ │eMMC│ │2×HDMI │ │
│ │4 │ │Gen2│ │3.0 │ │ │ │/SD │ │4Kp60 │ │
│ │ │ │x1 │ │xHCI │ │ │ │ │ │ │ │
│ └────┘ └────┘ └─────┘ └────┘ └────┘ └───────┘ │
│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌───────────┐ │
│ │UART │ │SPI │ │I²C │ │PWM │ │GPIO 40pin │ │
│ │×6 │ │×7 │ │×7 │ │×2ch │ │header │ │
│ └──────┘ └──────┘ └──────┘ └──────┘ └───────────┘ │
└──────────────────────────────────────────────────────┘
12.3 Device Tree — descrierea hardware pe ARM Linux¶
Pe ARM Linux, hardware-ul se descrie prin Device Tree (DTS) — un fișier text compilat în binar (DTB) pe care kernel-ul îl interpretează la boot:
/ {
compatible = "brcm,bcm2711";
#address-cells = <2>;
#size-cells = <1>;
memory@0 {
device_type = "memory";
reg = <0x0 0x0 0x40000000>; /* 1 GB la adresa 0 */
};
soc {
compatible = "simple-bus";
#address-cells = <1>;
#size-cells = <1>;
ranges = <0x7e000000 0x0 0xfe000000 0x01800000>;
uart0: serial@7e201000 {
compatible = "arm,pl011", "arm,primecell";
reg = <0x7e201000 0x200>;
interrupts = <GIC_SPI 121 IRQ_TYPE_LEVEL_HIGH>;
clocks = <&clocks BCM2835_CLOCK_UART>;
clock-names = "uartclk";
status = "okay";
};
gpio: gpio@7e200000 {
compatible = "brcm,bcm2711-gpio";
reg = <0x7e200000 0xb4>;
interrupts = <GIC_SPI 113 IRQ_TYPE_LEVEL_HIGH>;
gpio-controller;
#gpio-cells = <2>;
};
i2c1: i2c@7e804000 {
compatible = "brcm,bcm2711-i2c", "brcm,bcm2835-i2c";
reg = <0x7e804000 0x1000>;
interrupts = <GIC_SPI 117 IRQ_TYPE_LEVEL_HIGH>;
clocks = <&clocks BCM2835_CLOCK_VPU>;
#address-cells = <1>;
#size-cells = <0>;
status = "okay";
clock-frequency = <100000>;
sensor@48 {
compatible = "ti,tmp102";
reg = <0x48>;
};
};
};
};
Pe x86, echivalentul este ACPI (Advanced Configuration and Power Interface) — tabele binare furnizate de BIOS/UEFI care descriu hardware-ul, rutarea întreruperilor, managementul puterii etc.
13. Arhitectura calculatoarelor moderne (x86/x64)¶
13.1 Diagrama unui desktop/laptop modern¶
┌─────────────────────────────────────────────────────────┐
│ PLACA DE BAZĂ (Motherboard) │
│ │
│ ┌──────────────────────────────────────────────────┐ │
│ │ CPU (ex. Intel 13th Gen) │ │
│ │ │ │
│ │ 8 P-cores + 16 E-cores = 24 cores / 32 threads │ │
│ │ L3 Cache: 36 MB shared │ │
│ │ ┌─────────┐ ┌─────────┐ ┌──────────────────┐ │ │
│ │ │ IMC │ │ PCIe │ │ DMI 4.0 │ │ │
│ │ │ DDR5 │ │ Gen 5 │ │ (link to PCH) │ │ │
│ │ │ 2 chan │ │ x16+x4 │ │ 8 GT/s ×8 │ │ │
│ │ └────┬────┘ └────┬────┘ └────────┬──────────┘ │ │
│ └───────┼──────────┼───────────────┼────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌──────────┐ ┌──────────┐ ┌────────────────────────┐ │
│ │ 2×DDR5 │ │ GPU │ │ PCH (Z790) │ │
│ │ DIMM │ │ PCIe 5.0 │ │ │ │
│ │ slots │ │ x16 slot │ │ PCIe Gen 3/4 ×28 │ │
│ └──────────┘ └──────────┘ │ USB 3.2 Gen 2x2 ×5 │ │
│ │ USB 2.0 ×14 │ │
│ ┌──────────┐ │ SATA III ×8 │ │
│ │ NVMe SSD │◄──────────────│ Intel 2.5G Ethernet │ │
│ │ PCIe 4.0 │ (din PCH) │ Intel WiFi 6E │ │
│ │ x4 │ │ HD Audio (ALC4082) │ │
│ └──────────┘ │ SPI (BIOS Flash) │ │
│ │ SMBus (senzori, SPD) │ │
│ ┌──────────┐ │ LPC/eSPI (Super I/O) │ │
│ │ NVMe SSD │◄──────────────│ │ │
│ │ PCIe 4.0 │ (direct CPU) └────────────────────────┘ │
│ │ x4 │ │
│ └──────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ VRM (Voltage Regulator Module) │ │
│ │ Convertește 12V → 1.0-1.5V pentru CPU (50-300A) │ │
│ │ Faze multiple (16-24 faze), controlate de PWM IC │ │
│ └───────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────┐ ┌──────────┐ ┌─────────────────────────┐ │
│ │ BIOS │ │ Super I/O│ │ Clock Generator │ │
│ │ SPI Flash│ │ (fan, │ │ 100 MHz BCLK │ │
│ │ 32 MB │ │ serial, │ │ + spread spectrum │ │
│ │ │ │ PS/2) │ │ │ │
│ └──────────┘ └──────────┘ └─────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
13.2 Enumerarea PCIe — descoperirea hardware¶
La boot, BIOS/UEFI scanează toate bus-urile PCIe:
PCIe Config Space (256 bytes legacy / 4KB extended):
Offset Registru
0x00 Vendor ID (ex. 0x8086 = Intel, 0x10DE = NVIDIA)
0x02 Device ID
0x04 Command (enable memory space, bus master)
0x06 Status
0x08 Revision ID
0x09 Class Code (3 bytes: Class, Subclass, Prog IF)
0x10-0x24 BAR0-BAR5 (Base Address Registers)
0x2C Subsystem Vendor ID
0x2E Subsystem ID
0x3C Interrupt Line
0x3D Interrupt Pin
; x86: citirea PCIe config space (mecanismul CF8/CFC legacy)
; Bus 0, Device 2, Function 0, Offset 0 (Vendor+Device ID)
mov eax, 0x80000000 ; Enable bit
or eax, (0 << 16) ; Bus 0
or eax, (2 << 11) ; Device 2 (GPU integrat Intel, de obicei)
or eax, (0 << 8) ; Function 0
or eax, 0x00 ; Offset 0
mov dx, 0xCF8
out dx, eax ; Scrie adresa la CONFIG_ADDRESS
mov dx, 0xCFC
in eax, dx ; Citește Vendor ID (low 16) + Device ID (high 16)
; EAX = 0x????8086 dacă e Intel
Pe sisteme moderne, config space-ul PCIe este accesat prin MMIO (ECAM — Enhanced Configuration Access Mechanism), nu prin porturile legacy CF8/CFC.
14. Comunicația inter-procesor și sisteme multi-core¶
14.1 Coerența cache-ului¶
Când mai multe nuclee au propriile cache-uri L1/L2, trebuie asigurată consistența datelor partajate.
Protocolul MESI (Modified, Exclusive, Shared, Invalid):
| Stare | Descriere |
|---|---|
| Modified | Linia e modificată local, unica copie validă |
| Exclusive | Linia e identică cu memoria, unica copie în cache |
| Shared | Linia e identică cu memoria, poate exista în alte cache-uri |
| Invalid | Linia nu e validă |
Exemplu: Core 0 scrie variabila X
1. Core 0 are X în stare Shared
2. Core 1 are X în stare Shared
3. Core 0 vrea să scrie X:
→ Core 0 trimite "Invalidate" pe bus
→ Core 1 primește, marchează X ca Invalid
→ Core 0 trece X în Modified, scrie valoarea
4. Core 1 vrea să citească X:
→ Core 1 trimite "Read" pe bus
→ Core 0 interceptează, trimite valoarea modificată
→ Ambele trec X în Shared
14.2 IPI — Inter-Processor Interrupts (x86)¶
Un nucleu poate trimite o întrerupere altui nucleu prin LAPIC:
; x86: trimitere IPI (Inter-Processor Interrupt)
; Folosind ICR (Interrupt Command Register) al LAPIC
; Trimite vector 0x40 către APIC ID 2
mov dword [0xFEE00310], (2 << 24) ; ICR high: dest APIC ID = 2
mov dword [0xFEE00300], 0x00004040 ; ICR low: vector 0x40, fixed delivery
; Utilizări IPI:
; - OS trimite TLB shootdown (invalidare TLB pe alte nuclee)
; - OS trimite reschedule interrupt
; - INIT IPI + SIPI pentru pornirea nucleelor secundare la boot
14.3 Pornirea nucleelor secundare¶
x86 (AP startup sequence):
1. BSP (Bootstrap Processor) pornește primul
2. BSP detectează AP-urile (Application Processors) prin ACPI/MP Table
3. BSP trimite INIT IPI → resetează AP-ul
4. BSP trimite SIPI (Startup IPI) cu adresa codului de startup
5. AP-ul pornește în Real Mode la adresa specificată
6. AP-ul execută codul de inițializare (trece în Long Mode, join scheduler)
ARM (PSCI — Power State Coordination Interface):
@ ARM: pornire nucleu secundar folosind PSCI (prin SMC/HVC)
@ cpu_on(target_cpu, entry_point, context_id)
MOV X0, #0xC4000003 @ PSCI CPU_ON function ID (64-bit)
MOV X1, #1 @ Target CPU: core 1
LDR X2, =secondary_entry @ Adresa codului de startup
MOV X3, #0 @ Context ID
SMC #0 @ Secure Monitor Call (EL3)
@ sau HVC #0 pentru hypervisor
14.4 Sincronizare între nuclee¶
@ ARM: spinlock simplu folosind exclusive load/store
.global spin_lock
spin_lock:
MOV W2, #1 @ Valoare „locked"
.Lretry:
LDAXR W1, [X0] @ Load-Acquire Exclusive
CBNZ W1, .Lspin @ Dacă deja locked, spin
STXR W3, W2, [X0] @ Store Exclusive (try lock)
CBNZ W3, .Lretry @ Dacă store a eșuat, retry
RET @ Lock achiziționat
.Lspin:
YIELD @ Hint: alt thread poate rula
B .Lretry
.global spin_unlock
spin_unlock:
STLR WZR, [X0] @ Store-Release zero (unlock)
RET
; x86: spinlock cu LOCK prefix
spin_lock:
mov eax, 1
.retry:
xchg eax, [rdi] ; atomic swap (implicit LOCK)
test eax, eax
jnz .spin ; dacă era locked, spin
ret ; lock achiziționat
.spin:
pause ; reduce consumul în spin loop
cmp dword [rdi], 0 ; citire normală (fără lock)
jne .spin ; spin pe citire (mai eficient)
jmp .retry ; încearcă din nou cu xchg
spin_unlock:
mov dword [rdi], 0 ; simplu store (x86 e strongly ordered)
ret
15. Interfețe externe și standarde de comunicație¶
15.1 Tabel comparativ interfețe¶
| Interfață | Tip | Viteză maximă | Fire | Distanță | Utilizare tipică |
|---|---|---|---|---|---|
| UART | Serial async | 1-5 Mbps | 2 | 15 m | Debug, senzori, GPS, BT |
| SPI | Serial sync | 50+ MHz | 4+CS | 1 m | Flash, display, ADC |
| I²C | Serial sync | 100k-3.4M | 2 | 1 m | Senzori, EEPROM, RTC |
| CAN | Diferențial | 1 Mbps (CAN FD 8M) | 2 | 40-500 m | Automotive, industrial |
| USB 2.0 | Serial | 480 Mbps | 4 | 5 m | Periferice PC, MCU |
| USB 3.2 | Serial | 20 Gbps | varies | 3 m | Storage, display, docking |
| USB4/TB4 | Serial | 40/80 Gbps | varies | 2 m | eGPU, docking, display |
| Ethernet | Serial | 100M-400G | 2-8 | 100m Cu | Networking |
| PCIe 5.0 | Serial | 128 GB/s (x16) | varies | placa PCB | GPU, NVMe, acceleratoare |
| SATA III | Serial | 6 Gbps | 7 | 1 m | HDD, SSD (legacy) |
| SDIO | Paralel | 208 MHz DDR (UHS-I) | 6 | pe PCB | SD cards, WiFi modules |
| JTAG | Serial sync | 10-50 MHz | 4-5 | 30 cm | Debug, programming |
| SWD | Serial sync | 10-50 MHz | 2 | 30 cm | ARM debug (alternativă JTAG) |
| MIPI CSI | Serial | 2.5 Gbps/lane | 2/lane | pe PCB | Cameră |
| MIPI DSI | Serial | 1.5 Gbps/lane | 2/lane | pe PCB | Display mobil |
| HDMI 2.1 | TMDS/FRL | 48 Gbps | 19 | 3 m | Display, audio |
| DisplayPort | Serial | 80 Gbps (DP 2.1) | 20 | 3 m | Display profesional |
15.2 Protocoale de debug¶
JTAG (Joint Test Action Group):
Semnale: TCK (Clock), TMS (Mode Select), TDI (Data In), TDO (Data Out), nTRST
Funcții: boundary scan, debug CPU, programare Flash/FPGA
Permite: oprire CPU, citire/scriere registre și memorie, breakpoints hardware
SWD (Serial Wire Debug) — ARM specific:
Semnale: SWDIO (bidirecțional), SWCLK
Avantaje: doar 2 fire (vs. 4-5 JTAG), aceeași funcționalitate
Suportat de: toate Cortex-M, cele mai multe Cortex-A
Debuggere: ST-LINK, J-Link, CMSIS-DAP
Protocoale de trace:
- ETM (Embedded Trace Macrocell) — ARM: trace hardware non-invaziv, înregistrează fluxul de instrucțiuni fără a afecta execuția
- Intel PT (Processor Trace): echivalent x86, trace hardware pe pachet
16. Studii de caz comparative¶
16.1 Aprinderea unui LED — de la hardware la software¶
Embedded (STM32, bare-metal):
Lanțul: Cod → AHB Bus → GPIO Controller → Pin fizic → LED
Latență: ~3 cicluri de ceas (instruction + bus + periferic)
La 168 MHz: ~18 ns de la instrucțiune la schimbarea pinului
Cod:
LDR R0, =GPIOA_BSRR @ Adresa registrului
MOV R1, #(1 << 5) @ Bit Set pentru PA5
STR R1, [R0] @ O singură instrucțiune schimbă pinul
Desktop (Linux, /sys/class/gpio):
Lanțul: Aplicație userspace
→ syscall write()
→ kernel VFS layer
→ sysfs driver
→ GPIO subsystem
→ Platform driver
→ MMIO la chipset/SuperIO/GPIO controller
→ Pin fizic
→ LED
Latență: ~1-10 μs (de 100-1000× mai lent)
Cod (din shell):
echo 1 > /sys/class/gpio/gpio17/value
16.2 Citirea unui senzor de temperatură I²C¶
Embedded (Cortex-M, HAL):
// Polling — totul pe același chip, fără OS
uint8_t data[2];
HAL_I2C_Master_Receive(&hi2c1, 0x48 << 1, data, 2, 100);
float temp = ((data[0] << 8) | data[1]) / 256.0f;
// Latență totală: ~200 μs (dominată de viteza I²C la 400 kHz)
// CPU ocupat 100% pe durata transferului (polling)
// SAU: cu DMA/IT, CPU liber, notificat la final
Desktop (Linux, i2c-dev):
// Trece prin kernel I²C subsystem, SMBus driver, chipset PCH
int fd = open("/dev/i2c-1", O_RDWR);
ioctl(fd, I2C_SLAVE, 0x48);
uint8_t data[2];
read(fd, data, 2);
float temp = ((data[0] << 8) | data[1]) / 256.0f;
// Latență: ~200 μs I²C + overhead kernel ~50 μs
// CPU nu e blocat — kernel face scheduling
16.3 Tabel sinteză arhitecturală¶
| Caracteristică | MCU (Cortex-M4) | Desktop (Intel i7-13700K) |
|---|---|---|
| Frecvență CPU | 168 MHz | 5.4 GHz (turbo) |
| Nuclee | 1 | 24 (8P + 16E) |
| Pipeline | 3 etaje, in-order | 20+ etaje, OoO |
| Cache | 0 (opțional I/D cache mic) | L1 80KB/core, L2 2MB/core, L3 30MB |
| RAM | 192 KB SRAM on-chip | 128 GB DDR5 off-chip |
| Stocare program | 1 MB Flash on-chip | SSD 1-4 TB (PCIe NVMe) |
| Memorie virtuală | Nu (MPU opțional) | Da (MMU, 4-level page table) |
| Magistrale interne | AHB/APB (32-bit, 168/84 MHz) | Ring/Mesh + PCIe 5.0 + DDR5 |
| I/O | Memory-mapped direct | Prin chipset + drivere OS |
| Întreruperi | NVIC, 12 cicluri latență | LAPIC + I/O APIC, ~μs |
| Boot | ~10 ms (direct din Flash) | ~10-30 s (UEFI → OS) |
| OS tipic | Bare-metal / FreeRTOS | Linux / Windows |
| Determinism temporal | Garantat (hard real-time) | Negarat (soft real-time cu RT patch) |
| Consum | 100-500 mW | 65-253W (PBP-MTP) |
| Cost chip | $3-10 | $300-500 |
| Număr tranzistoare | ~1M | ~5-15B |
Anexe¶
A. Glosar de magistrale și protocoale¶
| Acronim | Denumire completă | Context |
|---|---|---|
| AMBA | Advanced Microcontroller Bus Architecture | ARM SoC |
| AHB | Advanced High-performance Bus | ARM SoC |
| APB | Advanced Peripheral Bus | ARM SoC |
| AXI | Advanced eXtensible Interface | ARM SoC/FPGA |
| CHI | Coherent Hub Interface | ARM server |
| PCIe | Peripheral Component Interconnect Express | x86/universal |
| DMI | Direct Media Interface | Intel CPU-PCH |
| UPI | Ultra Path Interconnect | Intel multi-CPU |
| QPI | QuickPath Interconnect (predecessor UPI) | Intel (legacy) |
| IF | Infinity Fabric | AMD |
| FSB | Front Side Bus (obsolet) | Intel pre-2008 |
| HyperTransport | HT (predecessor IF) | AMD (legacy) |
| CXL | Compute Express Link | Acceleratoare |
| CCIX | Cache Coherent Interconnect for Accelerators | Acceleratoare |
B. Harta memoriei comparative¶
Cortex-M (32-bit, 4GB address space):
0x00000000-0x1FFFFFFF Code (Flash, ROM) — 512 MB
0x20000000-0x3FFFFFFF SRAM — 512 MB
0x40000000-0x5FFFFFFF Periferice — 512 MB
0x60000000-0x9FFFFFFF External RAM — 1 GB
0xA0000000-0xDFFFFFFF External Device — 1 GB
0xE0000000-0xE00FFFFF Private Peripheral (NVIC, SysTick, SCB)
0xE0100000-0xFFFFFFFF Vendor-specific
x86-64 (48-bit virtual, 256 TB):
0x0000000000000000-0x00007FFFFFFFFFFF User Space (128 TB)
0x0000000000400000 Text segment (.text)
0x0000000000600000 Data segment (.data, .bss)
0x00007FFxxxxxxxx Stack (crește în jos)
0x00007FFFF7xxxxxx Shared libraries
Non-canonical hole (nevalid)
0xFFFF800000000000-0xFFFFFFFFFFFFFFFF Kernel Space (128 TB)
0xFFFF880000000000 Direct mapping of all physical memory
0xFFFFFFF000000000 MMIO region
0xFFFFFFFF80000000 Kernel text (.text)
0xFFFFFFFFFEE00000 LAPIC MMIO
C. Pini și semnale critice pe placa de bază¶
CPU Socket:
├── Power: VCC_CORE (1.0-1.5V, sute de amperi), VCC_IO
├── Clock: BCLK (100 MHz), refclk
├── Reset: RESET#, INIT#
├── Memory: DDR5 data (64-bit per canal), address, command, clock
├── PCIe: TX±/RX± perechi diferențiale (lanes)
├── DMI: TX±/RX± către PCH
├── Control: THERMTRIP#, PROCHOT#, VID (voltage ID)
└── Debug: ITP (In-Target Probe)
PCH:
├── PCIe Gen 3/4 lanes
├── USB 3.2/2.0 ports
├── SATA ports
├── HDA (High Definition Audio)
├── SPI (BIOS Flash)
├── SMBus/I²C (SPD, senzori)
├── eSPI/LPC (Super I/O, TPM)
├── GPIO
└── DMI uplink to CPU
Curs realizat ca material de referință pentru studenții de calculatoare, electronică și sisteme embedded.
Pe această pagină