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      319659 : void FreeAllocationsHelper(
      20             :     Heap* heap, const std::vector<JSArrayBuffer::Allocation>& allocations) {
      21      577143 :   for (JSArrayBuffer::Allocation alloc : allocations) {
      22      257465 :     JSArrayBuffer::FreeBackingStore(heap->isolate(), alloc);
      23             :   }
      24      319678 : }
      25             : 
      26             : }  // namespace
      27             : 
      28      319591 : void ArrayBufferCollector::QueueOrFreeGarbageAllocations(
      29             :     std::vector<JSArrayBuffer::Allocation> allocations) {
      30      639182 :   if (heap_->ShouldReduceMemory()) {
      31        7416 :     FreeAllocationsHelper(heap_, allocations);
      32             :   } else {
      33      312175 :     base::MutexGuard guard(&allocations_mutex_);
      34      312259 :     allocations_.push_back(std::move(allocations));
      35             :   }
      36      319675 : }
      37             : 
      38      156336 : void ArrayBufferCollector::PerformFreeAllocations() {
      39      156336 :   base::MutexGuard guard(&allocations_mutex_);
      40      468597 :   for (const std::vector<JSArrayBuffer::Allocation>& allocations :
      41             :        allocations_) {
      42      312259 :     FreeAllocationsHelper(heap_, allocations);
      43             :   }
      44      156338 :   allocations_.clear();
      45      156339 : }
      46             : 
      47       94944 : void ArrayBufferCollector::FreeAllocations() {
      48             :   // TODO(wez): Remove backing-store from external memory accounting.
      49       94944 :   heap_->account_external_memory_concurrently_freed();
      50      189888 :   if (!heap_->IsTearingDown() && !heap_->ShouldReduceMemory() &&
      51             :       FLAG_concurrent_array_buffer_freeing) {
      52      176120 :     V8::GetCurrentPlatform()->CallOnWorkerThread(
      53      526294 :         MakeCancelableTask(heap_->isolate(), [this] {
      54      435136 :           TRACE_BACKGROUND_GC(
      55             :               heap_->tracer(),
      56             :               GCTracer::BackgroundScope::BACKGROUND_ARRAY_BUFFER_FREE);
      57       87027 :           PerformFreeAllocations();
      58      263148 :         }));
      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        6884 :     PerformFreeAllocations();
      65             :   }
      66       94944 : }
      67             : 
      68             : }  // namespace internal
      69      122036 : }  // namespace v8