array-buffer-tracker.h 3.11 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_HEAP_ARRAY_BUFFER_TRACKER_H_
#define V8_HEAP_ARRAY_BUFFER_TRACKER_H_

8
#include <unordered_map>
9

10
#include "src/allocation.h"
11
#include "src/base/platform/mutex.h"
12 13 14 15 16 17 18
#include "src/globals.h"

namespace v8 {
namespace internal {

class Heap;
class JSArrayBuffer;
19
class Page;
20

21
class ArrayBufferTracker : public AllStatic {
22
 public:
23 24 25 26
  enum ProcessingMode {
    kUpdateForwardedRemoveOthers,
    kUpdateForwardedKeepOthers,
  };
27

28 29 30
  // The following methods are used to track raw C++ pointers to externally
  // allocated memory used as backing store in live array buffers.

31 32
  // Register/unregister a new JSArrayBuffer |buffer| for tracking. Guards all
  // access to the tracker by taking the page lock for the corresponding page.
33 34
  inline static void RegisterNew(Heap* heap, JSArrayBuffer* buffer);
  inline static void Unregister(Heap* heap, JSArrayBuffer* buffer);
35

36 37
  // Frees all backing store pointers for dead JSArrayBuffers in new space.
  // Does not take any locks and can only be called during Scavenge.
38
  static void FreeDeadInNewSpace(Heap* heap);
39

40 41 42
  // Frees all backing store pointers for dead JSArrayBuffer on a given page.
  // Requires marking information to be present. Requires the page lock to be
  // taken by the caller.
43
  static void FreeDead(Page* page);
44

45 46
  // Frees all remaining, live or dead, array buffers on a page. Only useful
  // during tear down.
47
  static void FreeAll(Page* page);
48

49 50
  // Processes all array buffers on a given page. |mode| specifies the action
  // to perform on the buffers. Returns whether the tracker is empty or not.
51
  static bool ProcessBuffers(Page* page, ProcessingMode mode);
52

53 54
  // Returns whether a buffer is currently tracked.
  static bool IsTracked(JSArrayBuffer* buffer);
55
};
56

57 58 59 60 61 62
// LocalArrayBufferTracker tracks internalized array buffers.
//
// Never use directly but instead always call through |ArrayBufferTracker|.
class LocalArrayBufferTracker {
 public:
  typedef JSArrayBuffer* Key;
63
  typedef size_t Value;
64

65 66 67 68 69 70
  enum CallbackResult { kKeepEntry, kUpdateEntry, kRemoveEntry };
  enum FreeMode { kFreeDead, kFreeAll };

  explicit LocalArrayBufferTracker(Heap* heap) : heap_(heap) {}
  ~LocalArrayBufferTracker();

71 72
  inline void Add(Key key, const Value& value);
  inline Value Remove(Key key);
73

74
  // Frees up array buffers determined by |free_mode|.
75
  template <FreeMode free_mode>
76
  void Free();
77 78

  // Processes buffers one by one. The CallbackResult of the callback decides
79
  // what action to take on the buffer.
80
  //
81 82 83
  // Callback should be of type:
  //   CallbackResult fn(JSArrayBuffer* buffer, JSArrayBuffer** new_buffer);
  template <typename Callback>
84
  void Process(Callback callback);
85 86 87 88 89 90 91 92

  bool IsEmpty() { return array_buffers_.empty(); }

  bool IsTracked(Key key) {
    return array_buffers_.find(key) != array_buffers_.end();
  }

 private:
93
  typedef std::unordered_map<Key, Value> TrackingData;
94 95

  Heap* heap_;
96
  TrackingData array_buffers_;
97
};
98

99 100
}  // namespace internal
}  // namespace v8
101
#endif  // V8_HEAP_ARRAY_BUFFER_TRACKER_H_