Ignora benchmark quando si utilizza stable/beta

Question

Ho un file con alcuni benchmark e test e vorrei testare contro stable, beta e nightly. Tuttavia, o non utilizzo il benchmark o la stable/beta si lamentano. C'è un modo per nascondere tutte le parti del benchmark quando si utilizza stable/beta?

Come esempio il seguente codice della book:

#![feature(test)] 

extern crate test; 

pub fn add_two(a: i32) -> i32 { 
    a + 2 
} 

#[cfg(test)] 
mod tests { 
    use super::*; 
    use test::Bencher; 

    #[test] 
    fn it_works() { 
     assert_eq!(4, add_two(2)); 
    } 

    #[bench] 
    fn bench_add_two(b: &mut Bencher) { 
     b.iter(|| add_two(2)); 
    } 
} 

sto usando rustup e vorrei lo stesso file di lavorare con tutte le costruisce, chiamando qualcosa come:

rustup run nightly cargo bench --bin bench --features "bench" 
rustup run nightly cargo test --bin bench --features "bench" 
rustup run beta cargo test --bin bench 
rustup run stable cargo test --bin bench 

Sono stato in grado di nascondere #![feature(test)] con #![cfg_attr(feature = "bench", feature(test))]. Posso fare qualcosa di simile al resto delle parti di riferimento? Qual è una buona risorsa per le feature flag?

Answer 1

Nei miei progetti, ho posto dei benchmark in un modulo separato, proprio come faccio per i test. Quindi creo una funzionalità Carico che consente loro. In questo estratto, ho usato il nome della funzione unstable, ma è possibile utilizzare qualcosa che ti piacerebbe:

Cargo.toml

# ... 

[features] 
unstable = [] 

# ... 

src/lib.rs

#![cfg_attr(feature = "unstable", feature(test))] 

#[cfg(test)] 
mod tests { 
    #[test] 
    fn a_test() { 
     assert_eq!(1, 1); 
    } 
} 

#[cfg(all(feature = "unstable", test))] 
mod bench { 
    extern crate test; 
    use self::test::Bencher; 

    #[bench] 
    fn a_bench(b: &mut Bencher) { 
     let z = b.iter(|| { 
      test::black_box(|| { 
       1 + 1 
      }) 
     }); 
    } 
} 

La riga #[cfg(all(feature = "unstable", test))] dice di compilare solo il seguente elemento se la funzione è impostata e comunque stiamo compilando in modalità test. Allo stesso modo, #![cfg_attr(feature = "unstable", feature(test))] abilita il flag di funzione test solo quando la funzione unstable è abilitata.

Ecco un esempio in the wild.

Answer 2

C'è un modo per nascondere tutte le parti di riferimento quando si utilizza stable/beta?

Sì, ed è possibile farlo utilizzando automaticamente un build script, quindi non è necessario specificare --features durante l'esecuzione del carico. Nello script di build è possibile rilevare la versione del compilatore di Rust e definire una funzionalità (ad esempio "nightly"). Quindi, nel codice sorgente è possibile raggruppare i benchmark e abilitarli se la funzione è stata definita.

Cargo.toml

[package] 
build = "build.rs" 

[features] 
nightly = [] 

[build-dependencies] 
rustc_version = "0.1.*" 

build.rs

extern crate rustc_version; 

use rustc_version::{version_meta, Channel}; 

fn main() { 
    if version_meta().channel == Channel::Nightly { 
     println!("cargo:rustc-cfg=feature=\"nightly\""); 
    } 
} 

src/lib.rs

#![cfg_attr(all(feature = "nightly", test), feature(test))] 

#[cfg(all(feature = "nightly", test))] 
extern crate test; 

pub fn add_two(a: i32) -> i32 { 
    a + 2 
} 

#[cfg(test)] 
mod tests { 
    // tests 
} 

#[cfg(all(feature = "nightly", test))] 
mod benchs { 
    use test::Bencher; 
    // benchs 
} 

Answer 3

Cargo supporta una directory panchine per test di benchmark. Se li metti lì, non puoi mai eseguire "cargo bench" su beta/stable, e farlo girare solo di notte.