@shd101wyy/yo 0.0.2

package/std/collections/hash_map.yo

@@ -0,0 +1,482 @@
+/**
+ * HashMap - A high-performance hash map implementation using SwissTable algorithm
+ * 
+ * SwissTable is a state-of-the-art hash table design developed by Google for Abseil.
+ * Key features:
+ * - SIMD-accelerated lookup using control bytes
+ * - Quadratic probing for collision resolution
+ * - 7/8 max load factor for good performance
+ * - Compact memory layout with metadata array
+ * 
+ * Memory layout:
+ * - ctrl: Array of control bytes (metadata), one per bucket
+ * - data: Array of key-value pairs
+ * 
+ * Control byte values:
+ * - 0xFF (EMPTY): Bucket is empty and never used
+ * - 0xFE (DELETED): Bucket was used but is now deleted
+ * - 0x00-0x7F: Lower 7 bits of hash (H2 hash), indicates occupied bucket
+ * 
+ * Hash function splits hash into two parts:
+ * - H1: Upper bits used to find bucket group
+ * - H2: Lower 7 bits stored in control byte for fast SIMD comparison
+ */
+{ GlobalAllocator, AllocError } :: import "../allocator.yo";
+{ malloc, calloc, realloc, free } :: GlobalAllocator;
+
+/**
+ * HashMap error types
+ */
+HashMapError :: enum(
+  AllocError(error : AllocError),
+  KeyNotFound,
+  CapacityOverflow
+);
+
+/**
+ * Control byte constants for SwissTable
+ */
+CTRL_EMPTY :: u8(255);
+CTRL_DELETED :: u8(254);
+
+/**
+ * Default initial capacity (must be power of 2)
+ */
+DEFAULT_CAPACITY :: usize(16);
+
+/**
+ * Maximum load factor: 7/8 = 0.875
+ * We resize when: size > capacity * 7 / 8
+ */
+MAX_LOAD_FACTOR_NUMERATOR :: usize(7);
+MAX_LOAD_FACTOR_DENOMINATOR :: usize(8);
+
+/**
+ * Bucket - Internal structure to store key-value pairs
+ */
+Bucket :: (fn(compt(K): Type, compt(V): Type) -> compt(Type))
+  struct(
+    key : K,
+    value : V
+  )
+;
+
+/**
+ * Extract H2 hash (lower 7 bits) from full hash
+ */
+h2_hash :: (fn(hash: u64) -> u8)
+  u8(hash & u64(127))
+;
+
+/**
+ * Extract H1 hash (upper bits) for bucket index
+ */
+h1_hash :: (fn(hash: u64, capacity: usize) -> usize)
+  (usize((hash >> u64(7))) % capacity)
+;
+
+/**
+ * HashMap type - high-performance hash table using SwissTable
+ * 
+ * Memory layout:
+ * - ctrl: Pointer to control bytes array (length = capacity)
+ * - data: Pointer to buckets array (length = capacity)
+ * - capacity: Total number of buckets (always power of 2)
+ * - size: Current number of occupied buckets
+ */
+HashMap :: (fn(
+  compt(K): Type,
+  compt(V): Type,
+  where(K <: (Eq(K), Hash))
+) -> compt(Type))
+  object(
+    ctrl : ?*(u8),
+    data : ?*(Bucket(K, V)),
+    capacity : usize,
+    size : usize,
+
+    /**
+     * Allocate memory for HashMap with given capacity
+     * Initializes all control bytes to EMPTY
+     */
+    _alloc_with_capacity :: (fn(capacity: usize) -> Result(Self, HashMapError))(
+      {
+        bucket_size :: sizeof(Bucket(K, V));
+        ctrl_size := capacity;
+        data_size := (capacity * bucket_size);
+        
+        ctrl_result := malloc(ctrl_size);
+        match(ctrl_result,
+          .None => .Err(.AllocError(error: .OutOfMemory)),
+          .Some(ctrl_void_ptr) => {
+            ctrl_ptr := *(u8)(ctrl_void_ptr);
+            
+            data_result := malloc(data_size);
+            match(data_result,
+              .None => {
+                free(.Some(*(void)(ctrl_ptr)));
+                .Err(.AllocError(error: .OutOfMemory))
+              },
+              .Some(data_void_ptr) => {
+                data_ptr := *(Bucket(K, V))(data_void_ptr);
+                
+                i := usize(0);
+                while(i < capacity, i = (i + usize(1)), {
+                  (ctrl_ptr &+ i).* = CTRL_EMPTY;
+                });
+                
+                .Ok(Self(
+                  ctrl: .Some(ctrl_ptr),
+                  data: .Some(data_ptr),
+                  capacity: capacity,
+                  size: usize(0)
+                ))
+              }
+            )
+          }
+        )
+      }
+    ),
+
+    /**
+     * Create a new empty HashMap with default capacity
+     */
+    new :: (fn() -> Self)(
+      {
+        result := Self._alloc_with_capacity(DEFAULT_CAPACITY);
+        match(result,
+          .Ok(map) => map,
+          .Err(_) => panic("Failed to allocate HashMap")
+        )
+      }
+    ),
+
+    /**
+     * Create a HashMap with a specific initial capacity
+     * Capacity will be rounded up to next power of 2
+     */
+    with_capacity :: (fn(requested_capacity: usize) -> Self)(
+      {
+        capacity := cond(
+          (requested_capacity < DEFAULT_CAPACITY) => DEFAULT_CAPACITY,
+          true => {
+            c := requested_capacity;
+            c = (c - usize(1));
+            c = (c | (c >> usize(1)));
+            c = (c | (c >> usize(2)));
+            c = (c | (c >> usize(4)));
+            c = (c | (c >> usize(8)));
+            c = (c | (c >> usize(16)));
+            (c + usize(1))
+          }
+        );
+        
+        result := Self._alloc_with_capacity(capacity);
+        match(result,
+          .Ok(map) => map,
+          .Err(_) => panic("Failed to allocate HashMap")
+        )
+      }
+    ),
+
+    /**
+     * Get ctrl pointer (unwrapped for internal use)
+     */
+    _ctrl_ptr :: (fn(self: Self) -> *(u8))(
+      match(self.ctrl,
+        .Some(ptr) => ptr,
+        .None => panic("HashMap ctrl pointer is null")
+      )
+    ),
+
+    /**
+     * Get data pointer (unwrapped for internal use)
+     */
+    _data_ptr :: (fn(self: Self) -> *(Bucket(K, V)))(
+      match(self.data,
+        .Some(ptr) => ptr,
+        .None => panic("HashMap data pointer is null")
+      )
+    ),
+
+    /**
+     * Find bucket index for a given key using quadratic probing
+     * Returns Some(index) if key is found, None otherwise
+     */
+    _find_bucket :: (fn(self: Self, key: K, hash: u64) -> Option(usize))(
+      {
+        h2 := h2_hash(hash);
+        index := h1_hash(hash, self.capacity);
+        probe := usize(0);
+        ctrl_ptr := self._ctrl_ptr();
+        data_ptr := self._data_ptr();
+        
+        while(probe < self.capacity, probe = (probe + usize(1)), {
+          probe_index := ((index + probe) % self.capacity);
+          ctrl_byte := (ctrl_ptr &+ probe_index).*;
+          
+          cond(
+            (ctrl_byte == CTRL_EMPTY) => {
+              return .None;
+            },
+            (ctrl_byte == h2) => {
+              bucket := (data_ptr &+ probe_index).*;
+              cond(
+                (bucket.key == key) => {
+                  return .Some(probe_index);
+                },
+                true => ()
+              );
+            },
+            true => ()
+          );
+        });
+        
+        .None
+      }
+    ),
+
+    /**
+     * Find first available bucket (EMPTY or DELETED) for insertion
+     * Returns bucket index using quadratic probing
+     */
+    _find_insert_bucket :: (fn(self: Self, hash: u64) -> usize)(
+      {
+        index := h1_hash(hash, self.capacity);
+        probe := usize(0);
+        ctrl_ptr := self._ctrl_ptr();
+        
+        while(probe < self.capacity, probe = (probe + usize(1)), {
+          probe_index := ((index + probe) % self.capacity);
+          ctrl_byte := (ctrl_ptr &+ probe_index).*;
+          
+          cond(
+            ((ctrl_byte == CTRL_EMPTY) || (ctrl_byte == CTRL_DELETED)) => {
+              return probe_index;
+            },
+            true => ()
+          );
+        });
+        
+        panic("HashMap is full - should have resized")
+      }
+    ),
+
+    /**
+     * Check if HashMap needs resizing based on load factor
+     */
+    _needs_resize :: ((fn(self: Self) -> bool)
+      {
+        threshold := ((self.capacity * MAX_LOAD_FACTOR_NUMERATOR) / MAX_LOAD_FACTOR_DENOMINATOR);
+        (self.size >= threshold)
+      }
+    ),
+
+    /**
+     * Resize and rehash the HashMap to a new capacity
+     */
+    _resize :: (fn(self: Self, new_capacity: usize) -> Result(unit, HashMapError))(
+      {
+        result := Self._alloc_with_capacity(new_capacity);
+        match(result,
+          .Err(err) => .Err(err),
+          .Ok(new_map) => {
+            i := usize(0);
+            ctrl_ptr := self._ctrl_ptr();
+            data_ptr := self._data_ptr();
+            while(i < self.capacity, i = (i + usize(1)), {
+              ctrl_byte := (ctrl_ptr &+ i).*;
+              cond(
+                ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
+                  bucket := (data_ptr &+ i).*;
+                  hash := (bucket.key).hash();
+                  h2 := h2_hash(hash);
+                  new_index := new_map._find_insert_bucket(hash);
+                  
+                  new_ctrl_ptr := new_map._ctrl_ptr();
+                  new_data_ptr := new_map._data_ptr();
+                  (new_ctrl_ptr &+ new_index).* = h2;
+                  consume((new_data_ptr &+ new_index).* = bucket);
+                  new_map.size = (new_map.size + usize(1));
+                },
+                true => ()
+              );
+            });
+            
+            match(self.ctrl,
+              .Some(ptr) => free(.Some(*(void)(ptr))),
+              .None => ()
+            );
+            match(self.data,
+              .Some(ptr) => free(.Some(*(void)(ptr))),
+              .None => ()
+            );
+            
+            self.ctrl = new_map.ctrl;
+            self.data = new_map.data;
+            self.capacity = new_map.capacity;
+            
+            new_map.ctrl = .None;
+            new_map.data = .None;
+            
+            .Ok(())
+          }
+        )
+      }
+    ),
+
+    /**
+     * Insert or update a key-value pair
+     * Returns Ok(Some(old_value)) if key existed, Ok(None) if new key
+     */
+    set :: ((fn(self: Self, key: K, value: V) -> Result(Option(V), HashMapError))
+      {
+        hash := key.hash();
+        bucket_opt := self._find_bucket(key, hash);
+        
+        match(bucket_opt,
+          .Some(index) => {
+            data_ptr := self._data_ptr();
+            old_bucket := (data_ptr &+ index).*;
+            old_value := old_bucket.value;
+            new_bucket := Bucket(K, V)(key: key, value: value);
+            consume((data_ptr &+ index).* = new_bucket);
+            .Ok(.Some(old_value))
+          },
+          .None => {
+            resize_check := cond(
+              (self._needs_resize()) => {
+                new_capacity := (self.capacity * usize(2));
+                self._resize(new_capacity)
+              },
+              true => (Result(unit, HashMapError).Ok(()))
+            );
+            
+            match(resize_check,
+              .Err(err) => .Err(err),
+              .Ok(_) => {
+                h2 := h2_hash(hash);
+                index := self._find_insert_bucket(hash);
+                
+                ctrl_ptr := self._ctrl_ptr();
+                data_ptr := self._data_ptr();
+                (ctrl_ptr &+ index).* = h2;
+                new_bucket := Bucket(K, V)(key: key, value: value);
+                consume((data_ptr &+ index).* = new_bucket);
+                self.size = (self.size + usize(1));
+                
+                .Ok(.None)
+              }
+            )
+          }
+        )
+      }
+    ),
+
+    /**
+     * Get a value by key
+     * Returns Some(value) if found, None otherwise
+     */
+    get :: ((fn(self: Self, key: K) -> Option(V))
+      {
+        hash := key.hash();
+        bucket_opt := self._find_bucket(key, hash);
+        match(bucket_opt,
+          .Some(index) => {
+            data_ptr := self._data_ptr();
+            bucket := (data_ptr &+ index).*;
+            .Some(bucket.value)
+          },
+          .None => .None
+        )
+      }
+    ),
+
+    /**
+     * Check if a key exists in the map
+     */
+    has :: ((fn(self: Self, key: K) -> bool)
+      {
+        hash := key.hash();
+        bucket_opt := self._find_bucket(key, hash);
+        match(bucket_opt,
+          .Some(_) => true,
+          .None => false
+        )
+      }
+    ),
+
+    /**
+     * Remove a key-value pair by key
+     * Returns Some(value) if the key was found and removed, None otherwise
+     */
+    remove :: ((fn(self: Self, key: K) -> Option(V))
+      {
+        hash := key.hash();
+        bucket_opt := self._find_bucket(key, hash);
+        match(bucket_opt,
+          .Some(index) => {
+            data_ptr := self._data_ptr();
+            ctrl_ptr := self._ctrl_ptr();
+            bucket := (data_ptr &+ index).*;
+            value := bucket.value;
+            
+            (ctrl_ptr &+ index).* = CTRL_DELETED;
+            self.size = (self.size - usize(1));
+            
+            .Some(value)
+          },
+          .None => .None
+        )
+      }
+    ),
+
+    /**
+     * Get the number of key-value pairs in the map
+     */
+    len :: ((fn(self: Self) -> usize)
+      self.size
+    ),
+
+    /**
+     * Check if the map is empty
+     */
+    is_empty :: ((fn(self: Self) -> bool)
+      (self.size == usize(0))
+    ),
+
+    /**
+     * Clear all key-value pairs
+     * Resets all control bytes to EMPTY
+     */
+    clear :: ((fn(self: Self) -> unit)
+      {
+        ctrl_ptr := self._ctrl_ptr();
+        i := usize(0);
+        while(i < self.capacity, i = (i + usize(1)), {
+          (ctrl_ptr &+ i).* = CTRL_EMPTY;
+        });
+        self.size = usize(0);
+      }
+    ),
+
+    /**
+     * RAII destructor - automatically called when HashMap goes out of scope
+     */
+    dispose :: (fn(self: Self) -> unit)({
+      match(self.ctrl,
+        .Some(ptr) => free(.Some(*(void)(ptr))),
+        .None => ()
+      );
+      match(self.data,
+        .Some(ptr) => free(.Some(*(void)(ptr))),
+        .None => ()
+      );
+    })
+  );
+
+export
+  HashMap,
+  HashMapError,
+  Bucket
+;