Remove FlexZeroVec

CHANGELOG.md

@@ -46,6 +46,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`
 
 

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),

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());
             }
         });
     });

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());
 }

utils/zerotrie/tests/builder_test.rs

@@ -648,21 +648,22 @@ 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);
+    assert_eq!(zhm_buf.len(), 63);
 
-    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();
-    assert_eq!(zhm_buf.len(), 134);
+    assert_eq!(zhm_buf.len(), 136);
 }
 
 macro_rules! utf8_byte {
@@ -804,21 +805,22 @@ 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);
+    assert_eq!(zhm_buf.len(), 1328);
 
-    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();
-    assert_eq!(zhm_buf.len(), 2832);
+    assert_eq!(zhm_buf.len(), 2834);
 }
 
 #[test]
@@ -834,19 +836,20 @@ 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);
+    assert_eq!(zhm_buf.len(), 13302);
 
-    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();
-    assert_eq!(zhm_buf.len(), 28318);
+    assert_eq!(zhm_buf.len(), 28320);
 }