Revert "[dict-proto] C++ implementation of SwissNameDictionary, pt. 6"

This reverts commit ae153904.

Reason for revert: link error in https://ci.chromium.org/ui/p/v8/builders/ci/V8%20Linux%20-%20full%20debug/16047/overview

Original change's description:
> [dict-proto] C++ implementation of SwissNameDictionary, pt. 6
>
> 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 Add, DeleteEntry, Rehash, and Shrink operations, as
> well as some helpers required by those.
>
> Bug: v8:11388
> Change-Id: I81a181e99e679095c2acc877a293e81b6a581db4
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2715192
> Reviewed-by: Igor Sheludko <ishell@chromium.org>
> Reviewed-by: Marja Hölttä <marja@chromium.org>
> Commit-Queue: Frank Emrich <emrich@google.com>
> Cr-Commit-Position: refs/heads/master@{#73020}

Bug: v8:11388
Change-Id: I7c83ddfab6055b992f1580e03aae0da31d83ba63
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2718662
Auto-Submit: Francis McCabe <fgm@chromium.org>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Adam Klein <adamk@chromium.org>
Cr-Commit-Position: refs/heads/master@{#73034}

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

@@ -317,21 +317,6 @@ PropertyDetails SwissNameDictionary::DetailsAt(InternalIndex entry) {
   return DetailsAt(entry.as_int());
 }
 
-// static
-template <typename LocalIsolate>
-Handle<SwissNameDictionary> SwissNameDictionary::EnsureGrowable(
-    LocalIsolate* isolate, Handle<SwissNameDictionary> table) {
-  int capacity = table->Capacity();
-
-  if (table->UsedCapacity() < MaxUsableCapacity(capacity)) {
-    // We have room for at least one more entry, nothing to do.
-    return table;
-  }
-
-  int new_capacity = capacity == 0 ? kInitialCapacity : capacity * 2;
-  return Rehash(isolate, table, new_capacity);
-}
-
 swiss_table::ctrl_t SwissNameDictionary::GetCtrl(int entry) {
   DCHECK_LT(static_cast<unsigned>(entry), static_cast<unsigned>(Capacity()));
 
@@ -367,25 +352,6 @@ void SwissNameDictionary::SetCtrl(int entry, ctrl_t h) {
   ctrl[copy_entry] = h;
 }
 
-// static
-inline int SwissNameDictionary::FindFirstEmpty(uint32_t hash) {
-  // See SwissNameDictionary::FindEntry for description of probing algorithm.
-
-  auto seq = probe(hash, Capacity());
-  while (true) {
-    Group g{CtrlTable() + seq.offset()};
-    auto mask = g.MatchEmpty();
-    if (mask) {
-      // Note that picking the lowest bit set here means using the leftmost
-      // empty bucket in the group. Here, "left" means smaller entry/bucket
-      // index.
-      return seq.offset(mask.LowestBitSet());
-    }
-    seq.next();
-    DCHECK_LT(seq.index(), Capacity());
-  }
-}
-
 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
@@ -487,57 +453,6 @@ bool SwissNameDictionary::ToKey(ReadOnlyRoots roots, InternalIndex entry,
   return ToKey(roots, entry.as_int(), out_key);
 }
 
-// static
-template <typename LocalIsolate>
-Handle<SwissNameDictionary> SwissNameDictionary::Add(
-    LocalIsolate* isolate, Handle<SwissNameDictionary> original_table,
-    Handle<Name> key, Handle<Object> value, PropertyDetails details,
-    InternalIndex* entry_out) {
-  DCHECK(original_table->FindEntry(isolate, *key).is_not_found());
-
-  Handle<SwissNameDictionary> table = EnsureGrowable(isolate, original_table);
-
-  int nof = table->NumberOfElements();
-  int nod = table->NumberOfDeletedElements();
-  int new_enum_index = nof + nod;
-
-  int new_entry = table->AddInternal(*key, *value, details);
-
-  table->SetNumberOfElements(nof + 1);
-  table->SetEntryForEnumerationIndex(new_enum_index, new_entry);
-
-  if (entry_out) {
-    *entry_out = InternalIndex(new_entry);
-  }
-
-  return table;
-}
-
-int SwissNameDictionary::AddInternal(Name key, Object value,
-                                     PropertyDetails details) {
-  DisallowHeapAllocation no_gc;
-
-  DCHECK(key.IsUniqueName());
-  DCHECK_LE(UsedCapacity(), MaxUsableCapacity(Capacity()));
-
-  uint32_t hash = key.hash();
-
-  // For now we don't re-use deleted buckets (due to enumeration table
-  // complications), which is why we only look for empty buckets here, not
-  // deleted ones.
-  int target = FindFirstEmpty(hash);
-
-  SetCtrl(target, swiss_table::H2(hash));
-  SetKey(target, key);
-  ValueAtPut(target, value);
-  DetailsAtPut(target, details);
-
-  // Note that we do not update the number of elements or the enumeration table
-  // in this function.
-
-  return target;
-}
-
 template <typename LocalIsolate>
 void SwissNameDictionary::Initialize(LocalIsolate* isolate,
                                      ByteArray meta_table, int capacity) {

src/objects/swiss-name-dictionary.cc

@@ -10,90 +10,6 @@
 namespace v8 {
 namespace internal {
 
-// static
-Handle<SwissNameDictionary> SwissNameDictionary::DeleteEntry(
-    Isolate* isolate, Handle<SwissNameDictionary> table, InternalIndex entry) {
-  // GetCtrl() does the bounds check.
-  DCHECK(IsFull(table->GetCtrl(entry.as_int())));
-
-  int i = entry.as_int();
-
-  table->SetCtrl(i, Ctrl::kDeleted);
-  table->ClearDataTableEntry(isolate, i);
-  // We leave the PropertyDetails unchanged because they are not relevant for
-  // GC.
-
-  int nof = table->NumberOfElements();
-  table->SetNumberOfElements(nof - 1);
-  int nod = table->NumberOfDeletedElements();
-  table->SetNumberOfDeletedElements(nod + 1);
-
-  // TODO(v8:11388) Abseil's flat_hash_map doesn't shrink on deletion, but may
-  // decide on addition to do an in-place rehash to remove deleted elements. We
-  // shrink on deletion here to follow what NameDictionary and
-  // OrderedNameDictionary do. We should investigate which approach works
-  // better.
-  return Shrink(isolate, table);
-}
-
-// static
-template <typename LocalIsolate>
-Handle<SwissNameDictionary> SwissNameDictionary::Rehash(
-    LocalIsolate* isolate, Handle<SwissNameDictionary> table,
-    int new_capacity) {
-  DCHECK(IsValidCapacity(new_capacity));
-  DCHECK_LE(table->NumberOfElements(), MaxUsableCapacity(new_capacity));
-  ReadOnlyRoots roots(isolate);
-
-  Handle<SwissNameDictionary> new_table =
-      isolate->factory()->NewSwissNameDictionaryWithCapacity(
-          new_capacity, Heap::InYoungGeneration(*table) ? AllocationType::kYoung
-                                                        : AllocationType::kOld);
-
-  DisallowHeapAllocation no_gc;
-
-  int new_enum_index = 0;
-  new_table->SetNumberOfElements(table->NumberOfElements());
-  for (int enum_index = 0; enum_index < table->UsedCapacity(); ++enum_index) {
-    int entry = table->EntryForEnumerationIndex(enum_index);
-
-    Object key;
-
-    if (table->ToKey(roots, entry, &key)) {
-      Object value = table->ValueAtRaw(entry);
-      PropertyDetails details = table->DetailsAt(entry);
-
-      int new_entry = new_table->AddInternal(Name::cast(key), value, details);
-
-      // TODO(v8::11388) Investigate ways of hoisting the branching needed to
-      // select the correct meta table entry size (based on the capacity of the
-      // table) out of the loop.
-      new_table->SetEntryForEnumerationIndex(new_enum_index, new_entry);
-      ++new_enum_index;
-    }
-  }
-
-  new_table->SetHash(table->Hash());
-  return new_table;
-}
-
-// static
-Handle<SwissNameDictionary> SwissNameDictionary::Shrink(
-    Isolate* isolate, Handle<SwissNameDictionary> table) {
-  // TODO(v8:11388) We're using the same logic to decide whether or not to
-  // shrink as OrderedNameDictionary and NameDictionary here. We should compare
-  // this with the logic used by Abseil's flat_hash_map, which has a heuristic
-  // for triggering an (in-place) rehash on addition, but never shrinks the
-  // table. Abseil's heuristic doesn't take the numbere of deleted elements into
-  // account, because it doesn't track that.
-
-  int nof = table->NumberOfElements();
-  int capacity = table->Capacity();
-  if (nof >= (capacity >> 2)) return table;
-  int new_capacity = std::max(capacity / 2, kInitialCapacity);
-  return Rehash(isolate, table, new_capacity);
-}
-
 // 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

src/objects/swiss-name-dictionary.h

@@ -72,18 +72,6 @@ class SwissNameDictionary : public HeapObject {
  public:
   using Group = swiss_table::Group;
 
-  template <typename LocalIsolate>
-  inline static Handle<SwissNameDictionary> Add(
-      LocalIsolate* isolate, Handle<SwissNameDictionary> table,
-      Handle<Name> key, Handle<Object> value, PropertyDetails details,
-      InternalIndex* entry_out = nullptr);
-
-  static Handle<SwissNameDictionary> Shrink(Isolate* isolate,
-                                            Handle<SwissNameDictionary> table);
-
-  static Handle<SwissNameDictionary> DeleteEntry(
-      Isolate* isolate, Handle<SwissNameDictionary> table, InternalIndex entry);
-
   template <typename LocalIsolate>
   inline InternalIndex FindEntry(LocalIsolate* isolate, Object key);
 
@@ -115,11 +103,6 @@ class SwissNameDictionary : public HeapObject {
   template <typename LocalIsolate>
   void Initialize(LocalIsolate* isolate, ByteArray meta_table, int capacity);
 
-  template <typename LocalIsolate>
-  static Handle<SwissNameDictionary> Rehash(LocalIsolate* isolate,
-                                            Handle<SwissNameDictionary> table,
-                                            int new_capacity);
-
   inline void SetHash(int hash);
   inline int Hash();
 
@@ -235,10 +218,6 @@ class SwissNameDictionary : public HeapObject {
   using ctrl_t = swiss_table::ctrl_t;
   using Ctrl = swiss_table::Ctrl;
 
-  template <typename LocalIsolate>
-  inline static Handle<SwissNameDictionary> EnsureGrowable(
-      LocalIsolate* isolate, Handle<SwissNameDictionary> table);
-
   // Returns table of byte-encoded PropertyDetails (without enumeration index
   // stored in PropertyDetails).
   inline uint8_t* PropertyDetailsTable();
@@ -256,13 +235,6 @@ class SwissNameDictionary : public HeapObject {
 
   inline bool ToKey(ReadOnlyRoots roots, int entry, Object* out_key);
 
-  inline int FindFirstEmpty(uint32_t hash);
-  // Adds |key| ->  (|value|, |details|) as a new mapping to the table, which
-  // must have sufficient room. Returns the entry (= bucket) used by the new
-  // mapping. Does not update the number of present entries or the
-  // enumeration table.
-  inline int AddInternal(Name key, Object value, PropertyDetails details);
-
   // Use |set_ctrl| for modifications whenever possible, since that function
   // correctly maintains the copy of the first group at the end of the ctrl
   // table.