Optimize Table::allows_code_point

Author: yescallop

bench/benches/bench.rs

@@ -13,15 +13,17 @@ criterion_group!(
     bench_parse_uri,
     bench_parse_iri,
     bench_build,
-    bench_normalize,
+    bench_normalize_uri,
+    bench_normalize_iri,
     bench_resolve,
     bench_top100,
 );
 criterion_main!(benches);
 
 const PARSE_URI_CASE: &str = "https://user@example.com/search?q=%E6%B5%8B%E8%AF%95#fragment";
 const PARSE_IRI_CASE: &str = "https://用户@测试.com/search?q=我们测试解析IRI#fragment";
-const NORMALIZE_CASE: &str = "eXAMPLE://a/./b/../b/%63/%7bfoo%7d";
+const NORMALIZE_URI_CASE: &str = "eXAMPLE://a/./b/../b/%63/%7bfoo%7d";
+const NORMALIZE_IRI_CASE: &str = "https://%E7%94%A8%E6%88%B7@%E6%B5%8B%E8%AF%95.com/search?q=%E6%88%91%E4%BB%AC%E6%B5%8B%E8%AF%95%E8%A7%A3%E6%9E%90IRI#fragment";
 const RESOLVE_CASE_BASE: &str = "http://example.com/foo/bar/baz/quz";
 const RESOLVE_CASE_REF: &str = "../../../qux/./quux/../corge";
 
@@ -89,11 +91,23 @@ fn bench_build(c: &mut Criterion) {
     group.finish();
 }
 
-fn bench_normalize(c: &mut Criterion) {
-    let r_fluent = Uri::parse(NORMALIZE_CASE).unwrap();
-    let r_iri = UriStr::new(NORMALIZE_CASE).unwrap();
+fn bench_normalize_uri(c: &mut Criterion) {
+    let r_fluent = Uri::parse(NORMALIZE_URI_CASE).unwrap();
+    let r_iri = UriStr::new(NORMALIZE_URI_CASE).unwrap();
 
-    let mut group = c.benchmark_group("normalize");
+    let mut group = c.benchmark_group("normalize-uri");
+    group.bench_function("fluent-uri", |b| b.iter(|| r_fluent.normalize()));
+    group.bench_function("iri-string", |b| {
+        b.iter(|| r_iri.normalize().to_dedicated_string())
+    });
+    group.finish();
+}
+
+fn bench_normalize_iri(c: &mut Criterion) {
+    let r_fluent = Iri::parse(NORMALIZE_IRI_CASE).unwrap();
+    let r_iri = IriStr::new(NORMALIZE_IRI_CASE).unwrap();
+
+    let mut group = c.benchmark_group("normalize-iri");
     group.bench_function("fluent-uri", |b| b.iter(|| r_fluent.normalize()));
     group.bench_function("iri-string", |b| {
         b.iter(|| r_iri.normalize().to_dedicated_string())

bench/result.txt

@@ -4,10 +4,10 @@ parse-uri/fluent-uri    time:   [54.553 ns 54.789 ns 55.067 ns]
 parse-uri/iref          time:   [109.68 ns 110.15 ns 110.64 ns]
 parse-uri/iri-string    time:   [137.27 ns 138.20 ns 139.19 ns]
 
-parse-iri/fluent-uri    time:   [73.795 ns 74.449 ns 75.264 ns]
-parse-iri/iref          time:   [130.43 ns 131.37 ns 132.46 ns]
-parse-iri/iri-string    time:   [156.71 ns 158.12 ns 159.70 ns]
-parse-iri/oxiri         time:   [116.23 ns 117.85 ns 119.68 ns]
+parse-iri/fluent-uri    time:   [65.470 ns 65.827 ns 66.212 ns]
+parse-iri/iref          time:   [126.40 ns 127.42 ns 128.59 ns]
+parse-iri/iri-string    time:   [149.28 ns 150.21 ns 151.20 ns]
+parse-iri/oxiri         time:   [107.25 ns 107.73 ns 108.27 ns]
 
 build/fluent-uri        time:   [199.80 ns 201.46 ns 203.59 ns]
 build/iri-string        time:   [378.34 ns 381.28 ns 384.42 ns]
@@ -23,11 +23,11 @@ parse-top100/iri-string time:   [19.908 ms 20.010 ms 20.118 ms]
 parse-top100/iref       time:   [22.702 ms 22.790 ms 22.885 ms]
 
 parse-iri-top100/fluent-uri
-                        time:   [9.8868 ms 10.029 ms 10.221 ms]
+                        time:   [9.6033 ms 9.6497 ms 9.7035 ms]
 parse-iri-top100/iri-string
-                        time:   [19.857 ms 19.970 ms 20.093 ms]
-parse-iri-top100/iref   time:   [32.623 ms 32.762 ms 32.912 ms]
-parse-iri-top100/oxiri  time:   [28.590 ms 28.871 ms 29.196 ms]
+                        time:   [19.762 ms 20.074 ms 20.457 ms]
+parse-iri-top100/iref   time:   [31.735 ms 31.863 ms 32.005 ms]
+parse-iri-top100/oxiri  time:   [27.149 ms 27.287 ms 27.438 ms]
 
 parse-normalize-top100/fluent-uri
                         time:   [24.766 ms 24.897 ms 25.039 ms]

src/pct_enc/table.rs

@@ -112,18 +112,18 @@ impl Table {
         self.0 & (MASK_UCSCHAR | MASK_IPRIVATE) != 0
     }
 
+    #[inline]
     pub(crate) const fn allows_code_point(self, x: u32) -> bool {
         if x < 128 {
-            let table = if x < 64 {
-                self.0 & MASK_UNENCODED_ASCII
-            } else {
-                self.1
-            };
-            table & 1u64.wrapping_shl(x) != 0
-        } else {
-            (self.0 & MASK_UCSCHAR != 0 && is_ucschar(x))
-                || (self.0 & MASK_IPRIVATE != 0 && is_iprivate(x))
+            return self.allows_ascii(x as u8);
+        }
+        if self.0 & MASK_UCSCHAR != 0 && is_ucschar(x) {
+            return true;
+        }
+        if self.0 & MASK_IPRIVATE != 0 && is_iprivate(x) {
+            return true;
         }
+        false
     }
 
     /// Checks whether the given unencoded character is allowed by the table.