Remove FlexZeroVec

unicode-org · Oct 2, 2024 · c759ff2 · c759ff2
1 parent d983fc9
commit c759ff2
Show file tree

Hide file tree

Showing 17 changed files with 31 additions and 1,923 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -47,6 +47,7 @@
         - Change the `VarZeroVecFormat` values shipped by default to use the same index and length width. This breaks data layout for all `VarZeroVec`s. (https://github.com/unicode-org/icu4x/pull/5594)
         - Change the `VarZeroVec` format to not store a superfluous 0 index at the beginning of the index array. This breaks data layout for all `VarZeroVec`s (https://github.com/unicode-org/icu4x/pull/5601)
         - Optimize `MultiFieldsULE` to not store a length anymore. This breaks data layout for any `#[make_varule]`-using struct with multiple variable-sized fields. (https://github.com/unicode-org/icu4x/pull/5593)
+      - Remove `FlexZeroVec` (https://github.com/unicode-org/icu4x/pull/5604)
     - `writeable`
 
 

diff --git a/utils/potential_utf/src/ustr.rs b/utils/potential_utf/src/ustr.rs
@@ -26,7 +26,7 @@ use core::ops::Deref;
 /// use zerovec::ZeroMap;
 ///
 /// // This map is cheap to deserialize, as we don't need to perform UTF-8 validation.
-/// let map: ZeroMap<PotentialUtf8, usize> = [
+/// let map: ZeroMap<PotentialUtf8, u8> = [
 ///     (PotentialUtf8::from_bytes(b"abc"), 11),
 ///     (PotentialUtf8::from_bytes(b"def"), 22),
 ///     (PotentialUtf8::from_bytes(b"ghi"), 33),

diff --git a/utils/zerotrie/benches/overview.rs b/utils/zerotrie/benches/overview.rs
@@ -57,11 +57,11 @@ fn get_basic_bench(c: &mut Criterion) {
 
     #[cfg(feature = "bench")]
     g.bench_function("ZeroMap/usize", |b| {
-        let zm: ZeroMap<[u8], usize> = data.iter().copied().collect();
+        let zm: ZeroMap<[u8], u32> = data.iter().map(|(a, b)| (*a, *b as u32)).collect();
         b.iter(|| {
             for (key, expected) in black_box(data) {
                 let actual = black_box(&zm).get_copied(key);
-                assert_eq!(Some(*expected), actual);
+                assert_eq!(Some(*expected as u32), actual);
             }
         });
     });
@@ -88,22 +88,6 @@ fn get_basic_bench(c: &mut Criterion) {
         });
     });
 
-    #[cfg(feature = "bench")]
-    g.bench_function("ZeroHashMap/usize", |b| {
-        let zhm: ZeroHashMap<[u8], usize> = data
-            .iter()
-            .copied()
-            .collect();
-        b.iter(|| {
-            for (key, expected) in black_box(data) {
-                let actual = black_box(&zhm).get(key);
-                // No get_copied on ZHM so we need to do it manually
-                let actual = actual.map(|x| <zerovec::vecs::FlexZeroSlice as zerovec::maps::ZeroVecLike<usize>>::zvl_get_as_t(x, |y| *y));
-                assert_eq!(Some(*expected), actual);
-            }
-        });
-    });
-
     #[cfg(feature = "bench")]
     g.bench_function("ZeroHashMap/u8", |b| {
         let zhm: ZeroHashMap<[u8], u8> = data.iter().map(|(k, v)| (*k, *v as u8)).collect();
@@ -171,11 +155,11 @@ fn get_subtags_bench_helper<M: criterion::measurement::Measurement>(
 
     #[cfg(feature = "bench")]
     g.bench_function("ZeroMap/usize", |b| {
-        let zm: ZeroMap<[u8], usize> = litemap.iter().map(|(a, b)| (*a, b)).collect();
+        let zm: ZeroMap<[u8], u32> = litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
         b.iter(|| {
             for (i, key) in black_box(strings).iter().enumerate() {
                 let actual = black_box(&zm).get_copied(key.as_bytes());
-                assert_eq!(Some(i), actual);
+                assert_eq!(Some(i as u32), actual);
             }
         });
     });
@@ -193,27 +177,11 @@ fn get_subtags_bench_helper<M: criterion::measurement::Measurement>(
 
     #[cfg(feature = "bench")]
     g.bench_function("HashMap", |b| {
-        let hm: HashMap<&[u8], usize> = litemap.iter().map(|(a, b)| (*a, *b)).collect();
+        let hm: HashMap<&[u8], u32> = litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
         b.iter(|| {
             for (i, key) in black_box(strings).iter().enumerate() {
                 let actual = black_box(&hm).get(key.as_bytes());
-                assert_eq!(Some(&i), actual);
-            }
-        });
-    });
-
-    #[cfg(feature = "bench")]
-    g.bench_function("ZeroHashMap/usize", |b| {
-        let zhm: ZeroHashMap<[u8], usize> = litemap
-            .iter()
-            .map(|(a, b)| (*a, b))
-            .collect();
-        b.iter(|| {
-            for (i, key) in black_box(strings).iter().enumerate() {
-                let actual = black_box(&zhm).get(key.as_bytes());
-                // No get_copied on ZHM so we need to do it manually
-                let actual = actual.map(|x| <zerovec::vecs::FlexZeroSlice as zerovec::maps::ZeroVecLike<usize>>::zvl_get_as_t(x, |y| *y));
-                assert_eq!(Some(i), actual);
+                assert_eq!(Some(i as u32), actual.copied());
             }
         });
     });

diff --git a/utils/zerotrie/tests/asciitrie_test.rs b/utils/zerotrie/tests/asciitrie_test.rs
@@ -58,7 +58,7 @@ fn test_basic() {
     }
 
     // Compare the size to a postcard ZeroMap
-    let zm: ZeroMap<[u8], usize> = data_ascii.iter().copied().collect();
+    let zm: ZeroMap<[u8], u32> = data_ascii.iter().map(|(a, b)| (*a, *b as u32)).collect();
     let mut serializer = postcard::Serializer {
         output: AllocVec::new(),
     };
@@ -69,5 +69,5 @@ fn test_basic() {
         .expect("Failed to finalize serializer output");
 
     assert_eq!(26, bytes_ascii.len());
-    assert_eq!(57, zeromap_bytes.len());
+    assert_eq!(77, zeromap_bytes.len());
 }
diff --git a/utils/zerotrie/tests/builder_test.rs b/utils/zerotrie/tests/builder_test.rs
@@ -648,17 +648,18 @@ fn test_everything() {
     assert_bytes_eq!(36, trie_phf.as_bytes(), expected_bytes);
     check_phf_ascii_trie(&litemap, &trie_phf);
 
-    let zhm: zerovec::ZeroMap<[u8], usize> = litemap.iter().map(|(a, b)| (*a, b)).collect();
+    let zhm: zerovec::ZeroMap<[u8], u32> = litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
-    assert_eq!(zhm_buf.len(), 71);
+    assert_eq!(zhm_buf.len(), 88);
 
     let zhm: zerovec::ZeroMap<[u8], u8> = litemap.iter().map(|(a, b)| (*a, *b as u8)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
     assert_eq!(zhm_buf.len(), 61);
 
-    let zhm: zerovec::ZeroHashMap<[u8], usize> = litemap.iter().map(|(a, b)| (*a, b)).collect();
+    let zhm: zerovec::ZeroHashMap<[u8], u32> =
+        litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
-    assert_eq!(zhm_buf.len(), 144);
+    assert_eq!(zhm_buf.len(), 161);
 
     let zhm: zerovec::ZeroHashMap<[u8], u8> = litemap.iter().map(|(a, b)| (*a, *b as u8)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
@@ -804,17 +805,18 @@ fn test_short_subtags_10pct() {
     assert_eq!(trie_phf.byte_len(), 1100);
     check_phf_ascii_trie(&litemap, &trie_phf);
 
-    let zhm: zerovec::ZeroMap<[u8], usize> = litemap.iter().map(|(a, b)| (*a, b)).collect();
+    let zhm: zerovec::ZeroMap<[u8], u32> = litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
-    assert_eq!(zhm_buf.len(), 1327);
+    assert_eq!(zhm_buf.len(), 1890);
 
     let zhm: zerovec::ZeroMap<[u8], u8> = litemap.iter().map(|(a, b)| (*a, *b as u8)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
     assert_eq!(zhm_buf.len(), 1326);
 
-    let zhm: zerovec::ZeroHashMap<[u8], usize> = litemap.iter().map(|(a, b)| (*a, b)).collect();
+    let zhm: zerovec::ZeroHashMap<[u8], u32> =
+        litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
-    assert_eq!(zhm_buf.len(), 2833);
+    assert_eq!(zhm_buf.len(), 3396);
 
     let zhm: zerovec::ZeroHashMap<[u8], u8> = litemap.iter().map(|(a, b)| (*a, *b as u8)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
@@ -834,17 +836,18 @@ fn test_short_subtags() {
     assert_eq!(trie_phf.byte_len(), 9400);
     check_phf_ascii_trie(&litemap, &trie_phf);
 
-    let zm: zerovec::ZeroMap<[u8], usize> = litemap.iter().map(|(a, b)| (*a, b)).collect();
+    let zm: zerovec::ZeroMap<[u8], u32> = litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
     let zhm_buf = postcard::to_allocvec(&zm).unwrap();
-    assert_eq!(zhm_buf.len(), 15178);
+    assert_eq!(zhm_buf.len(), 18931);
 
     let zm: zerovec::ZeroMap<[u8], u8> = litemap.iter().map(|(a, b)| (*a, *b as u8)).collect();
     let zhm_buf = postcard::to_allocvec(&zm).unwrap();
     assert_eq!(zhm_buf.len(), 13300);
 
-    let zhm: zerovec::ZeroHashMap<[u8], usize> = litemap.iter().map(|(a, b)| (*a, b)).collect();
+    let zhm: zerovec::ZeroHashMap<[u8], u32> =
+        litemap.iter().map(|(a, b)| (*a, *b as u32)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();
-    assert_eq!(zhm_buf.len(), 30196);
+    assert_eq!(zhm_buf.len(), 33949);
 
     let zhm: zerovec::ZeroHashMap<[u8], u8> = litemap.iter().map(|(a, b)| (*a, *b as u8)).collect();
     let zhm_buf = postcard::to_allocvec(&zhm).unwrap();

diff --git a/utils/zerovec/src/flexzerovec/databake.rs b/utils/zerovec/src/flexzerovec/databake.rs
diff --git a/utils/zerovec/src/flexzerovec/mod.rs b/utils/zerovec/src/flexzerovec/mod.rs