[dict-proto] C++ implementation of SwissNameDictionary, pt. 3

This CL is part of a series that adds the C++ implementation of
SwissNameDictionary, a deterministic property backing store based on
Swiss Tables.

This CL adds the initialization code, factory functions and a
canonical SwissNameDictionary plus all helpers required for that.

Bug: v8:11388
Change-Id: I6bb92740afefc7d05433cfa62023e6da5e8213c7
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2688058Reviewed-by: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Marja Hölttä <marja@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Frank Emrich <emrich@google.com>
Cr-Commit-Position: refs/heads/master@{#72824}

src/heap/factory-base.cc

@@ -22,6 +22,7 @@
 #include "src/objects/source-text-module.h"
 #include "src/objects/string-inl.h"
 #include "src/objects/string.h"
+#include "src/objects/swiss-name-dictionary-inl.h"
 #include "src/objects/template-objects-inl.h"
 
 namespace v8 {
@@ -848,6 +849,43 @@ HeapObject FactoryBase<Impl>::AllocateRaw(int size, AllocationType allocation,
   return impl()->AllocateRaw(size, allocation, alignment);
 }
 
+template <typename Impl>
+Handle<SwissNameDictionary>
+FactoryBase<Impl>::NewSwissNameDictionaryWithCapacity(
+    int capacity, AllocationType allocation) {
+  DCHECK(SwissNameDictionary::IsValidCapacity(capacity));
+
+  if (capacity == 0) {
+    DCHECK_NE(read_only_roots().at(RootIndex::kEmptySwissPropertyDictionary),
+              kNullAddress);
+
+    return read_only_roots().empty_swiss_property_dictionary_handle();
+  }
+
+  if (capacity > SwissNameDictionary::MaxCapacity()) {
+    isolate()->FatalProcessOutOfHeapMemory("invalid table size");
+  }
+
+  int meta_table_length = SwissNameDictionary::MetaTableSizeFor(capacity);
+  Handle<ByteArray> meta_table =
+      impl()->NewByteArray(meta_table_length, allocation);
+
+  Map map = read_only_roots().swiss_name_dictionary_map();
+  int size = SwissNameDictionary::SizeFor(capacity);
+  HeapObject result = AllocateRawWithImmortalMap(size, allocation, map);
+  Handle<SwissNameDictionary> table(SwissNameDictionary::cast(result),
+                                    isolate());
+  table->Initialize(isolate(), *meta_table, capacity);
+  return table;
+}
+
+template <typename Impl>
+Handle<SwissNameDictionary> FactoryBase<Impl>::NewSwissNameDictionary(
+    int at_least_space_for, AllocationType allocation) {
+  return NewSwissNameDictionaryWithCapacity(
+      SwissNameDictionary::CapacityFor(at_least_space_for), allocation);
+}
+
 // Instantiate FactoryBase for the two variants we want.
 template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) FactoryBase<Factory>;
 template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)

src/heap/factory-base.h

@@ -221,6 +221,13 @@ class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) FactoryBase
 
   Handle<ClassPositions> NewClassPositions(int start, int end);
 
+  Handle<SwissNameDictionary> NewSwissNameDictionary(
+      int at_least_space_for = kSwissNameDictionaryInitialCapacity,
+      AllocationType allocation = AllocationType::kYoung);
+
+  Handle<SwissNameDictionary> NewSwissNameDictionaryWithCapacity(
+      int capacity, AllocationType allocation);
+
  protected:
   // Allocate memory for an uninitialized array (e.g., a FixedArray or similar).
   HeapObject AllocateRawArray(int size, AllocationType allocation);

src/heap/factory.cc

@@ -553,6 +553,27 @@ Handle<PropertyDescriptorObject> Factory::NewPropertyDescriptorObject() {
   return object;
 }
 
+Handle<SwissNameDictionary> Factory::CreateCanonicalEmptySwissNameDictionary() {
+  // This function is only supposed to be used to create the canonical empty
+  // version and should not be used afterwards.
+  DCHECK_EQ(kNullAddress, ReadOnlyRoots(isolate()).at(
+                              RootIndex::kEmptySwissPropertyDictionary));
+
+  ReadOnlyRoots roots(isolate());
+
+  Handle<ByteArray> empty_meta_table =
+      NewByteArray(SwissNameDictionary::kMetaTableEnumerationTableStartOffset,
+                   AllocationType::kReadOnly);
+
+  Map map = roots.swiss_name_dictionary_map();
+  int size = SwissNameDictionary::SizeFor(0);
+  HeapObject obj =
+      AllocateRawWithImmortalMap(size, AllocationType::kReadOnly, map);
+  SwissNameDictionary result = SwissNameDictionary::cast(obj);
+  result.Initialize(isolate(), *empty_meta_table, 0);
+  return handle(result, isolate());
+}
+
 // Internalized strings are created in the old generation (data space).
 Handle<String> Factory::InternalizeUtf8String(
     const Vector<const char>& string) {

src/heap/factory.h

@@ -171,6 +171,8 @@ class V8_EXPORT_PRIVATE Factory : public FactoryBase<Factory> {
       int capacity = kSmallOrderedHashMapMinCapacity,
       AllocationType allocation = AllocationType::kYoung);
 
+  Handle<SwissNameDictionary> CreateCanonicalEmptySwissNameDictionary();
+
   // Create a new PrototypeInfo struct.
   Handle<PrototypeInfo> NewPrototypeInfo();
 

src/heap/setup-heap-internal.cc

@@ -819,6 +819,11 @@ void Heap::CreateInitialObjects() {
           .ToHandleChecked();
   set_empty_ordered_property_dictionary(*empty_ordered_property_dictionary);
 
+  // Allocate the empty SwissNameDictionary
+  Handle<SwissNameDictionary> empty_swiss_property_dictionary =
+      factory->CreateCanonicalEmptySwissNameDictionary();
+  set_empty_swiss_property_dictionary(*empty_swiss_property_dictionary);
+
   // Allocate the empty FeedbackMetadata.
   Handle<FeedbackMetadata> empty_feedback_metadata =
       factory->NewFeedbackMetadata(0, 0, AllocationType::kReadOnly);

src/objects/swiss-name-dictionary-inl.h

@@ -5,6 +5,8 @@
 #ifndef V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_
 #define V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_
 
+#include <algorithm>
+
 #include "src/base/macros.h"
 #include "src/execution/isolate-utils-inl.h"
 #include "src/heap/heap.h"
@@ -26,10 +28,41 @@ namespace internal {
 CAST_ACCESSOR(SwissNameDictionary)
 OBJECT_CONSTRUCTORS_IMPL(SwissNameDictionary, HeapObject)
 
+const swiss_table::ctrl_t* SwissNameDictionary::CtrlTable() {
+  return reinterpret_cast<ctrl_t*>(
+      field_address(CtrlTableStartOffset(Capacity())));
+}
+
 int SwissNameDictionary::Capacity() {
   return ReadField<int32_t>(CapacityOffset());
 }
 
+void SwissNameDictionary::SetCapacity(int capacity) {
+  DCHECK(IsValidCapacity(capacity));
+
+  WriteField(CapacityOffset(), capacity);
+}
+
+int SwissNameDictionary::NumberOfElements() {
+  return GetMetaTableField(kMetaTableElementCountOffset);
+}
+
+int SwissNameDictionary::NumberOfDeletedElements() {
+  return GetMetaTableField(kMetaTableDeletedElementCountOffset);
+}
+
+void SwissNameDictionary::SetNumberOfElements(int elements) {
+  SetMetaTableField(kMetaTableElementCountOffset, elements);
+}
+
+void SwissNameDictionary::SetNumberOfDeletedElements(int deleted_elements) {
+  SetMetaTableField(kMetaTableDeletedElementCountOffset, deleted_elements);
+}
+
+int SwissNameDictionary::UsedCapacity() {
+  return NumberOfElements() + NumberOfDeletedElements();
+}
+
 // static
 constexpr bool SwissNameDictionary::IsValidCapacity(int capacity) {
   return capacity == 0 || (capacity >= kInitialCapacity &&
@@ -55,6 +88,180 @@ constexpr int SwissNameDictionary::SizeFor(int capacity) {
   return PropertyDetailsTableStartOffset(capacity) + capacity;
 }
 
+// We use 7/8th as maximum load factor for non-special cases.
+// For 16-wide groups, that gives an average of two empty slots per group.
+// Similar to Abseil's CapacityToGrowth.
+// static
+constexpr int SwissNameDictionary::MaxUsableCapacity(int capacity) {
+  CONSTEXPR_DCHECK(IsValidCapacity(capacity));
+
+  if (Group::kWidth == 8 && capacity == 4) {
+    // If the group size is 16 we can fully utilize capacity 4: There will be
+    // enough kEmpty entries in the ctrl table.
+    return 3;
+  }
+  return capacity - capacity / 8;
+}
+
+// Returns |at_least_space_for| * 8/7 for non-special cases. Similar to Abseil's
+// GrowthToLowerboundCapacity.
+// static
+int SwissNameDictionary::CapacityFor(int at_least_space_for) {
+  if (at_least_space_for <= 4) {
+    if (at_least_space_for == 0) {
+      return 0;
+    } else if (at_least_space_for < 4) {
+      return 4;
+    } else if (kGroupWidth == 16) {
+      DCHECK_EQ(4, at_least_space_for);
+      return 4;
+    } else if (kGroupWidth == 8) {
+      DCHECK_EQ(4, at_least_space_for);
+      return 8;
+    }
+  }
+
+  int non_normalized = at_least_space_for + at_least_space_for / 7;
+  return base::bits::RoundUpToPowerOfTwo32(non_normalized);
+}
+
+void SwissNameDictionary::SetMetaTableField(int field_index, int value) {
+  // See the STATIC_ASSERTs on |kMax1ByteMetaTableCapacity| and
+  // |kMax2ByteMetaTableCapacity| in the .cc file for an explanation of these
+  // constants.
+  int capacity = Capacity();
+  ByteArray meta_table = this->meta_table();
+  if (capacity <= kMax1ByteMetaTableCapacity) {
+    SetMetaTableField<uint8_t>(meta_table, field_index, value);
+  } else if (capacity <= kMax2ByteMetaTableCapacity) {
+    SetMetaTableField<uint16_t>(meta_table, field_index, value);
+  } else {
+    SetMetaTableField<uint32_t>(meta_table, field_index, value);
+  }
+}
+
+int SwissNameDictionary::GetMetaTableField(int field_index) {
+  // See the STATIC_ASSERTs on |kMax1ByteMetaTableCapacity| and
+  // |kMax2ByteMetaTableCapacity| in the .cc file for an explanation of these
+  // constants.
+  int capacity = Capacity();
+  ByteArray meta_table = this->meta_table();
+  if (capacity <= kMax1ByteMetaTableCapacity) {
+    return GetMetaTableField<uint8_t>(meta_table, field_index);
+  } else if (capacity <= kMax2ByteMetaTableCapacity) {
+    return GetMetaTableField<uint16_t>(meta_table, field_index);
+  } else {
+    return GetMetaTableField<uint32_t>(meta_table, field_index);
+  }
+}
+
+// static
+template <typename T>
+void SwissNameDictionary::SetMetaTableField(ByteArray meta_table,
+                                            int field_index, int value) {
+  STATIC_ASSERT((std::is_same<T, uint8_t>::value) ||
+                (std::is_same<T, uint16_t>::value) ||
+                (std::is_same<T, uint32_t>::value));
+  DCHECK_LE(value, std::numeric_limits<T>::max());
+  DCHECK_LT(meta_table.GetDataStartAddress() + field_index * sizeof(T),
+            meta_table.GetDataEndAddress());
+  T* raw_data = reinterpret_cast<T*>(meta_table.GetDataStartAddress());
+  raw_data[field_index] = value;
+}
+
+// static
+template <typename T>
+int SwissNameDictionary::GetMetaTableField(ByteArray meta_table,
+                                           int field_index) {
+  STATIC_ASSERT((std::is_same<T, uint8_t>::value) ||
+                (std::is_same<T, uint16_t>::value) ||
+                (std::is_same<T, uint32_t>::value));
+  DCHECK_LT(meta_table.GetDataStartAddress() + field_index * sizeof(T),
+            meta_table.GetDataEndAddress());
+  T* raw_data = reinterpret_cast<T*>(meta_table.GetDataStartAddress());
+  return raw_data[field_index];
+}
+
+constexpr int SwissNameDictionary::MetaTableSizePerEntryFor(int capacity) {
+  CONSTEXPR_DCHECK(IsValidCapacity(capacity));
+
+  // See the STATIC_ASSERTs on |kMax1ByteMetaTableCapacity| and
+  // |kMax2ByteMetaTableCapacity| in the .cc file for an explanation of these
+  // constants.
+  if (capacity <= kMax1ByteMetaTableCapacity) {
+    return sizeof(uint8_t);
+  } else if (capacity <= kMax2ByteMetaTableCapacity) {
+    return sizeof(uint16_t);
+  } else {
+    return sizeof(uint32_t);
+  }
+}
+
+constexpr int SwissNameDictionary::MetaTableSizeFor(int capacity) {
+  CONSTEXPR_DCHECK(IsValidCapacity(capacity));
+
+  int per_entry_size = MetaTableSizePerEntryFor(capacity);
+
+  // The enumeration table only needs to have as many slots as there can be
+  // present + deleted entries in the hash table (= maximum load factor *
+  // capactiy). Two more slots to store the number of present and deleted
+  // entries.
+  return per_entry_size * (MaxUsableCapacity(capacity) + 2);
+}
+
+template <typename LocalIsolate>
+void SwissNameDictionary::Initialize(LocalIsolate* isolate,
+                                     ByteArray meta_table, int capacity) {
+  DCHECK(IsValidCapacity(capacity));
+  DisallowHeapAllocation no_gc;
+  ReadOnlyRoots roots(isolate);
+
+  SetCapacity(capacity);
+  SetHash(PropertyArray::kNoHashSentinel);
+
+  ctrl_t* ctrl_table = reinterpret_cast<ctrl_t*>(
+      field_address(CtrlTableStartOffset(Capacity())));
+  memset(ctrl_table, Ctrl::kEmpty, CtrlTableSize(capacity));
+
+  MemsetTagged(RawField(DataTableStartOffset()), roots.the_hole_value(),
+               capacity * kDataTableEntryCount);
+
+  set_meta_table(meta_table);
+
+  SetNumberOfElements(0);
+  SetNumberOfDeletedElements(0);
+
+  // We leave the enumeration table PropertyDetails table and uninitialized.
+}
+
+void SwissNameDictionary::SetHash(int32_t hash) {
+  WriteField(PrefixOffset(), hash);
+}
+
+int SwissNameDictionary::Hash() { return ReadField<int32_t>(PrefixOffset()); }
+
+// static
+constexpr int SwissNameDictionary::MaxCapacity() {
+  int const_size =
+      DataTableStartOffset() + ByteArray::kHeaderSize +
+      // Size for present and deleted element count at max capacity:
+      2 * sizeof(uint32_t);
+  int per_entry_size =
+      // size of data table entries:
+      kDataTableEntryCount * kTaggedSize +
+      // ctrl table entry size:
+      kOneByteSize +
+      // PropertyDetails table entry size:
+      kOneByteSize +
+      // Enumeration table entry size at maximum capacity:
+      sizeof(uint32_t);
+
+  int result = (FixedArray::kMaxSize - const_size) / per_entry_size;
+  CONSTEXPR_DCHECK(result <= Smi::kMaxValue);
+
+  return result;
+}
+
 // static
 constexpr int SwissNameDictionary::PrefixOffset() {
   return HeapObject::kHeaderSize;
@@ -91,6 +298,10 @@ constexpr int SwissNameDictionary::PropertyDetailsTableStartOffset(
   return CtrlTableStartOffset(capacity) + CtrlTableSize(capacity);
 }
 
+ACCESSORS_CHECKED2(SwissNameDictionary, meta_table, ByteArray,
+                   MetaTablePointerOffset(), true,
+                   value.length() >= kMetaTableEnumerationTableStartOffset)
+
 }  // namespace internal
 }  // namespace v8
 

src/objects/swiss-name-dictionary.cc

@@ -8,5 +8,30 @@
 #include "src/objects/swiss-name-dictionary-inl.h"
 
 namespace v8 {
-namespace internal {}  // namespace internal
+namespace internal {
+
+// The largest value we ever have to store in the enumeration table is
+// Capacity() - 1. The largest value we ever have to store for the present or
+// deleted element count is MaxUsableCapacity(Capacity()). All data in the
+// meta table is unsigned. Using this, we verify the values of the constants
+// |kMax1ByteMetaTableCapacity| and |kMax2ByteMetaTableCapacity|.
+STATIC_ASSERT(SwissNameDictionary::kMax1ByteMetaTableCapacity - 1 <=
+              std::numeric_limits<uint8_t>::max());
+STATIC_ASSERT(SwissNameDictionary::MaxUsableCapacity(
+                  SwissNameDictionary::kMax1ByteMetaTableCapacity) <=
+              std::numeric_limits<uint8_t>::max());
+STATIC_ASSERT(SwissNameDictionary::kMax2ByteMetaTableCapacity - 1 <=
+              std::numeric_limits<uint16_t>::max());
+STATIC_ASSERT(SwissNameDictionary::MaxUsableCapacity(
+                  SwissNameDictionary::kMax2ByteMetaTableCapacity) <=
+              std::numeric_limits<uint16_t>::max());
+
+template void SwissNameDictionary::Initialize(Isolate* isolate,
+                                              ByteArray meta_table,
+                                              int capacity);
+template void SwissNameDictionary::Initialize(LocalIsolate* isolate,
+                                              ByteArray meta_table,
+                                              int capacity);
+
+}  // namespace internal
 }  // namespace v8

src/objects/swiss-name-dictionary.h

@@ -40,7 +40,6 @@ namespace internal {
 //       identity hash: 4 bytes, raw int32_t
 //   Meta table pointer: kTaggedSize bytes.
 //     See below for explanation of the meta table.
-//     For capacity 0, this contains the Smi |kNoMetaTableSentinel| instead.
 //   Data table:
 //     For each logical bucket of the hash table, contains the corresponding key
 //     and value.
@@ -73,16 +72,40 @@ class SwissNameDictionary : public HeapObject {
  public:
   using Group = swiss_table::Group;
 
+  inline int NumberOfElements();
+  inline int NumberOfDeletedElements();
+
   inline int Capacity();
+  inline int UsedCapacity();
+
+  template <typename LocalIsolate>
+  void Initialize(LocalIsolate* isolate, ByteArray meta_table, int capacity);
+
+  inline void SetHash(int hash);
+  inline int Hash();
 
   inline static constexpr bool IsValidCapacity(int capacity);
+  inline static int CapacityFor(int at_least_space_for);
+
+  // Given a capacity, how much of it can we fill before resizing?
+  inline static constexpr int MaxUsableCapacity(int capacity);
+
+  // The maximum allowed capacity for any SwissNameDictionary.
+  inline static constexpr int MaxCapacity();
 
   // Returns total size in bytes required for a table of given capacity.
   inline static constexpr int SizeFor(int capacity);
 
-  // TODO(v8:11388) This is a temporary placeholder for the actual value, which
-  // is added here in a follow-up CL.
-  static const int kGroupWidth = 8;
+  inline static constexpr int MetaTableSizePerEntryFor(int capacity);
+  inline static constexpr int MetaTableSizeFor(int capacity);
+
+  inline static constexpr int DataTableSize(int capacity);
+  inline static constexpr int CtrlTableSize(int capacity);
+
+  // Indicates that IterateEntries() returns entries ordered.
+  static constexpr bool kIsOrderedDictionaryType = true;
+
+  static const int kGroupWidth = Group::kWidth;
 
   class BodyDescriptor;
 
@@ -93,9 +116,19 @@ class SwissNameDictionary : public HeapObject {
   // Defines how many kTaggedSize sized values are associcated which each entry
   // in the data table.
   static constexpr int kDataTableEntryCount = 2;
+  static constexpr int kDataTableKeyEntryIndex = 0;
+  static constexpr int kDataTableValueEntryIndex = kDataTableKeyEntryIndex + 1;
 
-  inline static constexpr int DataTableSize(int capacity);
-  inline static constexpr int CtrlTableSize(int capacity);
+  static constexpr int kMetaTableElementCountOffset = 0;
+  static constexpr int kMetaTableDeletedElementCountOffset = 1;
+  static constexpr int kMetaTableEnumerationTableStartOffset = 2;
+
+  // The maximum capacity of any SwissNameDictionary whose meta table can use 1
+  // byte per entry.
+  static constexpr int kMax1ByteMetaTableCapacity = (1 << 8);
+  // The maximum capacity of any SwissNameDictionary whose meta table can use 2
+  // bytes per entry.
+  static constexpr int kMax2ByteMetaTableCapacity = (1 << 16);
 
   // TODO(v8:11388) We would like to use Torque-generated constants here, but
   // those are currently incorrect.
@@ -114,6 +147,28 @@ class SwissNameDictionary : public HeapObject {
   DECL_PRINTER(SwissNameDictionary)
   DECL_CAST(SwissNameDictionary)
   OBJECT_CONSTRUCTORS(SwissNameDictionary, HeapObject);
+
+ private:
+  using ctrl_t = swiss_table::ctrl_t;
+  using Ctrl = swiss_table::Ctrl;
+
+  // Not intended for modification, use set_ctrl instead to get correct copying
+  // of first group.
+  inline const ctrl_t* CtrlTable();
+
+  inline void SetCapacity(int capacity);
+  inline void SetNumberOfElements(int elements);
+  inline void SetNumberOfDeletedElements(int deleted_elements);
+
+  DECL_ACCESSORS(meta_table, ByteArray)
+  inline void SetMetaTableField(int field_index, int value);
+  inline int GetMetaTableField(int field_index);
+
+  template <typename T>
+  inline static void SetMetaTableField(ByteArray meta_table, int field_index,
+                                       int value);
+  template <typename T>
+  inline static int GetMetaTableField(ByteArray meta_table, int field_index);
 };
 
 }  // namespace internal

src/roots/roots.h

@@ -167,6 +167,8 @@ class Symbol;
   V(NameDictionary, empty_property_dictionary, EmptyPropertyDictionary)        \
   V(OrderedNameDictionary, empty_ordered_property_dictionary,                  \
     EmptyOrderedPropertyDictionary)                                            \
+  V(SwissNameDictionary, empty_swiss_property_dictionary,                      \
+    EmptySwissPropertyDictionary)                                              \
   V(InterceptorInfo, noop_interceptor_info, NoOpInterceptorInfo)               \
   V(WeakFixedArray, empty_weak_fixed_array, EmptyWeakFixedArray)               \
   V(WeakArrayList, empty_weak_array_list, EmptyWeakArrayList)                  \

test/cctest/BUILD.gn

@@ -275,6 +275,7 @@ v8_source_set("cctest_sources") {
     "test-smi-lexicographic-compare.cc",
     "test-strings.cc",
     "test-strtod.cc",
+    "test-swiss-name-dictionary.cc",
     "test-symbols.cc",
     "test-thread-termination.cc",
     "test-threads.cc",

test/cctest/test-swiss-name-dictionary.cc

+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/objects/swiss-name-dictionary-inl.h"
+#include "test/cctest/cctest.h"
+
+namespace v8 {
+namespace internal {
+namespace test_swiss_hash_table {
+
+TEST(CapacityFor) {
+  for (int elements = 0; elements <= 32; elements++) {
+    int capacity = SwissNameDictionary::CapacityFor(elements);
+    if (elements == 0) {
+      CHECK_EQ(0, capacity);
+    } else if (elements <= 3) {
+      CHECK_EQ(4, capacity);
+    } else if (elements == 4) {
+      CHECK_IMPLIES(SwissNameDictionary::kGroupWidth == 8, capacity == 8);
+      CHECK_IMPLIES(SwissNameDictionary::kGroupWidth == 16, capacity == 4);
+    } else if (elements <= 7) {
+      CHECK_EQ(8, capacity);
+    } else if (elements <= 14) {
+      CHECK_EQ(16, capacity);
+    } else if (elements <= 28) {
+      CHECK_EQ(32, capacity);
+    } else if (elements <= 32) {
+      CHECK_EQ(64, capacity);
+    }
+  }
+}
+
+TEST(MaxUsableCapacity) {
+  CHECK_EQ(0, SwissNameDictionary::MaxUsableCapacity(0));
+  CHECK_IMPLIES(SwissNameDictionary::kGroupWidth == 8,
+                SwissNameDictionary::MaxUsableCapacity(4) == 3);
+  CHECK_IMPLIES(SwissNameDictionary::kGroupWidth == 16,
+                SwissNameDictionary::MaxUsableCapacity(4) == 4);
+  CHECK_EQ(7, SwissNameDictionary::MaxUsableCapacity(8));
+  CHECK_EQ(14, SwissNameDictionary::MaxUsableCapacity(16));
+  CHECK_EQ(28, SwissNameDictionary::MaxUsableCapacity(32));
+}
+
+TEST(SizeFor) {
+  int baseline = HeapObject::kHeaderSize +
+                 // prefix:
+                 4 +
+                 // capacity:
+                 4 +
+                 // meta table:
+                 kTaggedSize;
+
+  int size_0 = baseline +
+               // ctrl table:
+               SwissNameDictionary::kGroupWidth;
+
+  int size_4 = baseline +
+               // data table:
+               4 * 2 * kTaggedSize +
+               // ctrl table:
+               4 + SwissNameDictionary::kGroupWidth +
+               // property details table:
+               4;
+
+  int size_8 = baseline +
+               // data table:
+               8 * 2 * kTaggedSize +
+               // ctrl table:
+               8 + SwissNameDictionary::kGroupWidth +
+               // property details table:
+               8;
+
+  CHECK_EQ(SwissNameDictionary::SizeFor(0), size_0);
+  CHECK_EQ(SwissNameDictionary::SizeFor(4), size_4);
+  CHECK_EQ(SwissNameDictionary::SizeFor(8), size_8);
+}
+
+}  // namespace test_swiss_hash_table
+}  // namespace internal
+}  // namespace v8