mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 15:28:11 +00:00
0ff29349e6
This change introduces a very basic GC graph dumper. The `dump_graph()`
function outputs JSON data that contains information about all nodes in
the graph, including their class types and edges.
Root nodes will have a property indicating their root type or source
location if the root is captured by a SafeFunction. It would be useful
to add source location for other types of roots in the future.
Output JSON dump have following format:
```json
"4908721208": {
"class_name": "Accessor",
"edges": [
"4909298232",
"4909297976"
]
},
"4907520440": {
"root": "SafeFunction Optional Optional.h:137",
"class_name": "Realm",
"edges": [
"4908269624",
"4924821560",
"4908409240",
"4908483960",
"4924527672"
]
},
"4908251320": {
"class_name": "CSSStyleRule",
"edges": [
"4908302648",
"4925101656",
"4908251192"
]
},
```
128 lines
3.8 KiB
C++
128 lines
3.8 KiB
C++
/*
|
|
* Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/Badge.h>
|
|
#include <AK/HashTable.h>
|
|
#include <AK/IntrusiveList.h>
|
|
#include <AK/Noncopyable.h>
|
|
#include <AK/NonnullOwnPtr.h>
|
|
#include <AK/Types.h>
|
|
#include <AK/Vector.h>
|
|
#include <LibCore/Forward.h>
|
|
#include <LibJS/Forward.h>
|
|
#include <LibJS/Heap/BlockAllocator.h>
|
|
#include <LibJS/Heap/Cell.h>
|
|
#include <LibJS/Heap/CellAllocator.h>
|
|
#include <LibJS/Heap/Handle.h>
|
|
#include <LibJS/Heap/HeapRootTypeOrLocation.h>
|
|
#include <LibJS/Heap/Internals.h>
|
|
#include <LibJS/Heap/MarkedVector.h>
|
|
#include <LibJS/Runtime/Completion.h>
|
|
#include <LibJS/Runtime/WeakContainer.h>
|
|
|
|
namespace JS {
|
|
|
|
class Heap : public HeapBase {
|
|
AK_MAKE_NONCOPYABLE(Heap);
|
|
AK_MAKE_NONMOVABLE(Heap);
|
|
|
|
public:
|
|
explicit Heap(VM&);
|
|
~Heap();
|
|
|
|
template<typename T, typename... Args>
|
|
NonnullGCPtr<T> allocate_without_realm(Args&&... args)
|
|
{
|
|
auto* memory = allocate_cell(sizeof(T));
|
|
new (memory) T(forward<Args>(args)...);
|
|
return *static_cast<T*>(memory);
|
|
}
|
|
|
|
template<typename T, typename... Args>
|
|
NonnullGCPtr<T> allocate(Realm& realm, Args&&... args)
|
|
{
|
|
auto* memory = allocate_cell(sizeof(T));
|
|
new (memory) T(forward<Args>(args)...);
|
|
auto* cell = static_cast<T*>(memory);
|
|
memory->initialize(realm);
|
|
return *cell;
|
|
}
|
|
|
|
enum class CollectionType {
|
|
CollectGarbage,
|
|
CollectEverything,
|
|
};
|
|
|
|
void collect_garbage(CollectionType = CollectionType::CollectGarbage, bool print_report = false);
|
|
void dump_graph();
|
|
|
|
bool should_collect_on_every_allocation() const { return m_should_collect_on_every_allocation; }
|
|
void set_should_collect_on_every_allocation(bool b) { m_should_collect_on_every_allocation = b; }
|
|
|
|
void did_create_handle(Badge<HandleImpl>, HandleImpl&);
|
|
void did_destroy_handle(Badge<HandleImpl>, HandleImpl&);
|
|
|
|
void did_create_marked_vector(Badge<MarkedVectorBase>, MarkedVectorBase&);
|
|
void did_destroy_marked_vector(Badge<MarkedVectorBase>, MarkedVectorBase&);
|
|
|
|
void did_create_weak_container(Badge<WeakContainer>, WeakContainer&);
|
|
void did_destroy_weak_container(Badge<WeakContainer>, WeakContainer&);
|
|
|
|
void defer_gc(Badge<DeferGC>);
|
|
void undefer_gc(Badge<DeferGC>);
|
|
|
|
BlockAllocator& block_allocator() { return m_block_allocator; }
|
|
|
|
void uproot_cell(Cell* cell);
|
|
|
|
private:
|
|
static bool cell_must_survive_garbage_collection(Cell const&);
|
|
|
|
Cell* allocate_cell(size_t);
|
|
|
|
void gather_roots(HashMap<Cell*, HeapRootTypeOrLocation>&);
|
|
void gather_conservative_roots(HashMap<Cell*, HeapRootTypeOrLocation>&);
|
|
void gather_asan_fake_stack_roots(HashMap<FlatPtr, HeapRootTypeOrLocation>&, FlatPtr);
|
|
void mark_live_cells(HashMap<Cell*, HeapRootTypeOrLocation> const& live_cells);
|
|
void finalize_unmarked_cells();
|
|
void sweep_dead_cells(bool print_report, Core::ElapsedTimer const&);
|
|
|
|
CellAllocator& allocator_for_size(size_t);
|
|
|
|
template<typename Callback>
|
|
void for_each_block(Callback callback)
|
|
{
|
|
for (auto& allocator : m_allocators) {
|
|
if (allocator->for_each_block(callback) == IterationDecision::Break)
|
|
return;
|
|
}
|
|
}
|
|
|
|
static constexpr size_t GC_MIN_BYTES_THRESHOLD { 4 * 1024 * 1024 };
|
|
size_t m_gc_bytes_threshold { GC_MIN_BYTES_THRESHOLD };
|
|
size_t m_allocated_bytes_since_last_gc { 0 };
|
|
|
|
bool m_should_collect_on_every_allocation { false };
|
|
|
|
Vector<NonnullOwnPtr<CellAllocator>> m_allocators;
|
|
|
|
HandleImpl::List m_handles;
|
|
MarkedVectorBase::List m_marked_vectors;
|
|
WeakContainer::List m_weak_containers;
|
|
|
|
Vector<GCPtr<Cell>> m_uprooted_cells;
|
|
|
|
BlockAllocator m_block_allocator;
|
|
|
|
size_t m_gc_deferrals { 0 };
|
|
bool m_should_gc_when_deferral_ends { false };
|
|
|
|
bool m_collecting_garbage { false };
|
|
};
|
|
|
|
}
|