# Analyse des Données de Benchmarking

Ce document identifie toutes les données intéressantes à collecter basées sur les résultats réels des benchmarks.

---

## 📊 1. BENCHMARKS - Données à récupérer

### 1.1 CPU (sysbench)

**Commande testée** :
```bash
sysbench cpu --cpu-max-prime=10000 --threads=$(nproc) run
```

**Output analysé** :
```
CPU speed:
    events per second:  3409.87

General statistics:
    total time:                          10.0005s
    total number of events:              34107

Latency (ms):
         min:                                    1.10
         avg:                                    1.17
         max:                                   15.92
         95th percentile:                        1.23
```

**✅ Données IMPORTANTES à extraire** :
- `events_per_second` : **3409.87** (métrique principale pour score)
- `total_time` : 10.0005s (durée du test)
- `avg_latency_ms` : 1.17 (latence moyenne)

**❌ Données OPTIONNELLES** (peuvent être ignorées pour l'instant) :
- min/max latency
- 95th percentile
- threads fairness

**Parsing recommandé** :
```bash
events_per_sec=$(sysbench cpu ... | grep 'events per second' | awk '{print $4}')
```

---

### 1.2 MEMORY (sysbench)

**Commande testée** :
```bash
sysbench memory --memory-block-size=1M --memory-total-size=512M run
```

**Output analysé** :
```
512.00 MiB transferred (13806.03 MiB/sec)

General statistics:
    total time:                          0.0351s
```

**✅ Données IMPORTANTES à extraire** :
- `throughput_mib_s` : **13806.03** MiB/sec (métrique principale)
- `total_time` : 0.0351s

**Parsing recommandé** :
```bash
throughput=$(sysbench memory ... | grep 'MiB/sec' | grep -oP '\d+\.\d+ MiB/sec' | awk '{print $1}')
```

---

### 1.3 DISK (fio) - Format JSON

**Commande testée** :
```bash
fio --name=test --ioengine=libaio --rw=randrw --bs=4k --size=100M \
    --numjobs=1 --direct=1 --filename=/tmp/fio-test-file --output-format=json
```

**Output JSON (extrait)** :
```json
{
  "read": {
    "bw_bytes": 728177777,
    "bw": 711111,
    "iops": 177777.777778,
    "runtime": 72
  },
  "write": {
    "bw_bytes": 728177777,
    "bw": 711111,
    "iops": 177777.777778
  }
}
```

**✅ Données IMPORTANTES à extraire** :
- `read.bw` : 711111 KiB/s → convertir en MB/s : **711 MB/s**
- `write.bw` : 711111 KiB/s → convertir en MB/s : **711 MB/s**
- `read.iops` : **177777** (operations/sec)
- `write.iops` : **177777** (operations/sec)
- `read.clat_ns.mean` : latence moyenne en nanosecondes

**Parsing recommandé (avec jq)** :
```bash
fio_output=$(fio ... --output-format=json)
read_mb_s=$(echo "$fio_output" | jq '.jobs[0].read.bw / 1024')
write_mb_s=$(echo "$fio_output" | jq '.jobs[0].write.bw / 1024')
iops_read=$(echo "$fio_output" | jq '.jobs[0].read.iops')
iops_write=$(echo "$fio_output" | jq '.jobs[0].write.iops')
latency_ns=$(echo "$fio_output" | jq '.jobs[0].read.clat_ns.mean')
latency_ms=$(echo "scale=3; $latency_ns / 1000000" | bc)
```

---

### 1.4 NETWORK (iperf3) - Format JSON

**Commande testée** :
```bash
iperf3 -c 10.0.0.50 -t 5 -J
```

**Output JSON (extrait)** :
```json
{
  "end": {
    "sum_sent": {
      "bits_per_second": 327057987.07346243,
      "retransmits": 102
    },
    "sum_received": {
      "bits_per_second": 323523050.66083658
    }
  }
}
```

**✅ Données IMPORTANTES à extraire** :
- `upload_mbps` : 327057987 / 1000000 = **327 Mbps** (bits_per_second sender)
- `download_mbps` : **323 Mbps** (pour test en reverse -R)
- `retransmits` : 102 (nombre de retransmissions)
- `mean_rtt` : 53143 µs (ping moyen)

**Parsing recommandé (avec jq)** :
```bash
upload_bits=$(echo "$iperf_json" | jq '.end.sum_sent.bits_per_second')
upload_mbps=$(echo "scale=2; $upload_bits / 1000000" | bc)
rtt_us=$(echo "$iperf_json" | jq '.end.streams[0].sender.mean_rtt')
ping_ms=$(echo "scale=2; $rtt_us / 1000" | bc)
```

---

## 🖥️ 2. HARDWARE - Données à récupérer

### 2.1 CPU (lscpu + dmidecode)

**Commande testée** : `lscpu` (output en français sur ta machine)

**Output analysé** :
```
Identifiant constructeur :                  GenuineIntel
Nom de modèle :                           Intel(R) Core(TM) i5-2400 CPU @ 3.10GHz
Processeur(s) :                             4
Thread(s) par cœur :                    1
Cœur(s) par socket :                    4
Socket(s) :                             1
Vitesse maximale du processeur en MHz : 3400,0000
Vitesse minimale du processeur en MHz : 1600,0000

Caches (somme de toutes) :
  L1d :                                     128 KiB (4 instances)
  L1i :                                     128 KiB (4 instances)
  L2 :                                      1 MiB (4 instances)
  L3 :                                      6 MiB (1 instance)

Drapeaux : fpu vme de pse tsc msr ... avx sse4_1 sse4_2 ...
```

**✅ Données IMPORTANTES à extraire** :
- `vendor` : **GenuineIntel**
- `model` : **Intel(R) Core(TM) i5-2400 CPU @ 3.10GHz**
- `microarchitecture` : Peut être déduit du model (Sandy Bridge pour i5-2400)
- `cores` : **4** (cœurs physiques)
- `threads` : **4** (4 cœurs × 1 thread = 4)
- `base_freq_ghz` : **3.1** GHz (du nom du modèle)
- `max_freq_ghz` : **3.4** GHz
- `cache_l1_kb` : 128 + 128 = **256 KB** (L1d + L1i)
- `cache_l2_kb` : 1024 KB = **1024 KB**
- `cache_l3_kb` : 6144 KB = **6144 KB**
- `flags` : ["avx", "sse4_1", "sse4_2", "aes", "pclmulqdq", ...] (important pour virtualisation)

**⚠️ PROBLÈME DÉTECTÉ** :
```bash
echo "Cores: $(lscpu | grep '^CPU(s):' | awk '{print $2}')"
# Retourne vide car en français : "Processeur(s) :"
```

**✅ SOLUTION - Forcer locale en anglais** :
```bash
LC_ALL=C lscpu
# Ou utiliser lscpu -J pour JSON et parser avec jq
```

**Parsing recommandé** :
```bash
export LC_ALL=C
vendor=$(lscpu | grep 'Vendor ID' | awk '{print $3}')
model=$(lscpu | grep 'Model name' | sed 's/Model name: *//' | xargs)
cores=$(lscpu | grep '^CPU(s):' | awk '{print $2}')
threads=$(nproc)
max_freq=$(lscpu | grep 'CPU max MHz' | awk '{print $4}')
max_freq_ghz=$(echo "scale=2; $max_freq / 1000" | bc)

# Caches
cache_l1d=$(lscpu | grep 'L1d cache' | awk '{print $3}' | sed 's/K//')
cache_l1i=$(lscpu | grep 'L1i cache' | awk '{print $3}' | sed 's/K//')
cache_l2=$(lscpu | grep 'L2 cache' | awk '{print $3}' | sed 's/[MK]//')
cache_l3=$(lscpu | grep 'L3 cache' | awk '{print $3}' | sed 's/[MK]//')

# Flags (liste complète)
flags=$(lscpu | grep 'Flags:' | sed 's/Flags: *//')
```

**❌ Données MANQUANTES actuellement** :
- `tdp_w` : Non disponible via lscpu, peut être récupéré via dmidecode ou base de données constructeur

---

### 2.2 RAM (free + dmidecode)

**Commande testée** : `free -m` + `sudo dmidecode -t memory`

**Output free -m** :
```
               total       utilisé      libre     partagé tamp/cache   disponible
Mem:            7771        5847        1479         678        1410        1923
```

**Output dmidecode -t memory** (extrait) :
```
Physical Memory Array
	Error Correction Type: None
	Maximum Capacity: 32 GB
	Number Of Devices: 4

Memory Device
	Size: 2 GB
	Form Factor: DIMM
	Locator: A1_DIMM0
	Type: DDR3
	Speed: 1333 MT/s
	Manufacturer: Samsung
	Part Number: M378B5773DH0-CH9
	Rank: 1
```

**✅ Données IMPORTANTES à extraire** :
- `total_mb` : **7771 MB** (du free -m)
- `slots_total` : **4** (Number Of Devices)
- `slots_used` : **4** (compter les Memory Device avec Size > 0)
- `ecc` : **false** (Error Correction Type: None)
- `layout` : Array de:
  - `slot` : "A1_DIMM0", "A1_DIMM1", "A1_DIMM2", "A1_DIMM3"
  - `size_mb` : 2048 (2 GB)
  - `type` : "DDR3"
  - `speed_mhz` : 1333
  - `manufacturer` : "Samsung" ou "Kingston"
  - `part_number` : "M378B5773DH0-CH9" ou "ACR256X64D3U1333C9"

**Parsing recommandé** :
```bash
# Total RAM
total_mb=$(free -m | grep '^Mem:' | awk '{print $2}')

# Avec dmidecode (nécessite sudo)
if command -v dmidecode &> /dev/null && [ $(id -u) -eq 0 ]; then
    ecc=$(sudo dmidecode -t 16 | grep 'Error Correction Type' | grep -q 'None' && echo "false" || echo "true")
    slots_total=$(sudo dmidecode -t 16 | grep 'Number Of Devices' | awk '{print $4}')

    # Parser chaque DIMM (complexe, nécessite parsing multi-lignes)
    # Voir script complet ci-dessous
fi
```

---

### 2.3 GPU (lspci + nvidia-smi)

**Commande testée** : `lspci | grep -i vga`

**Output analysé** :
```
00:02.0 VGA compatible controller: Intel Corporation 2nd Generation Core Processor Family Integrated Graphics Controller (rev 09)
```

**✅ Données IMPORTANTES à extraire** :
- `vendor` : **Intel Corporation**
- `model` : **2nd Generation Core Processor Family Integrated Graphics Controller**
- `pci_id` : **00:02.0**

**Pour GPU NVIDIA** (nvidia-smi) :
```bash
nvidia-smi --query-gpu=name,memory.total,driver_version,vbios_version --format=csv,noheader
# Output: GeForce RTX 3070, 8192 MiB, 525.105.17, 94.02.42.00.35
```

**Parsing recommandé** :
```bash
gpu_info=$(lspci | grep -i vga | head -1)
if echo "$gpu_info" | grep -qi 'nvidia'; then
    gpu_vendor="NVIDIA"
    gpu_model=$(nvidia-smi --query-gpu=name --format=csv,noheader | head -1)
    gpu_vram=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | head -1)
elif echo "$gpu_info" | grep -qi 'intel'; then
    gpu_vendor="Intel"
    gpu_model=$(echo "$gpu_info" | sed 's/.*: //' | sed 's/ (rev.*//')
    gpu_vram=null
else
    gpu_vendor=$(echo "$gpu_info" | awk -F: '{print $3}' | awk '{print $1, $2}')
    gpu_model=$(echo "$gpu_info" | sed 's/.*: //')
fi
```

---

### 2.4 MOTHERBOARD (dmidecode)

**Commande testée** : `sudo dmidecode -t baseboard`

**Output analysé** :
```
Base Board Information
	Manufacturer: LENOVO
	Product Name:
	Version:
	Serial Number: INVALID
```

**⚠️ PROBLÈME** : Product Name est vide sur ta machine Lenovo (OEM)

**✅ Données IMPORTANTES à extraire** :
- `manufacturer` : **LENOVO**
- `model` : **(vide sur certaines machines)**
- `version` : (vide)

**Alternative - dmidecode -t 1 (System Information)** :
```bash
sudo dmidecode -t 1 | grep -E 'Manufacturer|Product Name|Version'
```

**Parsing recommandé** :
```bash
if command -v dmidecode &> /dev/null && [ $(id -u) -eq 0 ]; then
    mb_manufacturer=$(sudo dmidecode -t 2 | grep 'Manufacturer:' | sed 's/.*: *//' | xargs)
    mb_model=$(sudo dmidecode -t 2 | grep 'Product Name:' | sed 's/.*: *//' | xargs)
    [ -z "$mb_model" ] && mb_model="Unknown"
fi
```

**❌ Données MANQUANTES actuellement** :
- `bios_version` : Disponible via `dmidecode -t 0`
- `bios_date` : Disponible via `dmidecode -t 0`

---

### 2.5 STORAGE (lsblk + smartctl)

**Commande testée** : `lsblk -J` + `sudo smartctl -i /dev/sda`

**Output lsblk -J** (extrait) :
```json
{
  "blockdevices": [
    {
      "name": "sda",
      "size": "447,1G",
      "type": "disk",
      "children": [
        {"name": "sda1", "size": "7,4G", "type": "part", "mountpoints": ["[SWAP]"]},
        {"name": "sda5", "size": "439,7G", "type": "part", "mountpoints": ["/"]}
      ]
    }
  ]
}
```

**Output smartctl** :
```
Device Model:     KINGSTON SA400S37480G
Serial Number:    50026B77833E25E3
User Capacity:    480 103 981 056 bytes [480 GB]
Rotation Rate:    Solid State Device
SATA Version is:  SATA 3.2, 6.0 Gb/s (current: 6.0 Gb/s)
```

**✅ Données IMPORTANTES à extraire** :
- `device` : **sda**
- `model` : **KINGSTON SA400S37480G**
- `size_gb` : **480** GB
- `type` : **ssd** (ou hdd si Rotation Rate ≠ SSD)
- `interface` : **sata** (ou nvme, usb)
- `serial` : **50026B77833E25E3**

**Parsing recommandé** :
```bash
# Liste des disques (JSON)
disks_json=$(lsblk -J -o NAME,SIZE,TYPE,ROTA,TRAN)

# Pour chaque disque
for disk in $(lsblk -d -n -o NAME); do
    model=$(sudo smartctl -i /dev/$disk 2>/dev/null | grep 'Device Model' | sed 's/.*: *//')
    size=$(lsblk -d -n -o SIZE /dev/$disk | sed 's/,/./')
    type=$(lsblk -d -n -o ROTA /dev/$disk) # 0=SSD, 1=HDD
    [ "$type" = "0" ] && disk_type="ssd" || disk_type="hdd"
    interface=$(lsblk -d -n -o TRAN /dev/$disk) # sata, nvme, usb
done
```

---

### 2.6 NETWORK (ip link)

**Commande testée** : `ip link show`

**Output analysé** :
```
2: eno1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP
    link/ether 44:37:e6:6b:53:86 brd ff:ff:ff:ff:ff:ff

3: wlp2s0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN
    link/ether 14:f6:d8:67:27:b7 brd ff:ff:ff:ff:ff:ff
```

**✅ Données IMPORTANTES à extraire** :
- `name` : **eno1**, **wlp2s0**
- `mac` : **44:37:e6:6b:53:86**
- `state` : **UP** ou **DOWN**
- `type` : **ethernet** (eno*, eth*) ou **wifi** (wlp*, wlan*)
- `speed_mbps` : Via `ethtool eno1 | grep Speed` → "Speed: 1000Mb/s"

**Parsing recommandé** :
```bash
# Interfaces actives
for iface in $(ip -br link show | grep UP | awk '{print $1}'); do
    # Ignorer loopback, docker, bridges
    [[ "$iface" =~ ^(lo|docker|br-|veth) ]] && continue

    mac=$(ip link show $iface | grep 'link/ether' | awk '{print $2}')

    # Type d'interface
    if [[ "$iface" =~ ^(eth|eno|enp) ]]; then
        type="ethernet"
    elif [[ "$iface" =~ ^(wlan|wlp) ]]; then
        type="wifi"
    else
        type="unknown"
    fi

    # Vitesse (nécessite ethtool)
    if command -v ethtool &> /dev/null; then
        speed=$(sudo ethtool $iface 2>/dev/null | grep 'Speed:' | awk '{print $2}' | sed 's/Mb\/s//')
    fi
done
```

---

### 2.7 OS (os-release + uname)

**Commande testée** : `cat /etc/os-release` + `uname -r` + `uname -m`

**Output analysé** :
```
ID=debian
VERSION_ID="13"
VERSION="13 (trixie)"
VERSION_CODENAME=trixie

6.12.57+deb13-amd64
x86_64
```

**✅ Données IMPORTANTES à extraire** :
- `name` : **debian**
- `version` : **13 (trixie)**
- `kernel_version` : **6.12.57+deb13-amd64**
- `architecture` : **x86_64**

**Parsing recommandé** :
```bash
os_name=$(grep '^ID=' /etc/os-release | cut -d= -f2 | tr -d '"')
os_version=$(grep '^VERSION=' /etc/os-release | cut -d= -f2 | tr -d '"')
kernel=$(uname -r)
arch=$(uname -m)
```

---

## 🔍 3. DONNÉES SUPPLÉMENTAIRES INTÉRESSANTES

### 3.1 BIOS (dmidecode -t 0)

**Pourquoi c'est utile** : Version BIOS/UEFI peut affecter performances, compatibilité

```bash
sudo dmidecode -t 0
# Output:
# Vendor: LENOVO
# Version: 9SKT91AUS
# Release Date: 03/30/2012
```

**✅ Données à extraire** :
- `bios_vendor` : LENOVO
- `bios_version` : 9SKT91AUS
- `bios_date` : 03/30/2012

---

### 3.2 PCI Version (lspci -v)

**Pourquoi c'est utile** : PCIe gen (2.0, 3.0, 4.0, 5.0) affecte bande passante GPU/NVMe

```bash
sudo lspci -vv -s 00:02.0 | grep 'LnkCap:'
# Output:
# LnkCap: Port #0, Speed 2.5GT/s, Width x16
# → PCIe 2.0 x16
```

**✅ Données à extraire** :
- `pcie_version` : 2.0, 3.0, 4.0, 5.0
- `pcie_lanes` : x1, x4, x8, x16

**❌ COMPLEXITÉ** : Parsing difficile, pas prioritaire pour MVP

---

### 3.3 USB Version (lsusb)

**Pourquoi c'est utile** : USB 2.0 / 3.0 / 3.1 / 4.0 pour périphériques

```bash
lsusb
# Output:
# Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
# Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
```

**✅ Données à extraire** :
- `usb_controllers` : ["USB 2.0", "USB 3.0"]

**❌ PAS PRIORITAIRE** pour benchmarking hardware

---

### 3.4 Température CPU (sensors)

**Pourquoi c'est utile** : Throttling thermique affecte performances

```bash
sensors
# Output:
# coretemp-isa-0000
# Core 0: +45.0°C
# Core 1: +43.0°C
```

**✅ Données à extraire** :
- `cpu_temp_celsius` : 45.0 (moyenne des cores)

**❌ PAS PRIORITAIRE** pour MVP (nécessite lm-sensors installé)

---

### 3.5 Consommation électrique (TDP)

**Pourquoi c'est utile** : Efficacité énergétique (perf/watt)

**Problème** : Pas accessible via commandes Linux standard
- Nécessite lookup dans base de données (ark.intel.com, AMD specs)
- Ou lecture via RAPL (Running Average Power Limit) si supporté

**❌ NON IMPLÉMENTABLE** facilement sans DB externe

---

## 📋 4. RÉSUMÉ - Priorités d'implémentation

### ✅ NIVEAU 1 - ESSENTIEL (déjà partiellement fait)

| Catégorie | Données | Outil | Parsing |
|-----------|---------|-------|---------|
| CPU Bench | events_per_sec, latency | sysbench | ✅ Simple (grep/awk) |
| Memory Bench | throughput_mib_s | sysbench | ✅ Simple (grep/awk) |
| Disk Bench | read/write MB/s, IOPS | fio JSON | ✅ Moyen (jq) |
| Network Bench | upload/download Mbps | iperf3 JSON | ✅ Moyen (jq) |
| CPU Info | vendor, model, cores, threads | lscpu | ⚠️ Locale issue |
| RAM Info | total_mb | free | ✅ Simple |
| OS Info | name, version, kernel | os-release | ✅ Simple |

**Actions requises** :
1. ✅ Forcer `LC_ALL=C` pour lscpu
2. ✅ Utiliser JSON pour fio/iperf3
3. ✅ Parser correctement les résultats

---

### ✅ NIVEAU 2 - IMPORTANT (enrichissement)

| Catégorie | Données | Outil | Complexité |
|-----------|---------|-------|-----------|
| CPU Detail | freq, caches, flags | lscpu | Moyen |
| RAM Detail | slots, type, speed, ECC | dmidecode | Élevée (sudo required) |
| GPU | vendor, model, vram | lspci, nvidia-smi | Moyen |
| Storage | model, size, type (SSD/HDD) | lsblk, smartctl | Moyen (sudo) |
| Network | interfaces, MAC, speed | ip, ethtool | Moyen |
| Motherboard | manufacturer, model | dmidecode | Simple (sudo) |

**Actions requises** :
1. ✅ Implémenter détection dmidecode (avec fallback si sudo manquant)
2. ✅ Parser GPU (lspci minimum, nvidia-smi si dispo)
3. ✅ Collecter storage avec smartctl (optionnel)

---

### ⚠️ NIVEAU 3 - NICE TO HAVE (futur)

| Données | Outil | Priorité | Raison |
|---------|-------|----------|--------|
| BIOS version/date | dmidecode -t 0 | Basse | Utile mais pas critique |
| PCIe version | lspci -vv | Basse | Parsing complexe |
| USB controllers | lsusb | Très basse | Peu utile pour bench |
| CPU temp | sensors | Moyenne | Nécessite lm-sensors |
| TDP | DB externe | Très basse | Non faisable simplement |

**Actions** : À voir après MVP fonctionnel

---

## 🎯 5. RECOMMANDATIONS POUR LE SCRIPT

### Stratégie de collecte

1. **Hardware basique (sans sudo)** :
   - ✅ lscpu (avec LC_ALL=C)
   - ✅ free
   - ✅ lspci
   - ✅ lsblk
   - ✅ ip link
   - ✅ /etc/os-release

2. **Hardware avancé (avec sudo optionnel)** :
   - ⚠️ dmidecode (RAM layout, motherboard, BIOS)
   - ⚠️ smartctl (modèle SSD/HDD)
   - ⚠️ ethtool (vitesse réseau)

3. **Gestion des cas** :
   - Si `sudo` non disponible → Collecter infos basiques uniquement
   - Si outil manquant → Retourner `null` pour ce champ
   - Si erreur → Log warning, continuer

### JSON final recommandé

```json
{
  "hardware": {
    "cpu": {
      "vendor": "GenuineIntel",
      "model": "Intel(R) Core(TM) i5-2400 CPU @ 3.10GHz",
      "cores": 4,
      "threads": 4,
      "base_freq_ghz": 3.1,
      "max_freq_ghz": 3.4,
      "cache_l1_kb": 256,
      "cache_l2_kb": 1024,
      "cache_l3_kb": 6144,
      "flags": ["avx", "sse4_1", "sse4_2"]
    },
    "ram": {
      "total_mb": 7771,
      "slots_total": 4,
      "slots_used": 4,
      "ecc": false,
      "layout": [
        {"slot": "DIMM0", "size_mb": 2048, "type": "DDR3", "speed_mhz": 1333, "manufacturer": "Samsung"}
      ]
    },
    "gpu": {
      "vendor": "Intel Corporation",
      "model": "2nd Gen Core Processor Family IGP",
      "vram_mb": null
    },
    "motherboard": {
      "manufacturer": "LENOVO",
      "model": "Unknown",
      "bios_version": "9SKT91AUS",
      "bios_date": "03/30/2012"
    },
    "storage": [
      {"device": "sda", "model": "KINGSTON SA400S37480G", "size_gb": 480, "type": "ssd", "interface": "sata"}
    ],
    "network": [
      {"name": "eno1", "type": "ethernet", "speed_mbps": 1000, "mac": "44:37:e6:6b:53:86"}
    ],
    "os": {
      "name": "debian",
      "version": "13 (trixie)",
      "kernel_version": "6.12.57+deb13-amd64",
      "architecture": "x86_64"
    }
  },
  "results": {
    "cpu": {
      "events_per_sec": 3409.87,
      "duration_s": 10.0005,
      "score": 34.1
    },
    "memory": {
      "throughput_mib_s": 13806.03,
      "score": 69.0
    },
    "disk": {
      "read_mb_s": 711,
      "write_mb_s": 711,
      "iops_read": 177777,
      "iops_write": 177777,
      "latency_ms": 0.002,
      "score": 85.0
    },
    "network": {
      "upload_mbps": 327,
      "download_mbps": 323,
      "ping_ms": 53.1,
      "score": 32.7
    },
    "global_score": 55.2
  }
}
```

---

## ✅ CONCLUSION

**Données ESSENTIELLES déjà disponibles** : ✅
- Benchmarks (CPU, RAM, Disk, Network) → Parsing fonctionne
- Infos basiques (CPU, RAM, OS) → Parsing à corriger (locale)

**Données IMPORTANTES à ajouter** : ⚠️
- CPU détaillé (fréquences, caches, flags)
- RAM détaillée (dmidecode)
- GPU (lspci minimum)
- Storage (lsblk + smartctl)
- Network (ip link + ethtool)

**Données OPTIONNELLES** : 💡
- BIOS
- PCI version
- Température CPU

**Prochaine étape** : Modifier le script bench.sh pour collecter toutes les données NIVEAU 1 et NIVEAU 2
