deps: V8: cherry-pick 7f80b64d1443

Original commit message:

    [base] Optimize Relaxed_Memset with word-sized atomic stores

    When filling memory with relaxed atomic stores for types smaller than
    a word (e.g., Tagged_t) clang does not merge the stores.

    This change optimizes Relaxed_Memset to store word-sized chunks
    after an alignment prologue and before a trailing epilogue.

    __attribute__((may_alias)) is used since otherwise aliasing pointers
    of different size are UB in C++.

    On x64 release builds, this achieves ~1.7x speedup for
    Array.prototype.fill with Smi value.

    Bug: 540352782
    TAG=agy
    CONV=d5bd36e5-0b77-41b5-8bfb-68b320ea0546

    Change-Id: I3be81d687d30a13c67ffed6cd4a6b4366411a6f6
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8177163
    Commit-Queue: Nico Hartmann <nicohartmann@chromium.org>
    Reviewed-by: Nico Hartmann <nicohartmann@chromium.org>
    Auto-Submit: Olivier Flückiger <olivf@chromium.org>
    Cr-Commit-Position: refs/heads/main@{#109025}

Refs: v8/v8@7f80b64

Author: o-

common.gypi

@@ -44,7 +44,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.22',
+    'v8_embedder_string': '-node.23',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/src/base/memcopy.h

@@ -9,6 +9,8 @@
 
 #include <algorithm>
 #include <atomic>
+#include <limits>
+#include <type_traits>
 
 #include "include/v8config.h"
 #include "src/base/base-export.h"
@@ -215,11 +217,59 @@ inline void MemCopyAndSwitchEndianness(void* dst, const void* src,
 }
 #endif
 
+// Helper to replicate an integral `value` across all bytes of a uintptr_t word.
+template <typename T>
+  requires std::is_integral_v<T>
+constexpr uintptr_t ReplicateValueWord(T value) {
+  if constexpr (sizeof(T) >= sizeof(uintptr_t)) {
+    return static_cast<uintptr_t>(value);
+  } else {
+    using UnsignedT = std::conditional_t<
+        sizeof(T) == 1, uint8_t,
+        std::conditional_t<
+            sizeof(T) == 2, uint16_t,
+            std::conditional_t<sizeof(T) == 4, uint32_t, uint64_t>>>;
+    constexpr uintptr_t kMultiplier =
+        static_cast<uintptr_t>(-1) / std::numeric_limits<UnsignedT>::max();
+    return static_cast<uintptr_t>(static_cast<UnsignedT>(value)) * kMultiplier;
+  }
+}
+
 // Fills `destination` with `count` `value`s.
 template <typename T>
-inline void Relaxed_Memset(T* destination, T value, size_t count)
+V8_INLINE void Relaxed_Memset(T* destination, T value, size_t count)
   requires std::is_integral_v<T>
 {
+#if defined(__ATOMIC_RELAXED) && (defined(__GNUC__) || defined(__clang__))
+  if constexpr (sizeof(T) < sizeof(uintptr_t)) {
+    constexpr size_t kElementsPerWord = sizeof(uintptr_t) / sizeof(T);
+    // Prologue: store elements until `destination` is word-aligned.
+    while (reinterpret_cast<uintptr_t>(destination) % sizeof(uintptr_t) != 0 &&
+           count > 0) {
+      std::atomic_ref<T>(*destination).store(value, std::memory_order_relaxed);
+      destination++;
+      count--;
+    }
+    // Main loop: store word-sized chunks using may_alias attribute and
+    // __atomic_store_n.
+    using AliasedWord = uintptr_t __attribute__((may_alias));
+    const uintptr_t word_val = ReplicateValueWord<T>(value);
+    AliasedWord* word_dest = reinterpret_cast<AliasedWord*>(destination);
+    size_t words = count / kElementsPerWord;
+    for (size_t w = 0; w < words; w++) {
+      __atomic_store_n(word_dest + w, word_val, __ATOMIC_RELAXED);
+    }
+    destination += words * kElementsPerWord;
+    count -= words * kElementsPerWord;
+    // Epilogue: store remaining trailing elements.
+    while (count > 0) {
+      std::atomic_ref<T>(*destination).store(value, std::memory_order_relaxed);
+      destination++;
+      count--;
+    }
+    return;
+  }
+#endif
   for (size_t i = 0; i < count; i++) {
     std::atomic_ref<T>(destination[i]).store(value, std::memory_order_relaxed);
   }

deps/v8/test/unittests/base/atomic-utils-unittest.cc

@@ -2,9 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/base/atomic-utils.h"
+
 #include <limits.h>
 
-#include "src/base/atomic-utils.h"
+#include "src/base/memcopy.h"
 #include "src/base/platform/platform.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -236,5 +238,70 @@ TEST(AsAtomicWord, SetBits_Concurrent) {
   }
 }
 
+template <typename T>
+void TestRelaxedMemsetHelper(T value, T sentinel) {
+  constexpr int kBufferSize = 64;
+  for (int offset = 0; offset < 8; ++offset) {
+    for (int count = 0; count < 32; ++count) {
+      if (offset + count > kBufferSize) continue;
+      alignas(8) T buffer[kBufferSize];
+      for (int i = 0; i < kBufferSize; ++i) {
+        buffer[i] = sentinel;
+      }
+      Relaxed_Memset(&buffer[offset], value, count);
+      for (int i = 0; i < kBufferSize; ++i) {
+        if (i >= offset && i < offset + count) {
+          EXPECT_EQ(value, buffer[i])
+              << "offset=" << offset << " count=" << count << " i=" << i;
+        } else {
+          EXPECT_EQ(sentinel, buffer[i])
+              << "offset=" << offset << " count=" << count << " i=" << i;
+        }
+      }
+    }
+  }
+}
+
+TEST(RelaxedMemset, VariousTypesAndAlignments) {
+  TestRelaxedMemsetHelper<uint8_t>(0xAB, 0x12);
+  TestRelaxedMemsetHelper<uint16_t>(0xABCD, 0x1234);
+  TestRelaxedMemsetHelper<uint32_t>(0xABCDEF01u, 0x12345678u);
+  TestRelaxedMemsetHelper<uint64_t>(0xABCDEF0123456789ULL,
+                                    0x1111222233334444ULL);
+  TestRelaxedMemsetHelper<int8_t>(-1, 0);
+  TestRelaxedMemsetHelper<int32_t>(-123456, 789);
+}
+
+TEST(RelaxedMemset, ConstexprReplicatedWord) {
+  static_assert(ReplicateValueWord<uint8_t>(0xAB) ==
+#if V8_HOST_ARCH_64_BIT
+                0xABABABABABABABABULL
+#else
+                0xABABABABu
+#endif
+  );
+  static_assert(ReplicateValueWord<uint16_t>(0x1234) ==
+#if V8_HOST_ARCH_64_BIT
+                0x1234123412341234ULL
+#else
+                0x12341234u
+#endif
+  );
+
+  constexpr int kBufferSize = 32;
+  alignas(8) uint8_t buffer[kBufferSize];
+  for (int i = 0; i < kBufferSize; ++i) {
+    buffer[i] = 0xFF;
+  }
+  Relaxed_Memset<uint8_t>(&buffer[1], 0x42, 15);
+  EXPECT_EQ(0xFF, buffer[0]);
+  for (int i = 1; i < 16; ++i) {
+    EXPECT_EQ(0x42, buffer[i]);
+  }
+  for (int i = 16; i < kBufferSize; ++i) {
+    EXPECT_EQ(0xFF, buffer[i]);
+  }
+}
+
 }  // namespace base
 }  // namespace v8