array-buffer-sweeper.h

Go to the documentation of this file.

// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef V8_HEAP_ARRAY_BUFFER_SWEEPER_H_
#define V8_HEAP_ARRAY_BUFFER_SWEEPER_H_
 
#include <memory>
 
#include "include/v8-external-memory-accounter.h"
#include "include/v8config.h"
#include "src/api/api.h"
#include "src/base/logging.h"
#include "src/heap/sweeper.h"
#include "src/objects/js-array-buffer.h"
#include "src/tasks/cancelable-task.h"
 
namespace v8 {
namespace internal {
 
class ArrayBufferExtension;
class Heap;
 
// Singly linked-list of ArrayBufferExtensions that stores head and tail of the
// list to allow for concatenation of lists.
struct ArrayBufferList final {
  using Age = ArrayBufferExtension::Age;
 
  explicit ArrayBufferList(Age age) : age_(age) {}
 
  bool IsEmpty() const;
  size_t ApproximateBytes() const { return bytes_; }
  size_t BytesSlow() const;
 
  size_t Append(ArrayBufferExtension* extension);
  void Append(ArrayBufferList& list);
 
  V8_EXPORT_PRIVATE bool ContainsSlow(ArrayBufferExtension* extension) const;
 
 private:
  ArrayBufferExtension* head_ = nullptr;
  ArrayBufferExtension* tail_ = nullptr;
  // Bytes are approximate as they may be subtracted eagerly, while the
  // `ArrayBufferExtension` is still in the list. The extension will only be
  // dropped on next sweep.
  size_t bytes_ = 0;
  ArrayBufferExtension::Age age_;
 
  friend class ArrayBufferSweeper;
};
 
// The ArrayBufferSweeper iterates and deletes ArrayBufferExtensions
// concurrently to the application.
class ArrayBufferSweeper final {
 public:
  enum class SweepingType { kYoung, kFull };
  enum class TreatAllYoungAsPromoted { kNo, kYes };
 
  explicit ArrayBufferSweeper(Heap* heap);
  ~ArrayBufferSweeper();
 
  void RequestSweep(SweepingType sweeping_type,
                    TreatAllYoungAsPromoted treat_all_young_as_promoted);
  void EnsureFinished();
 
  // Track the given ArrayBufferExtension.
  void Append(ArrayBufferExtension* extension);
 
  void Resize(ArrayBufferExtension* extension, int64_t delta);
 
  // Detaches an ArrayBufferExtension.
  void Detach(ArrayBufferExtension* extension);
 
  const ArrayBufferList& young() const { return young_; }
  const ArrayBufferList& old() const { return old_; }
 
  // Bytes accounted in the young generation. Rebuilt during sweeping.
  size_t YoungBytes() const { return young().ApproximateBytes(); }
  // Bytes accounted in the old generation. Rebuilt during sweeping.
  size_t OldBytes() const { return old().ApproximateBytes(); }
 
  bool sweeping_in_progress() const { return state_.get(); }
 
  uint64_t GetTraceIdForFlowEvent(GCTracer::Scope::ScopeId scope_id) const;
 
 private:
  class SweepingState;
 
  // Finishes sweeping if it is already done.
  void FinishIfDone();
  void Finish();
 
  void UpdateApproximateBytes(int64_t delta, ArrayBufferExtension::Age age);
 
  // Increments external memory counters outside of ArrayBufferSweeper.
  // Increment may trigger GC.
  void IncrementExternalMemoryCounters(size_t bytes);
  void DecrementExternalMemoryCounters(size_t bytes);
 
  void Prepare(SweepingType type,
               TreatAllYoungAsPromoted treat_all_young_as_promoted,
               uint64_t trace_id);
  void Finalize();
 
  void ReleaseAll(ArrayBufferList* extension);
 
  static void FinalizeAndDelete(ArrayBufferExtension* extension);
 
  Heap* const heap_;
  std::unique_ptr<SweepingState> state_;
  ArrayBufferList young_{ArrayBufferList::Age::kYoung};
  ArrayBufferList old_{ArrayBufferList::Age::kOld};
  // Track accounting bytes adjustment during sweeping including freeing, and
  // resizing. Adjustment are applied to the accounted bytes when sweeping
  // finishes.
  int64_t young_bytes_adjustment_while_sweeping_{0};
  int64_t old_bytes_adjustment_while_sweeping_{0};
  V8_NO_UNIQUE_ADDRESS ExternalMemoryAccounter external_memory_accounter_;
};
 
}  // namespace internal
}  // namespace v8
 
#endif  // V8_HEAP_ARRAY_BUFFER_SWEEPER_H_