[compiler] Test insertion concurrency for TransitionArrays

In this test we both search and insert a transition in the main thread,
while the background thread searches.

Bug: v8:7790
Change-Id: Ic899f6c36c9bf9f7f5364ea30eb1c875b7ef6535
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2243211
Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#68878}

test/cctest/test-concurrent-transition-array.cc

@@ -5,7 +5,6 @@
 #include "src/api/api.h"
 #include "src/base/platform/semaphore.h"
 #include "src/handles/handles-inl.h"
-#include "src/handles/local-handles-inl.h"
 #include "src/handles/persistent-handles.h"
 #include "src/heap/heap.h"
 #include "src/heap/local-heap.h"
@@ -60,11 +59,11 @@ TEST(FullFieldTransitions_OnlySearch) {
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
 
-  Handle<String> name = CcTest::MakeString("foo");
+  Handle<String> name = CcTest::MakeString("name");
   const PropertyAttributes attributes = NONE;
   const PropertyKind kind = kData;
 
-  // Set map0 to be a full transition array with transition 'foo' to map1.
+  // Set map0 to be a full transition array with transition 'name' to map1.
   Handle<Map> map0 = Map::Create(isolate, 0);
   Handle<Map> map1 =
       Map::CopyWithField(isolate, map0, name, FieldType::Any(isolate),
@@ -79,9 +78,9 @@ TEST(FullFieldTransitions_OnlySearch) {
 
   std::unique_ptr<PersistentHandles> ph = isolate->NewPersistentHandles();
 
-  Handle<Name> persistent_name = Handle<Name>::cast(ph->NewHandle(name));
-  Handle<Map> persistent_map = Handle<Map>::cast(ph->NewHandle(map0));
-  Handle<Map> persistent_result_map = Handle<Map>::cast(ph->NewHandle(map1));
+  Handle<Name> persistent_name = ph->NewHandle(name);
+  Handle<Map> persistent_map = ph->NewHandle(map0);
+  Handle<Map> persistent_result_map = ph->NewHandle(map1);
 
   base::Semaphore sema_started(0);
 
@@ -99,6 +98,61 @@ TEST(FullFieldTransitions_OnlySearch) {
   thread->Join();
 }
 
+// Search and insert on the main thread, while the background thread searches at
+// the same time.
+TEST(FullFieldTransitions) {
+  CcTest::InitializeVM();
+  v8::HandleScope scope(CcTest::isolate());
+  Isolate* isolate = CcTest::i_isolate();
+
+  Handle<String> name1 = CcTest::MakeString("name1");
+  Handle<String> name2 = CcTest::MakeString("name2");
+  const PropertyAttributes attributes = NONE;
+  const PropertyKind kind = kData;
+
+  // Set map0 to be a full transition array with transition 'name1' to map1.
+  Handle<Map> map0 = Map::Create(isolate, 0);
+  Handle<Map> map1 =
+      Map::CopyWithField(isolate, map0, name1, FieldType::Any(isolate),
+                         attributes, PropertyConstness::kMutable,
+                         Representation::Tagged(), OMIT_TRANSITION)
+          .ToHandleChecked();
+  Handle<Map> map2 =
+      Map::CopyWithField(isolate, map0, name2, FieldType::Any(isolate),
+                         attributes, PropertyConstness::kMutable,
+                         Representation::Tagged(), OMIT_TRANSITION)
+          .ToHandleChecked();
+  TransitionsAccessor(isolate, map0).Insert(name1, map1, PROPERTY_TRANSITION);
+  {
+    TestTransitionsAccessor transitions(isolate, map0);
+    CHECK(transitions.IsFullTransitionArrayEncoding());
+  }
+
+  std::unique_ptr<PersistentHandles> ph = isolate->NewPersistentHandles();
+
+  Handle<Name> persistent_name = ph->NewHandle(name1);
+  Handle<Map> persistent_map = ph->NewHandle(map0);
+  Handle<Map> persistent_result_map = ph->NewHandle(map1);
+
+  base::Semaphore sema_started(0);
+
+  // Pass persistent handles to background thread.
+  std::unique_ptr<ConcurrentSearchThread> thread(new ConcurrentSearchThread(
+      isolate->heap(), &sema_started, std::move(ph), persistent_name,
+      persistent_map, persistent_result_map));
+  CHECK(thread->Start());
+
+  sema_started.Wait();
+
+  CHECK_EQ(*map1, TransitionsAccessor(isolate, map0)
+                      .SearchTransition(*name1, kind, attributes));
+  TransitionsAccessor(isolate, map0).Insert(name2, map2, PROPERTY_TRANSITION);
+  CHECK_EQ(*map2, TransitionsAccessor(isolate, map0)
+                      .SearchTransition(*name2, kind, attributes));
+
+  thread->Join();
+}
+
 }  // anonymous namespace
 
 }  // namespace internal