Commit cf8dde2d686199474847c6c4e342dc1ac46a435b | zig

author	Ryan Liptak <squeek502@hotmail.com> 2019-05-03 21:15:00-07:00
committer	Ryan Liptak <squeek502@hotmail.com> 2019-05-03 21:15:00-07:00
log	cf8dde2d686199474847c6c4e342dc1ac46a435b
tree	5cfe5b3a15d3c396d77acc578408f359bb98799b
parent	13a7b8586a600c117cc2d090a283e5a6344d42c4

std.HashMap: cleanup ensureCapacity + add test

- Cleaned up some comments
- Removed the "is power of two" check from optimizedCapacity since the * 5 / 3 is unlikely to end up with a power of two, so it's a wasted check the majority of the time
- Made ensureCapacity/ensureCapacityExact increment the modification count if they resize the hash map so that we can catch resizes while iterating, which would likely break the iterator state

1 files changed, 23 insertions(+), 8 deletions(-)

std
- hash_map.zig

std/hash_map.zig+23-8

 @@ -137,18 +137,14 @@ pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u3
         fn optimizedCapacity(expected_count: usize) usize {
             // ensure that the hash map will be at most 60% full if
-            // new_capacity items are put into the hash map
+            // expected_count items are put into it
             var optimized_capacity = expected_count * 5 / 3;
             // round capacity to the next power of two
-            const is_power_of_two = optimized_capacity & (optimized_capacity-1) == 0;
+            const pow = math.log2_int_ceil(usize, optimized_capacity);
-            if (!is_power_of_two) {
+            return math.pow(usize, 2, pow);
-                const pow = math.log2_int_ceil(usize, optimized_capacity);
-                optimized_capacity = math.pow(usize, 2, pow);
-            }
-            return optimized_capacity;
         }
-        /// Increase capacity so that the hash map will be at most
+        /// Increases capacity so that the hash map will be at most
         /// 60% full when expected_count items are put into it
         pub fn ensureCapacity(self: *Self, expected_count: usize) !void {
             const optimized_capacity = optimizedCapacity(expected_count);
 @@ -168,6 +164,7 @@ pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u3
             const old_entries = self.entries;
             try self.initCapacity(new_capacity);
+            self.incrementModificationCount();
             if (old_entries.len > 0) {
                 // dump all of the old elements into the new table
                 for (old_entries) |*old_entry| {
 @@ -467,6 +464,24 @@ test "iterator hash map" {
     testing.expect(entry.value == values[0]);
 }
+test "ensure capacity" {
+    var direct_allocator = std.heap.DirectAllocator.init();
+    defer direct_allocator.deinit();
+    var map = AutoHashMap(i32, i32).init(&direct_allocator.allocator);
+    defer map.deinit();
+    try map.ensureCapacity(20);
+    const initialCapacity = map.entries.len;
+    testing.expect(initialCapacity >= 20);
+    var i : i32 = 0;
+    while (i < 20) : (i += 1) {
+        testing.expect(map.putAssumeCapacity(i, i+10) == null);
+    }
+    // shouldn't resize from putAssumeCapacity
+    testing.expect(initialCapacity == map.entries.len);
+}
 pub fn getHashPtrAddrFn(comptime K: type) (fn (K) u32) {
     return struct {
         fn hash(key: K) u32 {