Test de vitesse des disques (SSD, USB, SD Card)

Que vous utilisiez un Raspberry Pi, un mini-PC ou un ordinateur de bureau, il est souvent utile de mesurer les performances réelles de ses supports de stockage : SSD, clés USB, cartes SD…
Le script Python présenté ici a été conçu pour effectuer des tests simples mais fiables en lecture et en écriture, et pour afficher un comparatif clair directement dans le terminal.

📌 Les principales fonctionnalités

Ce script permet de :

mesurer la vitesse d’écriture séquentielle d’un disque ;
mesurer la vitesse de lecture séquentielle après avoir vidé les caches mémoire ;
détecter automatiquement les périphériques montés dans les répertoires /media ou /mnt (clés USB, disques externes, cartes SD) ;
afficher un tableau comparatif des résultats, avec un code couleur qui met en avant le périphérique le plus rapide (en vert), le plus lent (en rouge) et les valeurs intermédiaires (en jaune) ;
adapter automatiquement la taille du fichier de test selon l’espace disponible, entre 64 et 512 Mo.

⚙️ Le principe de fonctionnement

Le script suit plusieurs étapes pour obtenir des résultats fiables :

Création d’un fichier temporaire dans chaque répertoire testé (par exemple le SSD système dans /tmp, ou une clé USB montée dans /media).
Test d’écriture en remplissant ce fichier avec des données, ce qui donne la vitesse réelle d’écriture séquentielle.
Vidage des caches mémoire du système afin de ne pas fausser le test de lecture.
Test de lecture du fichier précédemment écrit, ce qui permet de mesurer le débit séquentiel en lecture.
Affichage des résultats dans un tableau clair, avec les couleurs pour repérer immédiatement les meilleurs et les moins bons périphériques.

✅ Exemple de résultat obtenu

Exécuter le script avec sudo

Shell

sudo python speed.py

En fin de test, le script affiche un tableau similaire à celui-ci :

Shell

=== Résultats finaux ===
Périphérique                        Type        Écriture (Mo/s)   Lecture (Mo/s)
——————————————————————————–
SSD système (/)                     SSD              450 Mo/s       520 Mo/s
/dev/sda1 (/media/usb)              USB              120 Mo/s       130 Mo/s
/dev/mmcblk0p1 (/media/sdcard)      SD Card           35 Mo/s        40 Mo/s

Le SSD système atteint environ 450 Mo/s en écriture et 520 Mo/s en lecture.
Une clé USB testée affiche autour de 120 Mo/s en écriture et 130 Mo/s en lecture.
Une carte SD est mesurée à environ 35 Mo/s en écriture et 40 Mo/s en lecture.

Ces chiffres sont donnés à titre d’exemple ; ils varient bien entendu selon la qualité et le type de support utilisé.

🎯 Pourquoi utiliser ce script ?

Ce programme est particulièrement utile pour :

comparer les performances réelles de différents supports de stockage ;
vérifier la qualité d’une carte SD destinée à un Raspberry Pi, afin d’éviter les modèles trop lents ;
mesurer l’impact d’un boîtier USB externe ou d’un adaptateur sur les performances d’un disque ;
obtenir rapidement une mesure claire et lisible, sans avoir à installer d’outils complexes.

📥 Source

Python

#!/usr/bin/env python3
import os
import subprocess
import re
import shutil

# Couleurs terminal
RED = "\033[91m"
GREEN = "\033[92m"
YELLOW = "\033[93m"
RESET = "\033[0m"

def run_cmd(cmd):
    """Exécute une commande shell et retourne la sortie"""
    return subprocess.run(cmd, shell=True, capture_output=True, text=True)

def drop_caches():
    """Vide les caches disque (nécessite sudo)"""
    run_cmd("sync")
    run_cmd("echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null")

def run_dd(cmd):
    """Exécute dd et récupère la vitesse"""
    try:
        result = run_cmd(cmd)
        output = result.stderr + result.stdout
        for line in output.splitlines():
            if "copied" in line and "s" in line:
                return line.split(",")[-1].strip()
    except:
        return "inconnu"
    return "inconnu"

def parse_speed(speed_str):
    """Convertit une vitesse dd en Mo/s"""
    if speed_str == "inconnu":
        return 0
    parts = speed_str.split()
    try:
        value = float(parts[0])
        unit = parts[1].upper()
        if unit.startswith("GB"):
            value *= 1024
        elif unit.startswith("KB"):
            value /= 1024
        return value
    except:
        return 0

def pick_test_size(path):
    """Détermine la taille de fichier à tester (en Mo) selon la capacité du disque"""
    try:
        usage = shutil.disk_usage(path)
        avail_mb = usage.free // (1024 * 1024)
        test_size = max(64, min(avail_mb // 20, 512))  # 5% dispo, min 64MB, max 512MB
        return test_size
    except:
        return 256  # fallback

def test_device(path, use_direct=True):
    test_file = os.path.join(path, "testfile_speed")
    size_mb = pick_test_size(path)
    oflag = "oflag=direct" if use_direct else ""
    iflag = "iflag=direct" if use_direct else ""

    print(f"  → Test avec fichier de {size_mb} Mo")

    # Test écriture
    write_cmd = f"dd if=/dev/zero of={test_file} bs=1M count={size_mb} conv=fsync {oflag} status=progress"
    write_speed = run_dd(write_cmd)

    # Vide les caches avant le test de lecture
    drop_caches()

    # Test lecture
    read_cmd  = f"dd if={test_file} of=/dev/null bs=1M count={size_mb} {iflag} status=progress"
    read_speed  = run_dd(read_cmd)

    try:
        os.remove(test_file)
    except FileNotFoundError:
        pass

    return write_speed, read_speed

def list_external_mounts():
    """Liste périphériques montés sur /media ou /mnt"""
    mounts = []
    with open("/proc/mounts", "r") as f:
        for line in f:
            parts = line.split()
            device, path, fstype = parts[0], parts[1], parts[2]
            if path.startswith("/media") or path.startswith("/mnt"):
                mounts.append((device, path))
    return mounts

def is_sdcard(device):
    return re.match(r"/dev/mmcblk\d+", device) is not None

def main():
    results = []

    # SSD système
    print("Test du SSD système (root)…")
    write, read = test_device("/tmp", use_direct=False)
    results.append(("SSD système (/)", write, read, "SSD"))

    # Périphériques externes USB / SD
    external_mounts = list_external_mounts()
    for dev, path in external_mounts:
        print(f"Test de {dev} monté sur {path} …")
        kind = "SD Card" if is_sdcard(dev) else "USB"
        write, read = test_device(path, use_direct=True)
        results.append((f"{dev} ({path})", write, read, kind))

    # Tableau comparatif
    print("\n=== Résultats finaux ===")
    print(f"{'Périphérique':40} {'Type':10} {'Écriture (Mo/s)':>15} {'Lecture (Mo/s)':>15}")
    print("-"*85)

    write_vals = [parse_speed(w) for _, w, _, _ in results]
    read_vals  = [parse_speed(r) for _, _, r, _ in results]
    max_w, min_w = max(write_vals), min(write_vals)
    max_r, min_r = max(read_vals), min(read_vals)

    for name, w, r, kind in results:
        w_val, r_val = parse_speed(w), parse_speed(r)
        w_color = GREEN if w_val == max_w else RED if w_val == min_w else YELLOW
        r_color = GREEN if r_val == max_r else RED if r_val == min_r else YELLOW
        print(f"{name:40} {kind:10} {w_color}{w:>15}{RESET} {r_color}{r:>15}{RESET}")

if __name__ == "__main__":
    main()

Grimeco

Test de vitesse des disques (SSD, USB, SD Card)

📌 Les principales fonctionnalités

⚙️ Le principe de fonctionnement

✅ Exemple de résultat obtenu

🎯 Pourquoi utiliser ce script ?

📥 Source

A DECOUVRIR EGALEMENT

Raspberry Radio Internet (Partie II)

🖧 Activer le Wi-Fi sur un Asus X205TA sous Debian 11

Reconnaissance vocale et synthèse de parole

Laisser un commentaire Annuler la réponse