cppgc: Optimize compression by removing the branch and or-instruction

This is done by making sure that LSB of the cage-base is 1. This way we
know that on compression normal pointers after the shift will have the
MSB set to 1.

Bug: chromium:1325007
Change-Id: I8699aaa464f1a8c18d2092f5eb474266fb409fcb
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3688399
Commit-Queue: Anton Bikineev <bikineev@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/main@{#81039}

include/cppgc/member.h

@@ -100,14 +100,11 @@ class CompressedPointer final {
                      (reinterpret_cast<uintptr_t>(ptr) & kGigaCageMask));
 
     const auto uptr = reinterpret_cast<uintptr_t>(ptr);
-    // Truncate the pointer and shift right by one.
-    auto compressed = static_cast<Storage>(uptr) >> 1;
-    // If the pointer is regular, set the most significant bit.
-    if (V8_LIKELY(compressed > 1)) {
-      CPPGC_DCHECK((reinterpret_cast<uintptr_t>(ptr) &
-                    (api_constants::kAllocationGranularity - 1)) == 0);
-      compressed |= 0x80000000;
-    }
+    // Shift the pointer by one and truncate.
+    auto compressed = static_cast<Storage>(uptr >> 1);
+    // Normal compressed pointers must have the MSB set.
+    CPPGC_DCHECK((!compressed || compressed == kCompressedSentinel) ||
+                 (compressed & 0x80000000));
     return compressed;
   }
 

src/heap/cppgc/caged-heap.cc

@@ -47,13 +47,35 @@ VirtualMemory ReserveCagedHeap(PageAllocator& platform_allocator) {
 
   static constexpr size_t kAllocationTries = 4;
   for (size_t i = 0; i < kAllocationTries; ++i) {
+#if defined(CPPGC_POINTER_COMPRESSION)
+    // If pointer compression is enabled, reserve 2x of cage size and leave the
+    // half that has the least significant bit of the most significant halfword
+    // set. This is needed for compression to make sure that compressed normal
+    // pointers have the most significant bit set to 1, so that on decompression
+    // the bit will be sign-extended. This saves us a branch and 'or' operation
+    // during compression.
+    static constexpr size_t kTryReserveSize = 2 * kCagedHeapReservationSize;
+    static constexpr size_t kTryReserveAlignment =
+        2 * kCagedHeapReservationAlignment;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+    static constexpr size_t kTryReserveSize = kCagedHeapReservationSize;
+    static constexpr size_t kTryReserveAlignment =
+        kCagedHeapReservationAlignment;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
     void* hint = reinterpret_cast<void*>(RoundDown(
         reinterpret_cast<uintptr_t>(platform_allocator.GetRandomMmapAddr()),
-        kCagedHeapReservationAlignment));
+        kTryReserveAlignment));
 
-    VirtualMemory memory(&platform_allocator, kCagedHeapReservationSize,
-                         kCagedHeapReservationAlignment, hint);
-    if (memory.IsReserved()) return memory;
+    VirtualMemory memory(&platform_allocator, kTryReserveSize,
+                         kTryReserveAlignment, hint);
+    if (memory.IsReserved()) {
+#if defined(CPPGC_POINTER_COMPRESSION)
+      VirtualMemory second_half = memory.Split(kCagedHeapReservationSize);
+      return second_half;
+#else   // !defined(CPPGC_POINTER_COMPRESSION)
+      return memory;
+#endif  // !defined(CPPGC_POINTER_COMPRESSION)
+    }
   }
 
   FATAL("Fatal process out of memory: Failed to reserve memory for caged heap");

src/heap/cppgc/virtual-memory.cc

@@ -47,6 +47,21 @@ VirtualMemory& VirtualMemory::operator=(VirtualMemory&& other) V8_NOEXCEPT {
   return *this;
 }
 
+VirtualMemory VirtualMemory::Split(size_t size) {
+  DCHECK_GT(size, 0u);
+  DCHECK_LT(size, size_);
+  DCHECK(IsAligned(size, page_allocator_->CommitPageSize()));
+
+  const size_t old_size = std::exchange(size_, size);
+
+  VirtualMemory new_memory;
+  new_memory.page_allocator_ = page_allocator_;
+  new_memory.start_ = reinterpret_cast<uint8_t*>(start_) + size_;
+  new_memory.size_ = old_size - size;
+
+  return new_memory;
+}
+
 void VirtualMemory::Reset() {
   start_ = nullptr;
   size_ = 0;

src/heap/cppgc/virtual-memory.h

@@ -32,6 +32,9 @@ class V8_EXPORT_PRIVATE VirtualMemory {
   VirtualMemory(VirtualMemory&&) V8_NOEXCEPT;
   VirtualMemory& operator=(VirtualMemory&&) V8_NOEXCEPT;
 
+  // Splits the current reservation and returns the residual one.
+  VirtualMemory Split(size_t size);
+
   // Returns whether the memory has been reserved.
   bool IsReserved() const { return start_ != nullptr; }