vendor/unic-langid-impl/benches/likely_subtags.rs

   1 use criterion::black_box;
   2 use criterion::criterion_group;
   3 use criterion::criterion_main;
   4 use criterion::Criterion;
   5
   6 use tinystr::{TinyStr4, TinyStr8};
   7 use unic_langid_impl::LanguageIdentifier;
   8
   9 static STRINGS: &[&str] = &[
  10     "en-US",
  11     "en-GB",
  12     "es-AR",
  13     "it",
  14     "zh-Hans-CN",
  15     "de-AT",
  16     "pl",
  17     "fr-FR",
  18     "de-AT",
  19     "sr-Cyrl-SR",
  20     "nb-NO",
  21     "fr-FR",
  22     "mk",
  23     "uk",
  24     "und-PL",
  25     "und-Latn-AM",
  26     "ug-Cyrl",
  27     "sr-ME",
  28     "mn-Mong",
  29     "lif-Limb",
  30     "gan",
  31     "zh-Hant",
  32     "yue-Hans",
  33     "unr",
  34     "unr-Deva",
  35     "und-Thai-CN",
  36     "ug-Cyrl",
  37     "en-Latn-DE",
  38     "pl-FR",
  39     "de-CH",
  40     "tuq",
  41     "sr-ME",
  42     "ng",
  43     "klx",
  44     "kk-Arab",
  45     "en-Cyrl",
  46     "und-Cyrl-UK",
  47     "und-Arab",
  48     "und-Arab-FO",
  49 ];
  50
  51 fn maximize_bench(c: &mut Criterion) {
  52     c.bench_function("maximize", move |b| {
  53         b.iter(|| {
  54             let langids: Vec<LanguageIdentifier> = STRINGS
  55                 .iter()
  56                 .map(|s| -> LanguageIdentifier { s.parse().unwrap() })
  57                 .collect();
  58             for mut s in langids {
  59                 s.maximize();
  60                 let _ = black_box(s.to_string());
  61             }
  62         })
  63     });
  64 }
  65
  66 fn extract_input(s: &str) -> (Option<TinyStr8>, Option<TinyStr4>, Option<TinyStr4>) {
  67     let chunks: Vec<&str> = s.split("-").collect();
  68     let mut lang: Option<TinyStr8> = chunks.get(0).map(|s| s.parse().unwrap());
  69     let mut script: Option<TinyStr4> = chunks.get(1).map(|s| s.parse().unwrap());
  70     let mut region: Option<TinyStr4> = chunks.get(2).map(|s| s.parse().unwrap());
  71     if let Some(l) = lang {
  72         if l.as_str() == "und" {
  73             lang = None;
  74         }
  75     }
  76     if let Some(s) = script {
  77         if s.as_str().chars().count() == 2 {
  78             region = script;
  79             script = None;
  80         }
  81     }
  82     (lang, script, region)
  83 }
  84
  85 fn raw_maximize_bench(c: &mut Criterion) {
  86     let entries: Vec<(Option<TinyStr8>, Option<TinyStr4>, Option<TinyStr4>)> =
  87         STRINGS.iter().map(|s| extract_input(s)).collect();
  88
  89     c.bench_function("raw_maximize", move |b| {
  90         b.iter(|| {
  91             for (lang, script, region) in &entries {
  92                 let _ = unic_langid_impl::likelysubtags::maximize(
  93                     lang.clone(),
  94                     script.clone(),
  95                     region.clone(),
  96                 );
  97             }
  98         })
  99     });
 100 }
 101
 102 criterion_group!(benches, maximize_bench, raw_maximize_bench,);
 103 criterion_main!(benches);