IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Rust Discussion :

Rust 1.63 est disponible et s'accompagne des fils d'exécution délimités


Sujet :

Rust

  1. #1
    Chroniqueur Actualités
    Avatar de Bruno
    Homme Profil pro
    Rédacteur technique
    Inscrit en
    mai 2019
    Messages
    1 138
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Rédacteur technique
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : mai 2019
    Messages : 1 138
    Points : 22 976
    Points
    22 976
    Par défaut Rust 1.63 est disponible et s'accompagne des fils d'exécution délimités
    Rust 1.63 est disponible et s'accompagne des fils d'exécution délimités,
    des propriété Rust pour les descripteurs de fichiers

    L'équipe Rust a annoncé la disponibilité de Rust 1.63, elle apporte un code Codes exit personnalisés de main, plus de possibilités pour les const fn et Manipulations statiques pour stdio verrouillé, « L'équipe Rust est heureuse d'annoncer une nouvelle version de Rust, 1.63. Rust est un langage de programmation qui permet à chacun de construire des logiciels fiables et efficaces », a déclaré l’équipe Rust.

    Nom : Rust2B.png
Affichages : 3702
Taille : 20,2 Ko

    Rappelons que Rust est un langage de programmation compilé multiparadigme, conçu par Graydon Hore alors employé chez Mozilla Research, avec la contribution du créateur de JavaScript Brendan Eich. Utilisé par plusieurs grandes entreprises et par de nombreux développeurs dans le monde, Rust est devenu le langage de base pour certaines des fonctionnalités fondamentales du navigateur Firefox et de son moteur Gecko, ainsi que pour le moteur Servo de Mozilla.

    Voici, ci-dessous, les nouveautés apportées par la version 1.63 de Rust :

    Fils d'exécution délimités

    Le code Rust peut lancer de nouveaux threads avec std::thread::spawn depuis la version 1.0, mais cette fonction délimite sa fermeture avec "static". En gros, cela signifie que les threads doivent actuellement avoir la propriété de tous les arguments passés dans leur fermeture ; vous ne pouvez pas passer de données empruntées dans un thread. Dans les cas où l'on s'attend à ce que les threads sortent à la fin de la fonction (en étant join()'d), cela n'est pas strictement nécessaire et peut nécessiter des solutions de contournement comme le placement des données dans un Arc.

    Maintenant, avec la version 1.63.0, la bibliothèque standard ajoute les threads scopés, qui permettent de créer un thread empruntant le cadre de la pile locale. L'API std::thread::scope fournit la garantie nécessaire que tous les threads engendrés seront sortis avant que lui-même ne revienne, ce qui permet d'emprunter des données en toute sécurité. Voici un exemple :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    let mut a = vec![1, 2, 3];
    let mut x = 0;
     
    std::thread::scope(|s| {
        s.spawn(|| {
            println!("hello from the first scoped thread");
            // We can borrow `a` here.
            dbg!(&a);
        });
        s.spawn(|| {
            println!("hello from the second scoped thread");
            // We can even mutably borrow `x` here,
            // because no other threads are using it.
            x += a[0] + a[2];
        });
        println!("hello from the main thread");
    });
     
    // After the scope, we can modify and access our variables again:
    a.push(4);
    assert_eq!(x, a.len());

    Propriété Rust pour les descripteurs de fichiers/manches bruts (sécurité des E/S)

    Auparavant, le code Rust travaillant avec des APIs de plateforme prenant des descripteurs de fichiers bruts (sur les plateformes de type unix) ou des handles (sur Windows) travaillait généralement directement avec une représentation du descripteur spécifique à la plateforme (par exemple, un c_int, ou l'alias RawFd). Pour les liaisons Rust à de telles API natives, le système de types n'arrivait pas à coder si l'API prenait la propriété du descripteur de fichier (par exemple, close) ou l'empruntait simplement (par exemple, dup).

    Maintenant, Rust fournit des types enveloppants tels que BorrowedFd et OwnedFd, qui sont marqués comme #[repr(transparent)], ce qui signifie que les liaisons externes "C" peuvent directement prendre ces types pour encoder la sémantique de propriété. Voir la section API stabilisées pour la liste complète des types de wrapper stabilisés dans la 1.63. Actuellement, ils sont disponibles sur les plateformes cfg(unix), Windows et WASI.

    l’équipe Rust recommande que les nouvelles API utilisent ces types au lieu des alias de types précédents (comme RawFd).

    Initialisation des constantes Mutex, RwLock, Condvar

    Les fonctions Condvar::new, Mutex::new, et RwLock::new sont maintenant appelables dans des contextes const, ce qui permet d'éviter l'utilisation de crates comme lazy_static pour créer des statiques globales avec des valeurs Mutex, RwLock, ou Condvar. Ceci s'appuie sur le travail effectué dans la 1.62 pour permettre des mutex plus fins et plus rapides sous Linux.

    Turbofish pour les génériques dans les fonctions avec impl Trait

    Pour une signature de fonction comme fn foo(value : T, f : impl Copy), c'était une erreur de spécifier le type concret de T via turbofish : foo::(3, 3) échouerait avec :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    error[E0632]: cannot provide explicit generic arguments when `impl Trait` is used in argument position
     --> src/lib.rs:4:11
      |
    4 |     foo::<u32>(3, 3);
      |           ^^^ explicit generic argument not allowed
      |
      = note: see issue #83701 <https://github.com/rust-lang/rust/issues/83701> for more information

    Dans la version 1.63, cette restriction est assouplie et le type explicite du générique peut être spécifié. Cependant, le paramètre impl Trait, bien qu'il soit désugarisé vers un générique, reste opaque et ne peut pas être spécifié via le turbofish.


    La migration des durées de vie non-lexicales est terminée

    Comme détaillé dans ce billet de blog, léquipe Rust a entièrement supprimé l'ancien vérificateur d'emprunts lexicaux de rustc dans toutes les éditions, en activant entièrement la nouvelle version non-lexicale du vérificateur d'emprunts. Comme le vérificateur d'emprunts n'affecte pas la sortie de rustc, cela ne changera pas le comportement des programmes, mais cela termine une migration de longue haleine (commencée lors de la stabilisation initiale de NLL pour l'édition 2018) pour offrir tous les avantages du nouveau vérificateur d'emprunts dans toutes les éditions de Rust. Pour la plupart des utilisateurs, ce changement apportera des diagnostics légèrement meilleurs pour certaines erreurs de vérification d'emprunt, mais n'aura pas d'autre impact sur le code qu'ils peuvent écrire.

    API stabilisées

    Les méthodes et implémentations de traits suivantes sont maintenant stabilisées :

    • array::from_fn
    • Box::into_pin
    • BinaryHeap::try_reserve
    • BinaryHeap::try_reserve_exact
    • OsString::try_reserve
    • OsString::try_reserve_exact
    • PathBuf::try_reserve
    • PathBuf::try_reserve_exact
    • Path::try_exists
    • Ref::filter_map
    • RefMut::filter_map
    • NonNull::<[T]>::len
    • ToOwned::clone_into
    • Ipv6Addr::to_ipv4_mapped
    • unix::io::AsFd
    • unix::io::BorrowedFd<'fd>
    • unix::io::OwnedFd
    • windows::io::AsHandle
    • windows::io::BorrowedHandle<'handle>
    • windows::io::OwnedHandle
    • windows::io::HandleOrInvalid
    • windows::io::HandleOrNull
    • windows::io::InvalidHandleError
    • windows::io::NullHandleError
    • windows::io::AsSocket
    • windows::io::BorrowedSocket<'handle>
    • windows::io::OwnedSocket
    • thread::scope
    • thread::Scope
    • thread::ScopedJoinHandle

    Ces API sont désormais utilisables dans des contextes de contrainte :

    • array::from_ref
    • slice::from_ref
    • intrinsics::copy
    • intrinsics::copy_nonoverlapping
    • <*const T>::copy_to
    • <*const T>::copy_to_nonoverlapping
    • <*mut T>::copy_to
    • <*mut T>::copy_to_nonoverlapping
    • <*mut T>::copy_from
    • <*mut T>::copy_from_nonoverlapping
    • str::from_utf8
    • Utf8Error::error_len
    • Utf8Error::valid_up_to
    • Condvar::new
    • Mutex::new
    • RwLock::new

    Source : Rust

    Et vous ?

    Quel est votre avis sur le sujet ?

    Voir aussi :

    Facebook rejoint AWS, Huawei, Google, Microsoft et Mozilla dans la Fondation Rust et renforce son équipe Rust par des nouveaux talents

    Microsoft annonce Rust preview pour Windows, alors que la comparaison entre Rust et C++ reste un sujet d'actualité

    Microsoft, Google, AWS, Huawei et Mozilla s'associent pour créer la Fondation Rust, une organisation à but non lucratif chargée de gérer le langage de programmation

    Rust 1.53.0 est disponible et s'accompagne de IntoIterator pour les tableaux, Cargo prend désormais en charge les référentiels git où la branche HEAD par défaut n'est pas "master"
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

  2. #2
    Expert confirmé
    Avatar de Pyramidev
    Homme Profil pro
    Développeur
    Inscrit en
    avril 2016
    Messages
    1 341
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : avril 2016
    Messages : 1 341
    Points : 5 600
    Points
    5 600
    Par défaut
    L'utilisation de std::thread::scope permet de pratiquer la programmation concurrente structurée, un paradigme qui est très bien expliqué dans un excellent article de Nathaniel J. Smith : Notes on structured concurrency, or: Go statement considered harmful.

    C'est un plaisir que Rust le supporte enfin directement dans la bibliothèque standard ! 🥳

    Je viens de tester std::thread::scope en modifiant quelques POC sur mon PC, dont un code adapté du projet du chapitre 20 du Rust Book.

    J'ai pu effectivement me débarrasser de Arc. En contrepartie, le code est plus volumineux. Par exemple, j'ai dû passer un objet s: &'scope Scope<'scope, 'env> de paramètre en paramètre, avec les durées de vie qui vont avec.

  3. #3
    Expert éminent sénior Avatar de Uther
    Homme Profil pro
    Tourneur Fraiseur
    Inscrit en
    avril 2002
    Messages
    4 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Tourneur Fraiseur

    Informations forums :
    Inscription : avril 2002
    Messages : 4 481
    Points : 14 759
    Points
    14 759
    Par défaut
    En effet, au début il y avait un autre système de scoped thread plus simple de prévu, mais il a été abandonné avant la version 1.0 car il dépendait pour sa sécurité sur le fait que les objets étaient systématiquement libérés, ce que Rust ne garantit pas : on peut par exemple faire des cycles de Rc ou utiliser des fonctions comme Box::leak().

Discussions similaires

  1. Réponses: 0
    Dernier message: 01/07/2022, 15h26
  2. Réponses: 0
    Dernier message: 18/06/2021, 21h33
  3. Réponses: 0
    Dernier message: 12/02/2021, 09h35
  4. Réponses: 1
    Dernier message: 08/10/2020, 23h20
  5. Réponses: 0
    Dernier message: 28/08/2020, 15h17

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo