deps: update V8 to 6.5.254.31

PR-URL: https://github.com/nodejs/node/pull/18453
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Yang Guo <yangguo@chromium.org>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>

3 files changed, 129 insertions, 8 deletions

diff --git a/deps/v8/test/unittests/heap/gc-tracer-unittest.cc b/deps/v8/test/unittests/heap/gc-tracer-unittest.cc
index e7702fda75..e4e9260881 100644
--- a/deps/v8/test/unittests/heap/gc-tracer-unittest.cc
+++ b/deps/v8/test/unittests/heap/gc-tracer-unittest.cc
@@ -5,6 +5,7 @@
 #include <cmath>
 #include <limits>
 
+#include "src/base/platform/platform.h"
 #include "src/globals.h"
 #include "src/heap/gc-tracer.h"
 #include "src/isolate.h"
@@ -294,5 +295,125 @@ TEST_F(GCTracerTest, IncrementalMarkingSpeed) {
                        tracer->IncrementalMarkingSpeedInBytesPerMillisecond()));
 }
 
+TEST_F(GCTracerTest, BackgroundScavengerScope) {
+  GCTracer* tracer = i_isolate()->heap()->tracer();
+  tracer->ResetForTesting();
+  tracer->Start(SCAVENGER, GarbageCollectionReason::kTesting,
+                "collector unittest");
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::SCAVENGER_BACKGROUND_SCAVENGE_PARALLEL, 10,
+      nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::SCAVENGER_BACKGROUND_SCAVENGE_PARALLEL, 1,
+      nullptr);
+  tracer->Stop(SCAVENGER);
+  EXPECT_DOUBLE_EQ(
+      11, tracer->current_
+              .scopes[GCTracer::Scope::SCAVENGER_BACKGROUND_SCAVENGE_PARALLEL]);
+}
+
+TEST_F(GCTracerTest, BackgroundMinorMCScope) {
+  GCTracer* tracer = i_isolate()->heap()->tracer();
+  tracer->ResetForTesting();
+  tracer->Start(MINOR_MARK_COMPACTOR, GarbageCollectionReason::kTesting,
+                "collector unittest");
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MINOR_MC_BACKGROUND_MARKING, 10, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MINOR_MC_BACKGROUND_MARKING, 1, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MINOR_MC_BACKGROUND_EVACUATE_COPY, 20,
+      nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MINOR_MC_BACKGROUND_EVACUATE_COPY, 2, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MINOR_MC_BACKGROUND_EVACUATE_UPDATE_POINTERS,
+      30, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MINOR_MC_BACKGROUND_EVACUATE_UPDATE_POINTERS,
+      3, nullptr);
+  tracer->Stop(MINOR_MARK_COMPACTOR);
+  EXPECT_DOUBLE_EQ(
+      11,
+      tracer->current_.scopes[GCTracer::Scope::MINOR_MC_BACKGROUND_MARKING]);
+  EXPECT_DOUBLE_EQ(
+      22, tracer->current_
+              .scopes[GCTracer::Scope::MINOR_MC_BACKGROUND_EVACUATE_COPY]);
+  EXPECT_DOUBLE_EQ(
+      33, tracer->current_.scopes
+              [GCTracer::Scope::MINOR_MC_BACKGROUND_EVACUATE_UPDATE_POINTERS]);
+}
+
+TEST_F(GCTracerTest, BackgroundMajorMCScope) {
+  GCTracer* tracer = i_isolate()->heap()->tracer();
+  tracer->ResetForTesting();
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_MARKING, 100, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_SWEEPING, 200, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_MARKING, 10, nullptr);
+  // Scavenger should not affect the major mark-compact scopes.
+  tracer->Start(SCAVENGER, GarbageCollectionReason::kTesting,
+                "collector unittest");
+  tracer->Stop(SCAVENGER);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_SWEEPING, 20, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_MARKING, 1, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_SWEEPING, 2, nullptr);
+  tracer->Start(MARK_COMPACTOR, GarbageCollectionReason::kTesting,
+                "collector unittest");
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_EVACUATE_COPY, 30, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_EVACUATE_COPY, 3, nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_EVACUATE_UPDATE_POINTERS, 40,
+      nullptr);
+  tracer->AddBackgroundScopeSample(
+      GCTracer::BackgroundScope::MC_BACKGROUND_EVACUATE_UPDATE_POINTERS, 4,
+      nullptr);
+  tracer->Stop(MARK_COMPACTOR);
+  EXPECT_DOUBLE_EQ(
+      111, tracer->current_.scopes[GCTracer::Scope::MC_BACKGROUND_MARKING]);
+  EXPECT_DOUBLE_EQ(
+      222, tracer->current_.scopes[GCTracer::Scope::MC_BACKGROUND_SWEEPING]);
+  EXPECT_DOUBLE_EQ(
+      33,
+      tracer->current_.scopes[GCTracer::Scope::MC_BACKGROUND_EVACUATE_COPY]);
+  EXPECT_DOUBLE_EQ(
+      44, tracer->current_
+              .scopes[GCTracer::Scope::MC_BACKGROUND_EVACUATE_UPDATE_POINTERS]);
+}
+
+class ThreadWithBackgroundScope final : public base::Thread {
+ public:
+  explicit ThreadWithBackgroundScope(GCTracer* tracer)
+      : Thread(Options("ThreadWithBackgroundScope")), tracer_(tracer) {}
+  void Run() override {
+    GCTracer::BackgroundScope scope(
+        tracer_, GCTracer::BackgroundScope::MC_BACKGROUND_MARKING);
+  }
+
+ private:
+  GCTracer* tracer_;
+};
+
+TEST_F(GCTracerTest, MultithreadedBackgroundScope) {
+  GCTracer* tracer = i_isolate()->heap()->tracer();
+  ThreadWithBackgroundScope thread1(tracer);
+  ThreadWithBackgroundScope thread2(tracer);
+  tracer->ResetForTesting();
+  thread1.Start();
+  thread2.Start();
+  tracer->FetchBackgroundMarkCompactCounters();
+  thread1.Join();
+  thread2.Join();
+  tracer->FetchBackgroundMarkCompactCounters();
+  EXPECT_LE(0, tracer->current_.scopes[GCTracer::Scope::MC_BACKGROUND_MARKING]);
+}
+
 }  // namespace internal
 }  // namespace v8
diff --git a/deps/v8/test/unittests/heap/heap-unittest.cc b/deps/v8/test/unittests/heap/heap-unittest.cc
index 3b7b610c8c..c63aa2b724 100644
--- a/deps/v8/test/unittests/heap/heap-unittest.cc
+++ b/deps/v8/test/unittests/heap/heap-unittest.cc
@@ -99,7 +99,7 @@ TEST_F(HeapTest, ASLR) {
   }
   if (hints.size() == 1) {
     EXPECT_TRUE((*hints.begin()) == nullptr);
-    EXPECT_TRUE(base::OS::GetRandomMmapAddr() == nullptr);
+    EXPECT_TRUE(i::GetRandomMmapAddr() == nullptr);
   } else {
     // It is unlikely that 1000 random samples will collide to less then 500
     // values.
diff --git a/deps/v8/test/unittests/heap/marking-unittest.cc b/deps/v8/test/unittests/heap/marking-unittest.cc
index 9dd432c175..0553dc0ea5 100644
--- a/deps/v8/test/unittests/heap/marking-unittest.cc
+++ b/deps/v8/test/unittests/heap/marking-unittest.cc
@@ -63,7 +63,7 @@ TEST(Marking, SetAndClearRange) {
       calloc(Bitmap::kSize / kPointerSize, kPointerSize));
   for (int i = 0; i < 3; i++) {
     bitmap->SetRange(i, Bitmap::kBitsPerCell + i);
-    CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[0], 0xffffffffu << i);
+    CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[0], 0xFFFFFFFFu << i);
     CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[1], (1u << i) - 1);
     bitmap->ClearRange(i, Bitmap::kBitsPerCell + i);
     CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[0], 0x0u);
@@ -77,9 +77,9 @@ TEST(Marking, ClearMultipleRanges) {
       calloc(Bitmap::kSize / kPointerSize, kPointerSize));
   CHECK(bitmap->AllBitsClearInRange(0, Bitmap::kBitsPerCell * 3));
   bitmap->SetRange(0, Bitmap::kBitsPerCell * 3);
-  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[0], 0xffffffffu);
-  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[1], 0xffffffffu);
-  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[2], 0xffffffffu);
+  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[0], 0xFFFFFFFFu);
+  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[1], 0xFFFFFFFFu);
+  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[2], 0xFFFFFFFFu);
   CHECK(bitmap->AllBitsSetInRange(0, Bitmap::kBitsPerCell * 3));
   bitmap->ClearRange(Bitmap::kBitsPerCell / 2, Bitmap::kBitsPerCell);
   bitmap->ClearRange(Bitmap::kBitsPerCell,
@@ -87,17 +87,17 @@ TEST(Marking, ClearMultipleRanges) {
   bitmap->ClearRange(Bitmap::kBitsPerCell * 2 + 8,
                      Bitmap::kBitsPerCell * 2 + 16);
   bitmap->ClearRange(Bitmap::kBitsPerCell * 2 + 24, Bitmap::kBitsPerCell * 3);
-  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[0], 0xffffu);
+  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[0], 0xFFFFu);
   CHECK(bitmap->AllBitsSetInRange(0, Bitmap::kBitsPerCell / 2));
   CHECK(bitmap->AllBitsClearInRange(Bitmap::kBitsPerCell / 2,
                                     Bitmap::kBitsPerCell));
-  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[1], 0xffff0000u);
+  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[1], 0xFFFF0000u);
   CHECK(
       bitmap->AllBitsSetInRange(Bitmap::kBitsPerCell + Bitmap::kBitsPerCell / 2,
                                 2 * Bitmap::kBitsPerCell));
   CHECK(bitmap->AllBitsClearInRange(
       Bitmap::kBitsPerCell, Bitmap::kBitsPerCell + Bitmap::kBitsPerCell / 2));
-  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[2], 0xff00ffu);
+  CHECK_EQ(reinterpret_cast<uint32_t*>(bitmap)[2], 0xFF00FFu);
   CHECK(bitmap->AllBitsSetInRange(2 * Bitmap::kBitsPerCell,
                                   2 * Bitmap::kBitsPerCell + 8));
   CHECK(bitmap->AllBitsClearInRange(2 * Bitmap::kBitsPerCell + 24,