L'analyse comparative des programmes dans la Rouille

Comment est-il possible de comparer les programmes de la Rouille? Par exemple, comment pourrais-je obtenir le temps d'exécution du programme en quelques secondes?

InformationsquelleAutor php-- | 2012-11-10
  1. 11

    Vous pouvez essayer de timing de composants individuels à l'intérieur du programme à l'aide de la le temps de cage.

    • J'aime particulièrement precise_time_ns et precise_time_s.
    • Le time la caisse est maintenant apparemment obsolète.
    InformationsquelleAutor Kevin Cantu
  2. 81

    Il pourrait être intéressant de noter 2 ans plus tard (pour aider à l'avenir toute la Rouille programmeurs qui trébuchent sur cette page) il y a maintenant des outils de référence de la Rouille du code en tant que partie d'une suite de test.

    (Dans le guide du lien ci-dessous) à l'Aide de la #[bench] attribut, on peut utiliser la norme de la Rouille de l'outillage pour les méthodes de référence dans leur code.

    extern crate test;
use test::Bencher;

#[bench]
fn bench_xor_1000_ints(b: &mut Bencher) {
    b.iter(|| {
        //use `test::black_box` to prevent compiler optimizations from disregarding
        //unused values
        test::black_box(range(0u, 1000).fold(0, |old, new| old ^ new));
    });
}

    Pour la commande cargo bench ce sorties quelque chose comme:

    running 1 test
test bench_xor_1000_ints ... bench:       375 ns/iter (+/- 148)

test result: ok. 0 passed; 0 failed; 0 ignored; 1 measured

    Liens:

    • Celui-ci, apparemment, s'en va. Je suis toujours à la recherche de ce que je devrais utiliser.
    • Pourquoi pensez-vous que ce qui se passe loin, exactement?
    • Le lien pour le livre devrait être maintenant de ce qu'on appelle la "Nuit du livre": doc.rust-lang.org/nightly/unstable-book/library-features/...
    • Remarque: la version actuelle de l'Athlète est marqué instable et pas utilisable de la stabilité de la Rouille. C'est actuellement uniquement disponible dans la version nightly.
    InformationsquelleAutor Michael Tang
  3. 39

    Si vous voulez simplement le temps d'un morceau de code, vous pouvez utiliser le temps caisse. le temps en attendant obsolète, cependant. Un suivi caisse est chrono.

    Ajouter time = "*" à votre Cargo.toml.

    Ajouter 

    extern crate time;
use time::PreciseTime;

    avant votre fonction principale et

    let start = PreciseTime::now();
//whatever you want to do
let end = PreciseTime::now();
println!("{} seconds for whatever you did.", start.to(end));

    Exemple complet

    De fret.toml

    [package]
name = "hello_world" # the name of the package
version = "0.0.1"    # the current version, obeying semver
authors = [ "[email protected]" ]
[[bin]]
name = "rust"
path = "rust.rs"
[dependencies]
rand = "*" # Or a specific version
time = "*"

    la rouille.rs

    extern crate rand;
extern crate time;

use rand::Rng;
use time::PreciseTime;

fn main() {
    //Creates an array of 10000000 random integers in the range 0 - 1000000000
    //let mut array: [i32; 10000000] = [0; 10000000];
    let n = 10000000;
    let mut array = Vec::new();

    //Fill the array
    let mut rng = rand::thread_rng();
    for _ in 0..n {
        //array[i] = rng.gen::<i32>();
        array.push(rng.gen::<i32>());
    }

    //Sort
    let start = PreciseTime::now();
    array.sort();
    let end = PreciseTime::now();

    println!("{} seconds for sorting {} integers.", start.to(end), n);
}
    • Le time la caisse est maintenant apparemment obsolète.
    • Le chrono la caisse est probablement ce que vous recherchez, à la suite de la dépréciation de la time caisse. * Ne pas confondre time caisse avec le std::time module de la bibliothèque standard
    InformationsquelleAutor Martin Thoma
  4. 13

    Pour le calendrier de tests que vous pouvez utiliser std::temps::Instantanée

    fn my_function() {
    use std::time::Instant;
    let now = Instant::now();

    {
        my_function_to_measure();
    }

    let elapsed = now.elapsed();
    let sec = (elapsed.as_secs() as f64) + (elapsed.subsec_nanos() as f64 / 1000_000_000.0);
    println!("Seconds: {}", sec);
}

fn main() {
    my_function();
}

    Bien sûr, si vous avez fait cela souvent, vous voulez généraliser la conversion, ou l'utilisation d'une caisse qui fournit des utilitaires pour cela, ou de la pellicule Instant et Duration dans vos propres fonctions de sorte qu'ils peuvent être écrits dans moins verbeux.

    • Depuis std::time::SystemTime n'est pas garanti d'être de plus en plus monotone, il n'est pas le meilleur choix pour l'analyse comparative. Pour ce cas d'utilisation, il est préférable d'utiliser la fonction monotone std::time::Instant.
    • Mis à jour pour une utilisation Instantanée.
    • Est-il aussi précis que time cage precise_time_ns?
    InformationsquelleAutor ideasman42
  5. 7

    Un moyen rapide de savoir le temps d'exécution d'un programme, indépendamment de la mise en œuvre de la langue, est d'exécuter time prog sur la ligne de commande. Par exemple:

    ~$ time sleep 4

real    0m4.002s
user    0m0.000s
sys     0m0.000s

    Les plus intéressants de mesure est généralement user, qui mesure le montant réel du travail effectué par le programme, peu importe ce qui se passe dans le système (sleep est assez ennuyeux programme de référence). real mesures le temps réel écoulé, et sys mesures de la quantité de travail effectué par le système d'exploitation pour le compte du programme.

    • Cela suppose que vous êtes seulement période d'application de la totalité de l'exécution, parfois, vous voulez le temps spesific étapes de trop, surtout si le programme est interactif.
    InformationsquelleAutor Paul Stansifer
  6. 5

    Actuellement, il n'y a pas d'interface à Linux fonctions:

    • clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts)
    • getrusage
    • times (page de manuel: man 2 times)

    Les méthodes disponibles pour mesurer le temps de calcul et les points chauds de la Rouille programme sur Linux sont:

    • /usr/bin/time program
    • perf stat program
    • perf record --freq 100000 program; perf report
    • valgrind --tool=callgrind program; kcachegrind callgrind.out.*

    La sortie de perf report et valgrind dépend de la disponibilité des informations de débogage dans le programme. Il peut ne pas fonctionner.

    InformationsquelleAutor
  7. 2

    J'ai créé une petite caisse pour les ce (measure_time), dont les journaux ou imprime le temps jusqu'à la fin de la portée.

    #[macro_use]
extern crate measure_time;
fn main() {
    print_time!("measure function");
    do_stuff();
}
    InformationsquelleAutor Pascalius