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      237956 : void FreeAllocationsHelper(
      20             :     Heap* heap, const std::vector<JSArrayBuffer::Allocation>& allocations) {
      21      488013 :   for (JSArrayBuffer::Allocation alloc : allocations) {
      22      250054 :     JSArrayBuffer::FreeBackingStore(heap->isolate(), alloc);
      23             :   }
      24      237959 : }
      25             : 
      26             : }  // namespace
      27             : 
      28      237898 : void ArrayBufferCollector::QueueOrFreeGarbageAllocations(
      29             :     std::vector<JSArrayBuffer::Allocation> allocations) {
      30      475796 :   if (heap_->ShouldReduceMemory()) {
      31       15600 :     FreeAllocationsHelper(heap_, allocations);
      32             :   } else {
      33      222298 :     base::MutexGuard guard(&allocations_mutex_);
      34      222356 :     allocations_.push_back(std::move(allocations));
      35             :   }
      36      237959 : }
      37             : 
      38      155390 : void ArrayBufferCollector::PerformFreeAllocations() {
      39      155390 :   base::MutexGuard guard(&allocations_mutex_);
      40      377750 :   for (const std::vector<JSArrayBuffer::Allocation>& allocations :
      41             :        allocations_) {
      42      222356 :     FreeAllocationsHelper(heap_, allocations);
      43             :   }
      44      155394 :   allocations_.clear();
      45      155395 : }
      46             : 
      47       94928 : void ArrayBufferCollector::FreeAllocations() {
      48             :   // TODO(wez): Remove backing-store from external memory accounting.
      49       94928 :   heap_->account_external_memory_concurrently_freed();
      50      189856 :   if (!heap_->IsTearingDown() && !heap_->ShouldReduceMemory() &&
      51             :       FLAG_concurrent_array_buffer_freeing) {
      52      161954 :     V8::GetCurrentPlatform()->CallOnWorkerThread(
      53      483754 :         MakeCancelableTask(heap_->isolate(), [this] {
      54      399618 :           TRACE_BACKGROUND_GC(
      55             :               heap_->tracer(),
      56             :               GCTracer::BackgroundScope::BACKGROUND_ARRAY_BUFFER_FREE);
      57       79922 :           PerformFreeAllocations();
      58      241878 :         }));
      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       13951 :     PerformFreeAllocations();
      65             :   }
      66       94928 : }
      67             : 
      68             : }  // namespace internal
      69      120216 : }  // namespace v8