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      168838 : void FreeAllocationsHelper(
      20             :     Heap* heap, const std::vector<JSArrayBuffer::Allocation>& allocations) {
      21      523395 :   for (JSArrayBuffer::Allocation alloc : allocations) {
      22      185718 :     JSArrayBuffer::FreeBackingStore(heap->isolate(), alloc);
      23             :   }
      24      168839 : }
      25             : 
      26             : }  // namespace
      27             : 
      28      168822 : void ArrayBufferCollector::QueueOrFreeGarbageAllocations(
      29             :     std::vector<JSArrayBuffer::Allocation> allocations) {
      30      337644 :   if (heap_->ShouldReduceMemory()) {
      31       16227 :     FreeAllocationsHelper(heap_, allocations);
      32             :   } else {
      33      152595 :     base::MutexGuard guard(&allocations_mutex_);
      34      152611 :     allocations_.push_back(std::move(allocations));
      35             :   }
      36      168839 : }
      37             : 
      38      157835 : void ArrayBufferCollector::PerformFreeAllocations() {
      39      157835 :   base::MutexGuard guard(&allocations_mutex_);
      40      468281 :   for (const std::vector<JSArrayBuffer::Allocation>& allocations :
      41             :        allocations_) {
      42      152611 :     FreeAllocationsHelper(heap_, allocations);
      43             :   }
      44             :   allocations_.clear();
      45      157835 : }
      46             : 
      47       98000 : void ArrayBufferCollector::FreeAllocations() {
      48             :   // TODO(wez): Remove backing-store from external memory accounting.
      49      294000 :   heap_->account_external_memory_concurrently_freed();
      50      294000 :   if (!heap_->IsTearingDown() && !heap_->ShouldReduceMemory() &&
      51             :       FLAG_concurrent_array_buffer_freeing) {
      52       83585 :     V8::GetCurrentPlatform()->CallOnWorkerThread(
      53       82386 :         MakeCancelableTask(heap_->isolate(), [this] {
      54      411930 :           TRACE_BACKGROUND_GC(
      55             :               heap_->tracer(),
      56             :               GCTracer::BackgroundScope::BACKGROUND_ARRAY_BUFFER_FREE);
      57       82386 :           PerformFreeAllocations();
      58      583896 :         }));
      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       14415 :     PerformFreeAllocations();
      65             :   }
      66       98000 : }
      67             : 
      68             : }  // namespace internal
      69      178779 : }  // namespace v8