Bonjour à tous et toutes,
Je constate qu'il n'y a pas foule qui utilise Rust. SVP ne vous bousculez pas pour me répondre.
J'ai un très bon tuto sur Rust mais la documentation est plutôt compliquée. En tout cas, j'ai de la difficulté à trouver ce que je veux.
On fait aussi souvent référence à GITHub que je ne connais pas.
Ma question présente est de calculer le temps d'exécution comme clock() en C ou perf_counter() en Python.
Pourriez-vous me donner la recette ou un meilleur truc pour trouver cette info dans la doc?
Merci pour toute réponse.

Au moins une personne :

use std::time::Instant;
....
// Dans ta fonction 
 let now = Instant::now();
....
...
// à la fin de l'exécution
let elapsed = now.elapsed();
println!(duree: {:.2?}", elapsed);

Ça fonctionne très bien dans mes programmes
PS J'ai mal lu ta question :  la doc rust est très pénible à consulter au début, j'ai pas mal fouillé avent de trouver. Le langage évolue beaucoup et certaines info étaient valables lorsqu'elles ont été publiées puis sont devenues obsolètes après modif des libs (ou autres) de Rust.

-
Edité par joel76 12 juillet 2024 à 10:03:19

Je te remercie pour l'information. Ça fonctionne parfaitement sur mon ordi également.

-

use std::time::Instant;
fn main() {
 let now = Instant::now();
let mut n: u64 = 0;
for _ in 0..1000000000 {
n += 1;
}
let elapsed = now.elapsed();
println!("duree: {:.3?}", elapsed);
println!("{}", n);
}

-

Sans optimisation, je passe en environ 580 ms et avec optimisation, c'est plutôt environ 200000 ns ...

-
Edité par PierrotLeFou 12 juillet 2024 à 19:59:49

Faudra que je fasse d'autres tests, mais le temps d'exécution dans certains cas est plus lent que pour C.

La sécurité, ça se paie ...

Tu as mis les options d'optimisation de rust ?

Voici un lien qui pourrait t'intéresser : https://doc.rust-lang.org/rustc/command-line-arguments.html

Regarde à  -O: optimize your code

Ce que je viens de constater est que la fonction clock() de C n'est plus précise quand les temps s'approchent de la milliseconde.

En faisant des tests sur des ensembles plus grands, C et Rust sont comparables.

Je te remercie pour les liens. Je vais y jeter un coup d'oeil très attentif.

> Faudra que je fasse d'autres tests, mais le temps d'exécution dans certains cas est plus lent que pour C. > La sécurité, ça se paie ...

Sur des micros benchmark, les sécurités qu'apporte rust est qui rend difficile certaines optimisations difficile ne se verront justement pas parce qu'on ne tombe pas dessus dans un microbench.

Et dans ton code comme au-dessus, ce qui est mesurer n'est que l'appel de now.elapsed: la boucle est dégagée par le compilateur. En C++ les frameworks de test comme nanobench ou google.benchmark passent par des fonctions pour ne pas optimiser le résultat des variables. Il faut faire de même en rust avec std::hint::black_box ou équivalent.

Sans être vraiment compliqué, le code que j'ai testé est moins simple que celui donné ci-haut.

Il s'agit d'utiliser le crible d'Ératosthène pour trouver et compter les nombres premiers jusqu'à 100 millions.

On est dans les 840-880 ms.

Je met ici le lien suivant:

https://doc.rust-lang.org/std/hint/fn.black_box.html

Il y a beaucoup de choses que je devrai encore apprendre en Rust, mais le langage me plait.