Merge V8 5.3.332.45. DO NOT MERGE
Test: Manual
FPIIM-449
Change-Id: Id3254828b068abdea3cb10442e0172a8c9a98e03
(cherry picked from commit 13e2dadd00298019ed862f2b2fc5068bba730bcf)
diff --git a/src/heap/array-buffer-tracker.h b/src/heap/array-buffer-tracker.h
index 6130003..b015aa0 100644
--- a/src/heap/array-buffer-tracker.h
+++ b/src/heap/array-buffer-tracker.h
@@ -5,71 +5,97 @@
#ifndef V8_HEAP_ARRAY_BUFFER_TRACKER_H_
#define V8_HEAP_ARRAY_BUFFER_TRACKER_H_
-#include <map>
+#include <unordered_map>
+#include "src/allocation.h"
#include "src/base/platform/mutex.h"
#include "src/globals.h"
namespace v8 {
namespace internal {
-// Forward declarations.
class Heap;
class JSArrayBuffer;
+class Page;
-class ArrayBufferTracker {
+class ArrayBufferTracker : public AllStatic {
public:
- explicit ArrayBufferTracker(Heap* heap) : heap_(heap) {}
- ~ArrayBufferTracker();
-
- inline Heap* heap() { return heap_; }
+ enum ProcessingMode {
+ kUpdateForwardedRemoveOthers,
+ kUpdateForwardedKeepOthers,
+ };
// The following methods are used to track raw C++ pointers to externally
// allocated memory used as backing store in live array buffers.
- // A new ArrayBuffer was created with |data| as backing store.
- void RegisterNew(JSArrayBuffer* buffer);
+ // Register/unregister a new JSArrayBuffer |buffer| for tracking. Guards all
+ // access to the tracker by taking the page lock for the corresponding page.
+ inline static void RegisterNew(Heap* heap, JSArrayBuffer* buffer);
+ inline static void Unregister(Heap* heap, JSArrayBuffer* buffer);
- // The backing store |data| is no longer owned by V8.
- void Unregister(JSArrayBuffer* buffer);
+ // Frees all backing store pointers for dead JSArrayBuffers in new space.
+ // Does not take any locks and can only be called during Scavenge.
+ static void FreeDeadInNewSpace(Heap* heap);
- // A live ArrayBuffer was discovered during marking/scavenge.
- void MarkLive(JSArrayBuffer* buffer);
+ // 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.
+ static void FreeDead(Page* page);
- // Frees all backing store pointers that weren't discovered in the previous
- // marking or scavenge phase.
- void FreeDead(bool from_scavenge);
+ // Frees all remaining, live or dead, array buffers on a page. Only useful
+ // during tear down.
+ static void FreeAll(Page* page);
- // Prepare for a new scavenge phase. A new marking phase is implicitly
- // prepared by finishing the previous one.
- void PrepareDiscoveryInNewSpace();
+ // 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.
+ static bool ProcessBuffers(Page* page, ProcessingMode mode);
- // An ArrayBuffer moved from new space to old space.
- void Promote(JSArrayBuffer* buffer);
+ // Returns whether a buffer is currently tracked.
+ static bool IsTracked(JSArrayBuffer* buffer);
+};
+
+// LocalArrayBufferTracker tracks internalized array buffers.
+//
+// Never use directly but instead always call through |ArrayBufferTracker|.
+class LocalArrayBufferTracker {
+ public:
+ typedef std::pair<void*, size_t> Value;
+ typedef JSArrayBuffer* Key;
+
+ enum CallbackResult { kKeepEntry, kUpdateEntry, kRemoveEntry };
+ enum FreeMode { kFreeDead, kFreeAll };
+
+ explicit LocalArrayBufferTracker(Heap* heap) : heap_(heap) {}
+ ~LocalArrayBufferTracker();
+
+ inline void Add(Key key, const Value& value);
+ inline Value Remove(Key key);
+
+ // Frees up array buffers determined by |free_mode|.
+ template <FreeMode free_mode>
+ void Free();
+
+ // Processes buffers one by one. The CallbackResult of the callback decides
+ // what action to take on the buffer.
+ //
+ // Callback should be of type:
+ // CallbackResult fn(JSArrayBuffer* buffer, JSArrayBuffer** new_buffer);
+ template <typename Callback>
+ inline void Process(Callback callback);
+
+ bool IsEmpty() { return array_buffers_.empty(); }
+
+ bool IsTracked(Key key) {
+ return array_buffers_.find(key) != array_buffers_.end();
+ }
private:
- base::Mutex mutex_;
+ typedef std::unordered_map<Key, Value> TrackingMap;
+
Heap* heap_;
-
- // |live_array_buffers_| maps externally allocated memory used as backing
- // store for ArrayBuffers to the length of the respective memory blocks.
- //
- // At the beginning of mark/compact, |not_yet_discovered_array_buffers_| is
- // a copy of |live_array_buffers_| and we remove pointers as we discover live
- // ArrayBuffer objects during marking. At the end of mark/compact, the
- // remaining memory blocks can be freed.
- std::map<void*, size_t> live_array_buffers_;
- std::map<void*, size_t> not_yet_discovered_array_buffers_;
-
- // To be able to free memory held by ArrayBuffers during scavenge as well, we
- // have a separate list of allocated memory held by ArrayBuffers in new space.
- //
- // Since mark/compact also evacuates the new space, all pointers in the
- // |live_array_buffers_for_scavenge_| list are also in the
- // |live_array_buffers_| list.
- std::map<void*, size_t> live_array_buffers_for_scavenge_;
- std::map<void*, size_t> not_yet_discovered_array_buffers_for_scavenge_;
+ TrackingMap array_buffers_;
};
+
} // namespace internal
} // namespace v8
#endif // V8_HEAP_ARRAY_BUFFER_TRACKER_H_