Line data    Source code

       1             : // Copyright 2016 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/conversions-inl.h"
       6             : #include "src/heap/array-buffer-tracker.h"
       7             : #include "src/heap/heap.h"
       8             : #include "src/objects.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : 
      13      131363 : void ArrayBufferTracker::RegisterNew(Heap* heap, JSArrayBuffer* buffer) {
      14             :   void* data = buffer->backing_store();
      15      262726 :   if (!data) return;
      16             : 
      17      131363 :   size_t length = NumberToSize(buffer->byte_length());
      18      131363 :   Page* page = Page::FromAddress(buffer->address());
      19             :   {
      20      262765 :     base::LockGuard<base::RecursiveMutex> guard(page->mutex());
      21             :     LocalArrayBufferTracker* tracker = page->local_tracker();
      22      131363 :     if (tracker == nullptr) {
      23          39 :       page->AllocateLocalTracker();
      24             :       tracker = page->local_tracker();
      25             :     }
      26             :     DCHECK_NOT_NULL(tracker);
      27             :     tracker->Add(buffer, length);
      28             :   }
      29             :   // We may go over the limit of externally allocated memory here. We call the
      30             :   // api function to trigger a GC in this case.
      31             :   reinterpret_cast<v8::Isolate*>(heap->isolate())
      32      131363 :       ->AdjustAmountOfExternalAllocatedMemory(length);
      33             : }
      34             : 
      35        3483 : void ArrayBufferTracker::Unregister(Heap* heap, JSArrayBuffer* buffer) {
      36             :   void* data = buffer->backing_store();
      37        6966 :   if (!data) return;
      38             : 
      39        3468 :   Page* page = Page::FromAddress(buffer->address());
      40             :   size_t length = 0;
      41             :   {
      42        6936 :     base::LockGuard<base::RecursiveMutex> guard(page->mutex());
      43             :     LocalArrayBufferTracker* tracker = page->local_tracker();
      44             :     DCHECK_NOT_NULL(tracker);
      45        3468 :     length = tracker->Remove(buffer);
      46             :   }
      47        3468 :   heap->update_external_memory(-static_cast<intptr_t>(length));
      48             : }
      49             : 
      50             : void LocalArrayBufferTracker::Add(Key key, const Value& value) {
      51      302334 :   auto ret = array_buffers_.insert(std::make_pair(key, value));
      52             :   USE(ret);
      53             :   // Check that we indeed inserted a new value and did not overwrite an existing
      54             :   // one (which would be a bug).
      55             :   DCHECK(ret.second);
      56             : }
      57             : 
      58        3468 : LocalArrayBufferTracker::Value LocalArrayBufferTracker::Remove(Key key) {
      59             :   TrackingData::iterator it = array_buffers_.find(key);
      60             :   // Check that we indeed find a key to remove.
      61             :   DCHECK(it != array_buffers_.end());
      62        3468 :   Value value = it->second;
      63             :   array_buffers_.erase(it);
      64        3468 :   return value;
      65             : }
      66             : 
      67             : }  // namespace internal
      68             : }  // namespace v8