deps: V8: cherry-pick 92ac9425fa52

Original commit message:

    [profiler] Adjustable heap profiler sampling interval

    This change makes the V8 sampling heap profiler interval adjustable
    while heap sampling is running. Today, the sampling interval is fixed
    for the whole profiling session. Developers who want to adapt sampling
    under high allocation load have to stop the profiler and start it again
    with a new interval, which loses continuity.

    This PR adds a small API surface for adaptive heap sampling:

    - SetSamplingHeapProfilerInterval(sample_interval) updates the active sampling interval.
    - GetSamplingHeapProfilerSamples() returns the current retained samples without materializing the full allocation profile tree.
    - AllocationProfile::Sample now includes sample_interval, so consumers know which interval was used when the sample was generated.

    The new sample getter is intended for lightweight polling. It avoids the
    extra work done by GetAllocationProfile(), such as translating the
    allocation tree and resolving script metadata, when callers only need
    sample information.

    This keeps the adaptive policy outside V8: embedders can decide how to
    adjust the interval, while V8 exposes the mechanism needed to do it.

    Change-Id: I7cff46a13c02617d04149c8d5c273a8d9ef4bb9f
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8130742
    Reviewed-by: Camillo Bruni <cbruni@chromium.org>
    Commit-Queue: Dominik Inführ <dinfuehr@chromium.org>
    Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
    Cr-Commit-Position: refs/heads/main@{#109934}

Refs: v8/v8@92ac942
Signed-off-by: ishabi <ilyasshabi94@gmail.com>

Author: IlyasShabi

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.24',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/include/v8-profiler.h

@@ -836,6 +836,11 @@ class V8_EXPORT AllocationProfile {
      * been collected by GC.
      */
     bool is_live;
+
+    /**
+     * Sample interval in bytes used when this sample was selected.
+     */
+    uint64_t sample_interval;
   };
 
   /**
@@ -1257,6 +1262,22 @@ class V8_EXPORT HeapProfiler {
    */
   void StopSamplingHeapProfiler();
 
+  /**
+   * Updates the sampling interval for a currently running sampling heap
+   * profiler. The new interval is used for future sample scheduling.
+   *
+   * No-op if the sampling heap profiler is not running.
+   */
+  void SetSamplingHeapProfilerInterval(uint64_t sample_interval);
+
+  /**
+   * Returns the currently retained allocation samples without materializing
+   * the full allocation profile tree.
+   *
+   * Returns an empty vector if the sampling heap profiler is not running.
+   */
+  std::vector<AllocationProfile::Sample> GetSamplingHeapProfilerSamples();
+
   /**
    * Returns the sampled profile of allocations allocated (and still live) since
    * StartSamplingHeapProfiler was called. The ownership of the pointer is

deps/v8/src/api/api.cc

@@ -12098,6 +12098,17 @@ void HeapProfiler::StopSamplingHeapProfiler() {
   reinterpret_cast<i::HeapProfiler*>(this)->StopSamplingHeapProfiler();
 }
 
+void HeapProfiler::SetSamplingHeapProfilerInterval(uint64_t sample_interval) {
+  reinterpret_cast<i::HeapProfiler*>(this)->SetSamplingHeapProfilerInterval(
+      sample_interval);
+}
+
+std::vector<AllocationProfile::Sample>
+HeapProfiler::GetSamplingHeapProfilerSamples() {
+  return reinterpret_cast<i::HeapProfiler*>(this)
+      ->GetSamplingHeapProfilerSamples();
+}
+
 AllocationProfile* HeapProfiler::GetAllocationProfile() {
   return reinterpret_cast<i::HeapProfiler*>(this)->GetAllocationProfile();
 }

deps/v8/src/profiler/heap-profiler.cc

@@ -236,6 +236,18 @@ void HeapProfiler::StopSamplingHeapProfiler() {
   MaybeClearStringsStorage();
 }
 
+void HeapProfiler::SetSamplingHeapProfilerInterval(uint64_t sample_interval) {
+  if (sampling_heap_profiler_) {
+    sampling_heap_profiler_->SetSamplingInterval(sample_interval);
+  }
+}
+
+std::vector<v8::AllocationProfile::Sample>
+HeapProfiler::GetSamplingHeapProfilerSamples() {
+  if (!sampling_heap_profiler_) return {};
+  return sampling_heap_profiler_->GetSamples();
+}
+
 v8::AllocationProfile* HeapProfiler::GetAllocationProfile() {
   if (sampling_heap_profiler_) {
     return sampling_heap_profiler_->GetAllocationProfile();

deps/v8/src/profiler/heap-profiler.h

@@ -83,6 +83,8 @@ class HeapProfiler : public HeapObjectAllocationTracker {
   bool StartSamplingHeapProfiler(uint64_t sample_interval, int stack_depth,
                                  v8::HeapProfiler::SamplingFlags);
   void StopSamplingHeapProfiler();
+  void SetSamplingHeapProfilerInterval(uint64_t sample_interval);
+  std::vector<v8::AllocationProfile::Sample> GetSamplingHeapProfilerSamples();
   bool is_sampling_allocations() { return !!sampling_heap_profiler_; }
   AllocationProfile* GetAllocationProfile();
 

deps/v8/src/profiler/sampling-heap-profiler.cc

@@ -41,13 +41,14 @@ intptr_t SamplingHeapProfiler::Observer::GetNextSampleInterval(uint64_t rate) {
 // Samples were collected according to a poisson process. Since we have not
 // recorded all allocations, we must approximate the shape of the underlying
 // space of allocations based on the samples we have collected. Given that
-// we sample at rate R, the probability that an allocation of size S will be
-// sampled is 1-exp(-S/R). This function uses the above probability to
+// we sample at interval I, the probability that an allocation of size S will
+// be sampled is 1-exp(-S/I). This function uses the above probability to
 // approximate the true number of allocations with size *size* given that
 // *count* samples were observed.
 v8::AllocationProfile::Allocation SamplingHeapProfiler::ScaleSample(
-    size_t size, unsigned int count) const {
-  double scale = 1.0 / (1.0 - std::exp(-static_cast<double>(size) / rate_));
+    size_t size, unsigned int count, uint64_t sample_interval) const {
+  double scale =
+      1.0 / (1.0 - std::exp(-static_cast<double>(size) / sample_interval));
   // Round count instead of truncating.
   return {size, static_cast<unsigned int>(count * scale + 0.5)};
 }
@@ -57,15 +58,15 @@ SamplingHeapProfiler::SamplingHeapProfiler(
     v8::HeapProfiler::SamplingFlags flags)
     : isolate_(Isolate::FromHeap(heap)),
       heap_(heap),
-      allocation_observer_(heap_, static_cast<intptr_t>(rate), rate, this,
+      allocation_observer_(heap_, static_cast<intptr_t>(rate), this,
                            isolate_->random_number_generator()),
       names_(names),
       profile_root_(nullptr, "(root)", v8::UnboundScript::kNoScriptId, 0,
                     next_node_id()),
       stack_depth_(stack_depth),
-      rate_(rate),
+      interval_(rate),
       flags_(flags) {
-  CHECK_GT(rate_, 0u);
+  CHECK_GT(interval_.load(std::memory_order_relaxed), 0u);
   heap_->AddAllocationObserversToAllSpaces(&allocation_observer_,
                                            &allocation_observer_);
 }
@@ -94,10 +95,14 @@ void SamplingHeapProfiler::SampleObject(Address soon_object, size_t size) {
           TrustedHeapLayout::InTrustedSpace(heap_object) || !IsTheHole(*obj)));
   auto loc = Local<v8::Value>::FromSlot(obj.location());
 
+  // Record the current sampling interval so that this sample is scaled
+  // with the exact weight in effect at draw time.
+  const uint64_t interval_at_sample =
+      interval_.load(std::memory_order_relaxed);
   AllocationNode* node = AddStack();
-  node->allocations_[size]++;
-  auto sample =
-      std::make_unique<Sample>(size, node, loc, this, next_sample_id());
+  node->allocations_[{size, interval_at_sample}]++;
+  auto sample = std::make_unique<Sample>(size, node, loc, this,
+                                         next_sample_id(), interval_at_sample);
   sample->global.SetWeak(sample.get(), OnWeakCallback,
                          WeakCallbackType::kParameter);
   samples_.emplace(sample.get(), std::move(sample));
@@ -120,10 +125,11 @@ void SamplingHeapProfiler::OnWeakCallback(
     return;
   }
   AllocationNode* node = sample->owner;
-  DCHECK_GT(node->allocations_[sample->size], 0);
-  node->allocations_[sample->size]--;
-  if (node->allocations_[sample->size] == 0) {
-    node->allocations_.erase(sample->size);
+  const auto key = std::make_pair(sample->size, sample->sample_interval);
+  DCHECK_GT(node->allocations_[key], 0u);
+  node->allocations_[key]--;
+  if (node->allocations_[key] == 0) {
+    node->allocations_.erase(key);
     while (node->allocations_.empty() && node->children_.empty() &&
            node->parent_ && !node->parent_->pinned_) {
       AllocationNode* parent = node->parent_;
@@ -263,8 +269,15 @@ v8::AllocationProfile::Node* SamplingHeapProfiler::TranslateAllocationNode(
       column = pos_info.column + 1;
     }
   }
-  for (auto alloc : node->allocations_) {
-    allocations.push_back(ScaleSample(alloc.first, alloc.second));
+  // Entries are keyed by (size, interval). Scale each with its own interval,
+  // then merge by size for the public per-size Allocation output.
+  std::map<size_t, unsigned int> per_size;
+  for (const auto& [key, count] : node->allocations_) {
+    const auto& [size, interval] = key;
+    per_size[size] += ScaleSample(size, count, interval).count;
+  }
+  for (const auto& [size, count] : per_size) {
+    allocations.push_back({size, count});
   }
 
   profile->nodes_.push_back(v8::AllocationProfile::Node{
@@ -315,11 +328,25 @@ SamplingHeapProfiler::BuildSamples() const {
     const Sample* sample = it.second.get();
     const bool is_live = !sample->global.IsEmpty();
     samples.emplace_back(v8::AllocationProfile::Sample{
-        sample->owner->id_, sample->size, ScaleSample(sample->size, 1).count,
-        sample->sample_id, is_live});
+        sample->owner->id_, sample->size,
+        ScaleSample(sample->size, 1, sample->sample_interval).count,
+        sample->sample_id, is_live, sample->sample_interval});
   }
   return samples;
 }
 
+std::vector<v8::AllocationProfile::Sample> SamplingHeapProfiler::GetSamples() {
+  if (flags_ & v8::HeapProfiler::kSamplingForceGC) {
+    isolate_->heap()->CollectAllGarbage(
+        GCFlag::kNoFlags, GarbageCollectionReason::kSamplingProfiler);
+  }
+  return BuildSamples();
+}
+
+void SamplingHeapProfiler::SetSamplingInterval(uint64_t sample_interval) {
+  CHECK_GT(sample_interval, 0u);
+  interval_.store(sample_interval, std::memory_order_relaxed);
+}
+
 }  // namespace internal
 }  // namespace v8

deps/v8/src/profiler/sampling-heap-profiler.h

@@ -5,10 +5,12 @@
 #ifndef V8_PROFILER_SAMPLING_HEAP_PROFILER_H_
 #define V8_PROFILER_SAMPLING_HEAP_PROFILER_H_
 
+#include <atomic>
 #include <deque>
 #include <map>
 #include <memory>
 #include <unordered_map>
+#include <vector>
 
 #include "include/v8-profiler.h"
 #include "src/heap/heap.h"
@@ -85,9 +87,12 @@ class SamplingHeapProfiler {
     }
 
    private:
+    // Keyed by (allocation size, sampling interval at draw time) so that
+    // samples drawn under different intervals are scaled with the correct
+    // weight when the tree is translated.
     // TODO(alph): make use of unordered_map's here. Pay attention to
     // iterator invalidation during TranslateAllocationNode.
-    std::map<size_t, unsigned int> allocations_;
+    std::map<std::pair<size_t, uint64_t>, unsigned int> allocations_;
     std::map<FunctionId, std::unique_ptr<AllocationNode>> children_;
     AllocationNode* const parent_;
     const int script_id_;
@@ -101,19 +106,22 @@ class SamplingHeapProfiler {
 
   struct Sample {
     Sample(size_t size_, AllocationNode* owner_, Local<Value> local_,
-           SamplingHeapProfiler* profiler_, uint64_t sample_id)
+           SamplingHeapProfiler* profiler_, uint64_t sample_id_,
+           uint64_t sample_interval_)
         : size(size_),
           owner(owner_),
           global(reinterpret_cast<v8::Isolate*>(profiler_->isolate_), local_),
           profiler(profiler_),
-          sample_id(sample_id) {}
+          sample_id(sample_id_),
+          sample_interval(sample_interval_) {}
     Sample(const Sample&) = delete;
     Sample& operator=(const Sample&) = delete;
     const size_t size;
     AllocationNode* const owner;
     Global<Value> global;
     SamplingHeapProfiler* const profiler;
     const uint64_t sample_id;
+    const uint64_t sample_interval;
   };
 
   SamplingHeapProfiler(Heap* heap, StringsStorage* names, uint64_t rate,
@@ -123,19 +131,21 @@ class SamplingHeapProfiler {
   SamplingHeapProfiler& operator=(const SamplingHeapProfiler&) = delete;
 
   v8::AllocationProfile* GetAllocationProfile();
+
+  void SetSamplingInterval(uint64_t sample_interval);
+  std::vector<v8::AllocationProfile::Sample> GetSamples();
+
   StringsStorage* names() const { return names_; }
 
  private:
   class Observer : public AllocationObserver {
    public:
-    Observer(Heap* heap, intptr_t step_size, uint64_t rate,
-             SamplingHeapProfiler* profiler,
+    Observer(Heap* heap, intptr_t step_size, SamplingHeapProfiler* profiler,
              base::RandomNumberGenerator* random)
         : AllocationObserver(step_size),
           profiler_(profiler),
           heap_(heap),
-          random_(random),
-          rate_(rate) {}
+          random_(random) {}
 
    protected:
     void Step(int bytes_allocated, Address soon_object, size_t size) override {
@@ -148,14 +158,16 @@ class SamplingHeapProfiler {
       }
     }
 
-    intptr_t GetNextStepSize() override { return GetNextSampleInterval(rate_); }
+    intptr_t GetNextStepSize() override {
+      return GetNextSampleInterval(
+          profiler_->interval_.load(std::memory_order_relaxed));
+    }
 
    private:
     intptr_t GetNextSampleInterval(uint64_t rate);
     SamplingHeapProfiler* const profiler_;
     Heap* const heap_;
     base::RandomNumberGenerator* const random_;
-    uint64_t const rate_;
   };
 
   void SampleObject(Address soon_object, size_t size);
@@ -179,8 +191,8 @@ class SamplingHeapProfiler {
   v8::AllocationProfile::Node* TranslateAllocationNode(
       AllocationProfile* profile, SamplingHeapProfiler::AllocationNode* node,
       const std::map<int, Handle<Script>>& scripts);
-  v8::AllocationProfile::Allocation ScaleSample(size_t size,
-                                                unsigned int count) const;
+  v8::AllocationProfile::Allocation ScaleSample(size_t size, unsigned int count,
+                                                uint64_t sample_interval) const;
   AllocationNode* AddStack();
 
   Isolate* const isolate_;
@@ -192,7 +204,7 @@ class SamplingHeapProfiler {
   AllocationNode profile_root_;
   std::unordered_map<Sample*, std::unique_ptr<Sample>> samples_;
   const int stack_depth_;
-  const uint64_t rate_;
+  std::atomic<uint64_t> interval_;
   v8::HeapProfiler::SamplingFlags flags_;
 };