Line data    Source code

       1             : // Copyright 2017 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/heap/array-buffer-collector.h"
       6             : 
       7             : #include "src/base/template-utils.h"
       8             : #include "src/cancelable-task.h"
       9             : #include "src/heap/array-buffer-tracker.h"
      10             : #include "src/heap/gc-tracer.h"
      11             : #include "src/heap/heap-inl.h"
      12             : #include "src/task-utils.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : 
      17             : namespace {
      18             : 
      19      177157 : void FreeAllocationsHelper(
      20             :     Heap* heap, const std::vector<JSArrayBuffer::Allocation>& allocations) {
      21      556816 :   for (JSArrayBuffer::Allocation alloc : allocations) {
      22      202496 :     JSArrayBuffer::FreeBackingStore(heap->isolate(), alloc);
      23             :   }
      24      177163 : }
      25             : 
      26             : }  // namespace
      27             : 
      28      177140 : void ArrayBufferCollector::QueueOrFreeGarbageAllocations(
      29             :     std::vector<JSArrayBuffer::Allocation> allocations) {
      30      354280 :   if (heap_->ShouldReduceMemory()) {
      31       18277 :     FreeAllocationsHelper(heap_, allocations);
      32             :   } else {
      33      158863 :     base::MutexGuard guard(&allocations_mutex_);
      34      158886 :     allocations_.push_back(std::move(allocations));
      35             :   }
      36      177164 : }
      37             : 
      38      167351 : void ArrayBufferCollector::PerformFreeAllocations() {
      39      167351 :   base::MutexGuard guard(&allocations_mutex_);
      40      493590 :   for (const std::vector<JSArrayBuffer::Allocation>& allocations :
      41             :        allocations_) {
      42      158886 :     FreeAllocationsHelper(heap_, allocations);
      43             :   }
      44             :   allocations_.clear();
      45      167352 : }
      46             : 
      47      107086 : void ArrayBufferCollector::FreeAllocations() {
      48             :   // TODO(wez): Remove backing-store from external memory accounting.
      49      321258 :   heap_->account_external_memory_concurrently_freed();
      50      321258 :   if (!heap_->IsTearingDown() && !heap_->ShouldReduceMemory() &&
      51             :       FLAG_concurrent_array_buffer_freeing) {
      52       90665 :     V8::GetCurrentPlatform()->CallOnWorkerThread(
      53       88062 :         MakeCancelableTask(heap_->isolate(), [this] {
      54      352251 :           TRACE_BACKGROUND_GC(
      55             :               heap_->tracer(),
      56             :               GCTracer::BackgroundScope::BACKGROUND_ARRAY_BUFFER_FREE);
      57       88063 :           PerformFreeAllocations();
      58      722718 :         }));
      59             :   } else {
      60             :     // Fallback for when concurrency is disabled/restricted. This is e.g. the
      61             :     // case when the GC should reduce memory. For such GCs the
      62             :     // QueueOrFreeGarbageAllocations() call would immediately free the
      63             :     // allocations and this call would free already queued ones.
      64       16421 :     PerformFreeAllocations();
      65             :   }
      66      107086 : }
      67             : 
      68             : }  // namespace internal
      69      183867 : }  // namespace v8