Rayon pour Rust : guide complet avec exemples

Qu'est-ce que Rayon et pourquoi en a-t-on besoin ?

Rayon est une puissante bibliothèque pour le langage de programmation Rust, qui offre un moyen simple et sûr de paralléliser les calculs. Sa principale caractéristique est le concept d'itérateurs parallèles. Au lieu de gérer manuellement les threads, les mutex et les canaux, il vous suffit de remplacer un itérateur séquentiel (`.iter()`) par un itérateur parallèle (`.par_iter()`), et Rayon distribue automatiquement le travail sur tous les cœurs du processeur disponibles.

Pourquoi cette bibliothèque est-elle nécessaire ? Dans le monde moderne, les processeurs multicœurs sont devenus la norme. Cependant, écrire du code multithread manuellement est une tâche complexe, source de courses de données, d'interblocages et d'autres erreurs difficiles à détecter. Rayon prend en charge toutes ces complexités, en offrant :

\n
• Distribution automatique du travail : La bibliothèque décide elle-même comment diviser les données en parties et les répartir entre les threads.
\n
• Sécurité au niveau des types : Grâce au système de possession et d'emprunt de Rust, Rayon garantit l'absence de courses de données dès la phase de compilation.
\n
• Vol de travail (Work-stealing) : Si un thread termine sa tâche avant les autres, il "vole" du travail aux threads occupés, assurant une charge uniforme de tous les cœurs.
\n
• Simplicité d'utilisation : L'API de Rayon est intuitive pour tout développeur familier avec les itérateurs de Rust.
\n

Rayon est idéal pour les tâches nécessitant le traitement de grands volumes de données : traitement d'images, simulations, calculs numériques, analyse de fichiers et bien plus encore. Si votre tâche se divise facilement en sous-tâches indépendantes (parallélisme de données), Rayon est votre choix.

Installation

Rayon s'installe de manière standard pour Rust – via le gestionnaire de paquets Cargo. Ajoutez la ligne suivante dans le fichier Cargo.toml de votre projet :

[dependencies]\nrayon = "1.10"

Ensuite, exécutez la commande cargo build, et Cargo téléchargera et compilera automatiquement la bibliothèque. Rayon est une bibliothèque "pure" Rust, donc aucune dépendance supplémentaire ou exigence système n'est nécessaire. Elle fonctionne sur Windows, macOS et Linux.

Démarrage rapide

Commençons par un exemple classique : la somme d'un grand tableau de nombres. Faisons-le d'abord de manière séquentielle, puis en parallèle avec Rayon.

// On importe la bibliothèque\nuse rayon::prelude::*;\n\nfn main() {\n    // On crée un grand vecteur de nombres\n    let numbers: Vec<u64> = (1..=10_000_000).collect();\n\n    // --- Somme séquentielle ---\n    let sequential_start = std::time::Instant::now();\n    let sum_sequential: u64 = numbers.iter().sum();\n    let sequential_duration = sequential_start.elapsed();\n    println!("Somme séquentielle : {} (temps : {:?})", sum_sequential, sequential_duration);\n\n    // --- Somme parallèle avec Rayon ---\n    let parallel_start = std::time::Instant::now();\n    let sum_parallel: u64 = numbers.par_iter().sum(); // On a remplacé .iter() par .par_iter()\n    let parallel_duration = parallel_start.elapsed();\n    println!("Somme parallèle : {} (temps : {:?})", sum_parallel, parallel_duration);\n\n    // Comparaison de l'accélération\n    println!("Accélération : {:.2}x", sequential_duration.as_secs_f64() / parallel_duration.as_secs_f64());\n}

Dans cet exemple, nous n'avons fait qu'un seul changement : remplacer .iter() par .par_iter(). Rayon a automatiquement divisé le vecteur en parties, les a réparties entre les threads, a calculé les sommes partielles, puis a combiné les résultats. Sur un processeur multicœur, vous constaterez une accélération significative.

Méthodes/Fonctions principales

1. par_iter()

Ce qu'elle fait : Crée un itérateur parallèle à partir de références aux éléments d'une collection. C'est la méthode la plus