Reimplement SmallMap (again)

Summary:
Change `VecMap` (which is linear part of `SmallMap`) from

```
Vec<(Hash, K, V)>
```

to

```
Vec2<(K, V), Hash>
```

The idea is this: hash is 32 bit. But because of padding, it occupies 64 bits. So by changing layout from

```
H, K, V, H, K, V, ....
```

to

```
K, V, K, V, ..., H, H, ...
```

we save 4 bytes per entry.

At cost of slower operations with `SmallMap`. However `SmallMap` is meant to be small, not fast, so this is probably acceptable.

Basically we trade 2% memory for 0.5% CPU.

Also, additional savings of memory are possible: because hashes are stored in contiguous memory now, we can use SIMD to scan them. So we can increase the amount of entries with scan linearly before allocating the index without hurting much performance (currently we create the index at 12 entries).

Also, we can now implement storing `RawTable` next to `Vec2` data, to reduce the size of empty `SmallMap` from 4 words to 3.

Reviewed By: ndmitchell

Differential Revision: D40557486

fbshipit-source-id: 44ef3dd8de0b72171fa084a417dbf7376c793bae

Author: stepancheg

starlark_map/src/vec2/iter.rs

@@ -15,77 +15,124 @@
  * limitations under the License.
  */
 
+use std::marker::PhantomData;
+use std::ptr;
+use std::ptr::NonNull;
 use std::slice;
 
 use gazebo::prelude::*;
 
+use crate::vec2::Vec2;
+
 #[derive(Clone_)]
 pub(crate) struct Iter<'a, K, V> {
     pub(crate) keys: slice::Iter<'a, K>,
-    pub(crate) values: slice::Iter<'a, V>,
+    pub(crate) values: *const V,
+    pub(crate) _marker: PhantomData<slice::Iter<'a, V>>,
 }
 
+unsafe impl<K: Sync, V: Sync> Sync for Iter<'_, K, V> {}
+unsafe impl<K: Sync, V: Sync> Send for Iter<'_, K, V> {}
+
 impl<'a, K, V> Iterator for Iter<'a, K, V> {
     type Item = (&'a K, &'a V);
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        match (self.keys.next(), self.values.next()) {
-            (Some(k), Some(v)) => Some((k, v)),
-            _ => None,
-        }
+        let key = self.keys.next()?;
+        let value = unsafe { &*self.values };
+        self.values = unsafe { self.values.add(1) };
+        Some((key, value))
     }
 
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.keys.size_hint()
     }
 }
 
 impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {
+    #[inline]
     fn len(&self) -> usize {
         self.keys.len()
     }
 }
 
 impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
+    #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
-        match (self.keys.next_back(), self.values.next_back()) {
-            (Some(k), Some(v)) => Some((k, v)),
-            _ => None,
-        }
+        let key = self.keys.next_back()?;
+        let value = unsafe { &*self.values.add(self.keys.len()) };
+        Some((key, value))
     }
 }
 
 pub(crate) struct IntoIter<K, V> {
-    pub(crate) keys: std::vec::IntoIter<K>,
-    pub(crate) values: std::vec::IntoIter<V>,
+    // TODO: make NonNull
+    pub(crate) keys_begin: *mut K,
+    pub(crate) values_begin: *mut V,
+    pub(crate) values_end: *mut V,
+    pub(crate) values_ptr: NonNull<V>,
+    pub(crate) cap: usize,
 }
 
+unsafe impl<K: Send, V: Send> Send for IntoIter<K, V> {}
+unsafe impl<K: Sync, V: Sync> Sync for IntoIter<K, V> {}
+
 impl<K, V> Iterator for IntoIter<K, V> {
     type Item = (K, V);
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        match (self.keys.next(), self.values.next()) {
-            (Some(k), Some(v)) => Some((k, v)),
-            _ => None,
+        if self.values_begin == self.values_end {
+            None
+        } else {
+            unsafe {
+                let k = ptr::read(self.keys_begin);
+                let v = ptr::read(self.values_begin);
+                self.keys_begin = self.keys_begin.add(1);
+                self.values_begin = self.values_begin.add(1);
+                Some((k, v))
+            }
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.keys.size_hint()
+        let rem = self.len();
+        (rem, Some(rem))
+    }
+}
+
+impl<K, V> Drop for IntoIter<K, V> {
+    fn drop(&mut self) {
+        unsafe {
+            let rem = self.len();
+            ptr::drop_in_place(slice::from_raw_parts_mut(self.keys_begin, rem));
+            ptr::drop_in_place(slice::from_raw_parts_mut(self.values_begin, rem));
+            Vec2::<K, V>::dealloc_impl(self.values_ptr, self.cap);
+        }
     }
 }
 
 impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+    #[inline]
     fn len(&self) -> usize {
-        self.keys.len()
+        unsafe { self.values_end.offset_from(self.values_begin) as usize }
     }
 }
 
 impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
     fn next_back(&mut self) -> Option<Self::Item> {
-        match (self.keys.next_back(), self.values.next_back()) {
-            (Some(k), Some(v)) => Some((k, v)),
-            _ => None,
+        if self.values_begin == self.values_end {
+            None
+        } else {
+            unsafe {
+                self.values_end = self.values_end.sub(1);
+                let k = ptr::read(self.keys_begin.add(self.len()));
+                let v = ptr::read(self.values_end);
+                Some((k, v))
+            }
         }
     }
 }