Libraries: Move to Userland/Libraries/

Userland/Libraries/LibJS/Heap/Allocator.cpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <AK/Badge.h>
+#include <LibJS/Heap/Allocator.h>
+#include <LibJS/Heap/HeapBlock.h>
+
+namespace JS {
+
+Allocator::Allocator(size_t cell_size)
+    : m_cell_size(cell_size)
+{
+}
+
+Allocator::~Allocator()
+{
+}
+
+Cell* Allocator::allocate_cell(Heap& heap)
+{
+    if (m_usable_blocks.is_empty()) {
+        auto block = HeapBlock::create_with_cell_size(heap, m_cell_size);
+        m_usable_blocks.append(*block.leak_ptr());
+    }
+
+    auto& block = *m_usable_blocks.last();
+    auto* cell = block.allocate();
+    ASSERT(cell);
+    if (block.is_full())
+        m_full_blocks.append(*m_usable_blocks.last());
+    return cell;
+}
+
+void Allocator::block_did_become_empty(Badge<Heap>, HeapBlock& block)
+{
+    block.m_list_node.remove();
+    delete &block;
+}
+
+void Allocator::block_did_become_usable(Badge<Heap>, HeapBlock& block)
+{
+    ASSERT(!block.is_full());
+    m_usable_blocks.append(block);
+}
+
+}

Userland/Libraries/LibJS/Heap/Allocator.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/IntrusiveList.h>
+#include <AK/NonnullOwnPtr.h>
+#include <AK/Vector.h>
+#include <LibJS/Forward.h>
+#include <LibJS/Heap/HeapBlock.h>
+
+namespace JS {
+
+class Allocator {
+public:
+    Allocator(size_t cell_size);
+    ~Allocator();
+
+    size_t cell_size() const { return m_cell_size; }
+
+    Cell* allocate_cell(Heap&);
+
+    template<typename Callback>
+    IterationDecision for_each_block(Callback callback)
+    {
+        for (auto& block : m_full_blocks) {
+            if (callback(block) == IterationDecision::Break)
+                return IterationDecision::Break;
+        }
+        for (auto& block : m_usable_blocks) {
+            if (callback(block) == IterationDecision::Break)
+                return IterationDecision::Break;
+        }
+        return IterationDecision::Continue;
+    }
+
+    void block_did_become_empty(Badge<Heap>, HeapBlock&);
+    void block_did_become_usable(Badge<Heap>, HeapBlock&);
+
+private:
+    const size_t m_cell_size;
+
+    typedef IntrusiveList<HeapBlock, &HeapBlock::m_list_node> BlockList;
+    BlockList m_full_blocks;
+    BlockList m_usable_blocks;
+};
+
+}

Userland/Libraries/LibJS/Heap/DeferGC.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <LibJS/Heap/Heap.h>
+
+namespace JS {
+
+class DeferGC {
+public:
+    explicit DeferGC(Heap& heap)
+        : m_heap(heap)
+    {
+        m_heap.defer_gc({});
+    }
+
+    ~DeferGC()
+    {
+        m_heap.undefer_gc({});
+    }
+
+private:
+    Heap& m_heap;
+};
+
+}

Userland/Libraries/LibJS/Heap/Handle.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <LibJS/Heap/Handle.h>
+#include <LibJS/Heap/Heap.h>
+#include <LibJS/Runtime/Cell.h>
+
+namespace JS {
+
+HandleImpl::HandleImpl(Cell* cell)
+    : m_cell(cell)
+{
+    m_cell->heap().did_create_handle({}, *this);
+}
+
+HandleImpl::~HandleImpl()
+{
+    m_cell->heap().did_destroy_handle({}, *this);
+}
+
+}

Userland/Libraries/LibJS/Heap/Handle.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/Badge.h>
+#include <AK/Noncopyable.h>
+#include <AK/RefCounted.h>
+#include <AK/RefPtr.h>
+#include <LibJS/Forward.h>
+
+namespace JS {
+
+class HandleImpl : public RefCounted<HandleImpl> {
+    AK_MAKE_NONCOPYABLE(HandleImpl);
+    AK_MAKE_NONMOVABLE(HandleImpl);
+
+public:
+    ~HandleImpl();
+
+    Cell* cell() { return m_cell; }
+    const Cell* cell() const { return m_cell; }
+
+private:
+    template<class T>
+    friend class Handle;
+
+    explicit HandleImpl(Cell*);
+    Cell* m_cell { nullptr };
+};
+
+template<class T>
+class Handle {
+public:
+    Handle() { }
+
+    static Handle create(T* cell)
+    {
+        return Handle(adopt(*new HandleImpl(cell)));
+    }
+
+    T* cell() { return static_cast<T*>(m_impl->cell()); }
+    const T* cell() const { return static_cast<const T*>(m_impl->cell()); }
+
+    bool is_null() const { return m_impl.is_null(); }
+
+private:
+    explicit Handle(NonnullRefPtr<HandleImpl> impl)
+        : m_impl(move(impl))
+    {
+    }
+
+    RefPtr<HandleImpl> m_impl;
+};
+
+template<class T>
+inline Handle<T> make_handle(T* cell)
+{
+    return Handle<T>::create(cell);
+}
+
+}

Userland/Libraries/LibJS/Heap/Heap.cpp

@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <AK/Badge.h>
+#include <AK/HashTable.h>
+#include <AK/StackInfo.h>
+#include <AK/TemporaryChange.h>
+#include <LibCore/ElapsedTimer.h>
+#include <LibJS/Heap/Allocator.h>
+#include <LibJS/Heap/Handle.h>
+#include <LibJS/Heap/Heap.h>
+#include <LibJS/Heap/HeapBlock.h>
+#include <LibJS/Interpreter.h>
+#include <LibJS/Runtime/Object.h>
+#include <setjmp.h>
+
+//#define HEAP_DEBUG
+
+namespace JS {
+
+Heap::Heap(VM& vm)
+    : m_vm(vm)
+{
+    m_allocators.append(make<Allocator>(16));
+    m_allocators.append(make<Allocator>(32));
+    m_allocators.append(make<Allocator>(64));
+    m_allocators.append(make<Allocator>(128));
+    m_allocators.append(make<Allocator>(256));
+    m_allocators.append(make<Allocator>(512));
+    m_allocators.append(make<Allocator>(1024));
+    m_allocators.append(make<Allocator>(3172));
+}
+
+Heap::~Heap()
+{
+    collect_garbage(CollectionType::CollectEverything);
+}
+
+ALWAYS_INLINE Allocator& Heap::allocator_for_size(size_t cell_size)
+{
+    for (auto& allocator : m_allocators) {
+        if (allocator->cell_size() >= cell_size)
+            return *allocator;
+    }
+    ASSERT_NOT_REACHED();
+}
+
+Cell* Heap::allocate_cell(size_t size)
+{
+    if (should_collect_on_every_allocation()) {
+        collect_garbage();
+    } else if (m_allocations_since_last_gc > m_max_allocations_between_gc) {
+        m_allocations_since_last_gc = 0;
+        collect_garbage();
+    } else {
+        ++m_allocations_since_last_gc;
+    }
+
+    auto& allocator = allocator_for_size(size);
+    return allocator.allocate_cell(*this);
+}
+
+void Heap::collect_garbage(CollectionType collection_type, bool print_report)
+{
+    ASSERT(!m_collecting_garbage);
+    TemporaryChange change(m_collecting_garbage, true);
+
+    Core::ElapsedTimer collection_measurement_timer;
+    collection_measurement_timer.start();
+    if (collection_type == CollectionType::CollectGarbage) {
+        if (m_gc_deferrals) {
+            m_should_gc_when_deferral_ends = true;
+            return;
+        }
+        HashTable<Cell*> roots;
+        gather_roots(roots);
+        mark_live_cells(roots);
+    }
+    sweep_dead_cells(print_report, collection_measurement_timer);
+}
+
+void Heap::gather_roots(HashTable<Cell*>& roots)
+{
+    vm().gather_roots(roots);
+    gather_conservative_roots(roots);
+
+    for (auto* handle : m_handles)
+        roots.set(handle->cell());
+
+    for (auto* list : m_marked_value_lists) {
+        for (auto& value : list->values()) {
+            if (value.is_cell())
+                roots.set(value.as_cell());
+        }
+    }
+
+#ifdef HEAP_DEBUG
+    dbgln("gather_roots:");
+    for (auto* root : roots)
+        dbgln("  + {}", root);
+#endif
+}
+
+__attribute__((no_sanitize("address"))) void Heap::gather_conservative_roots(HashTable<Cell*>& roots)
+{
+    FlatPtr dummy;
+
+#ifdef HEAP_DEBUG
+    dbgln("gather_conservative_roots:");
+#endif
+
+    jmp_buf buf;
+    setjmp(buf);
+
+    HashTable<FlatPtr> possible_pointers;
+
+    const FlatPtr* raw_jmp_buf = reinterpret_cast<const FlatPtr*>(buf);
+
+    for (size_t i = 0; i < ((size_t)sizeof(buf)) / sizeof(FlatPtr); i += sizeof(FlatPtr))
+        possible_pointers.set(raw_jmp_buf[i]);
+
+    FlatPtr stack_reference = reinterpret_cast<FlatPtr>(&dummy);
+    auto& stack_info = m_vm.stack_info();
+
+    for (FlatPtr stack_address = stack_reference; stack_address < stack_info.top(); stack_address += sizeof(FlatPtr)) {
+        auto data = *reinterpret_cast<FlatPtr*>(stack_address);
+        possible_pointers.set(data);
+    }
+
+    HashTable<HeapBlock*> all_live_heap_blocks;
+    for_each_block([&](auto& block) {
+        all_live_heap_blocks.set(&block);
+        return IterationDecision::Continue;
+    });
+
+    for (auto possible_pointer : possible_pointers) {
+        if (!possible_pointer)
+            continue;
+#ifdef HEAP_DEBUG
+        dbgln("  ? {}", (const void*)possible_pointer);
+#endif
+        auto* possible_heap_block = HeapBlock::from_cell(reinterpret_cast<const Cell*>(possible_pointer));
+        if (all_live_heap_blocks.contains(possible_heap_block)) {
+            if (auto* cell = possible_heap_block->cell_from_possible_pointer(possible_pointer)) {
+                if (cell->is_live()) {
+#ifdef HEAP_DEBUG
+                    dbgln("  ?-> {}", (const void*)cell);
+#endif
+                    roots.set(cell);
+                } else {
+#ifdef HEAP_DEBUG
+                    dbgln("  #-> {}", (const void*)cell);
+#endif
+                }
+            }
+        }
+    }
+}
+
+class MarkingVisitor final : public Cell::Visitor {
+public:
+    MarkingVisitor() { }
+
+    virtual void visit_impl(Cell* cell)
+    {
+        if (cell->is_marked())
+            return;
+#ifdef HEAP_DEBUG
+        dbgln("  ! {}", cell);
+#endif
+        cell->set_marked(true);
+        cell->visit_edges(*this);
+    }
+};
+
+void Heap::mark_live_cells(const HashTable<Cell*>& roots)
+{
+#ifdef HEAP_DEBUG
+    dbgln("mark_live_cells:");
+#endif
+    MarkingVisitor visitor;
+    for (auto* root : roots)
+        visitor.visit(root);
+}
+
+void Heap::sweep_dead_cells(bool print_report, const Core::ElapsedTimer& measurement_timer)
+{
+#ifdef HEAP_DEBUG
+    dbgln("sweep_dead_cells:");
+#endif
+    Vector<HeapBlock*, 32> empty_blocks;
+    Vector<HeapBlock*, 32> full_blocks_that_became_usable;
+
+    size_t collected_cells = 0;
+    size_t live_cells = 0;
+    size_t collected_cell_bytes = 0;
+    size_t live_cell_bytes = 0;
+
+    for_each_block([&](auto& block) {
+        bool block_has_live_cells = false;
+        bool block_was_full = block.is_full();
+        block.for_each_cell([&](Cell* cell) {
+            if (cell->is_live()) {
+                if (!cell->is_marked()) {
+#ifdef HEAP_DEBUG
+                    dbgln("  ~ {}", cell);
+#endif
+                    block.deallocate(cell);
+                    ++collected_cells;
+                    collected_cell_bytes += block.cell_size();
+                } else {
+                    cell->set_marked(false);
+                    block_has_live_cells = true;
+                    ++live_cells;
+                    live_cell_bytes += block.cell_size();
+                }
+            }
+        });
+        if (!block_has_live_cells)
+            empty_blocks.append(&block);
+        else if (block_was_full != block.is_full())
+            full_blocks_that_became_usable.append(&block);
+        return IterationDecision::Continue;
+    });
+
+    for (auto* block : empty_blocks) {
+#ifdef HEAP_DEBUG
+        dbgln(" - HeapBlock empty @ {}: cell_size={}", block, block->cell_size());
+#endif
+        allocator_for_size(block->cell_size()).block_did_become_empty({}, *block);
+    }
+
+    for (auto* block : full_blocks_that_became_usable) {
+#ifdef HEAP_DEBUG
+        dbgln(" - HeapBlock usable again @ {}: cell_size={}", block, block->cell_size());
+#endif
+        allocator_for_size(block->cell_size()).block_did_become_usable({}, *block);
+    }
+
+#ifdef HEAP_DEBUG
+    for_each_block([&](auto& block) {
+        dbgln(" > Live HeapBlock @ {}: cell_size={}", &block, block.cell_size());
+        return IterationDecision::Continue;
+    });
+#endif
+
+    int time_spent = measurement_timer.elapsed();
+
+    if (print_report) {
+        size_t live_block_count = 0;
+        for_each_block([&](auto&) {
+            ++live_block_count;
+            return IterationDecision::Continue;
+        });
+
+        dbgln("Garbage collection report");
+        dbgln("=============================================");
+        dbgln("     Time spent: {} ms", time_spent);
+        dbgln("     Live cells: {} ({} bytes)", live_cells, live_cell_bytes);
+        dbgln("Collected cells: {} ({} bytes)", collected_cells, collected_cell_bytes);
+        dbgln("    Live blocks: {} ({} bytes)", live_block_count, live_block_count * HeapBlock::block_size);
+        dbgln("   Freed blocks: {} ({} bytes)", empty_blocks.size(), empty_blocks.size() * HeapBlock::block_size);
+        dbgln("=============================================");
+    }
+}
+
+void Heap::did_create_handle(Badge<HandleImpl>, HandleImpl& impl)
+{
+    ASSERT(!m_handles.contains(&impl));
+    m_handles.set(&impl);
+}
+
+void Heap::did_destroy_handle(Badge<HandleImpl>, HandleImpl& impl)
+{
+    ASSERT(m_handles.contains(&impl));
+    m_handles.remove(&impl);
+}
+
+void Heap::did_create_marked_value_list(Badge<MarkedValueList>, MarkedValueList& list)
+{
+    ASSERT(!m_marked_value_lists.contains(&list));
+    m_marked_value_lists.set(&list);
+}
+
+void Heap::did_destroy_marked_value_list(Badge<MarkedValueList>, MarkedValueList& list)
+{
+    ASSERT(m_marked_value_lists.contains(&list));
+    m_marked_value_lists.remove(&list);
+}
+
+void Heap::defer_gc(Badge<DeferGC>)
+{
+    ++m_gc_deferrals;
+}
+
+void Heap::undefer_gc(Badge<DeferGC>)
+{
+    ASSERT(m_gc_deferrals > 0);
+    --m_gc_deferrals;
+
+    if (!m_gc_deferrals) {
+        if (m_should_gc_when_deferral_ends)
+            collect_garbage();
+        m_should_gc_when_deferral_ends = false;
+    }
+}
+
+}

Userland/Libraries/LibJS/Heap/Heap.h

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/HashTable.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/Allocator.h>
+#include <LibJS/Heap/Handle.h>
+#include <LibJS/Runtime/Cell.h>
+#include <LibJS/Runtime/Object.h>
+
+namespace JS {
+
+class Heap {
+    AK_MAKE_NONCOPYABLE(Heap);
+    AK_MAKE_NONMOVABLE(Heap);
+
+public:
+    explicit Heap(VM&);
+    ~Heap();
+
+    template<typename T, typename... Args>
+    T* allocate_without_global_object(Args&&... args)
+    {
+        auto* memory = allocate_cell(sizeof(T));
+        new (memory) T(forward<Args>(args)...);
+        return static_cast<T*>(memory);
+    }
+
+    template<typename T, typename... Args>
+    T* allocate(GlobalObject& global_object, Args&&... args)
+    {
+        auto* memory = allocate_cell(sizeof(T));
+        new (memory) T(forward<Args>(args)...);
+        auto* cell = static_cast<T*>(memory);
+        constexpr bool is_object = IsBaseOf<Object, T>::value;
+        if constexpr (is_object)
+            static_cast<Object*>(cell)->disable_transitions();
+        cell->initialize(global_object);
+        if constexpr (is_object)
+            static_cast<Object*>(cell)->enable_transitions();
+        return cell;
+    }
+
+    enum class CollectionType {
+        CollectGarbage,
+        CollectEverything,
+    };
+
+    void collect_garbage(CollectionType = CollectionType::CollectGarbage, bool print_report = false);
+
+    VM& vm() { return m_vm; }
+
+    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_value_list(Badge<MarkedValueList>, MarkedValueList&);
+    void did_destroy_marked_value_list(Badge<MarkedValueList>, MarkedValueList&);
+
+    void defer_gc(Badge<DeferGC>);
+    void undefer_gc(Badge<DeferGC>);
+
+private:
+    Cell* allocate_cell(size_t);
+
+    void gather_roots(HashTable<Cell*>&);
+    void gather_conservative_roots(HashTable<Cell*>&);
+    void mark_live_cells(const HashTable<Cell*>& live_cells);
+    void sweep_dead_cells(bool print_report, const Core::ElapsedTimer&);
+
+    Allocator& 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;
+        }
+    }
+
+    size_t m_max_allocations_between_gc { 10000 };
+    size_t m_allocations_since_last_gc { false };
+
+    bool m_should_collect_on_every_allocation { false };
+
+    VM& m_vm;
+
+    Vector<NonnullOwnPtr<Allocator>> m_allocators;
+    HashTable<HandleImpl*> m_handles;
+
+    HashTable<MarkedValueList*> m_marked_value_lists;
+
+    size_t m_gc_deferrals { 0 };
+    bool m_should_gc_when_deferral_ends { false };
+
+    bool m_collecting_garbage { false };
+};
+
+}

Userland/Libraries/LibJS/Heap/HeapBlock.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <AK/Assertions.h>
+#include <AK/NonnullOwnPtr.h>
+#include <AK/kmalloc.h>
+#include <LibJS/Heap/HeapBlock.h>
+#include <stdio.h>
+#include <sys/mman.h>
+
+namespace JS {
+
+NonnullOwnPtr<HeapBlock> HeapBlock::create_with_cell_size(Heap& heap, size_t cell_size)
+{
+    char name[64];
+    snprintf(name, sizeof(name), "LibJS: HeapBlock(%zu)", cell_size);
+#ifdef __serenity__
+    auto* block = (HeapBlock*)serenity_mmap(nullptr, block_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0, block_size, name);
+#else
+    auto* block = (HeapBlock*)aligned_alloc(block_size, block_size);
+#endif
+    ASSERT(block != MAP_FAILED);
+    new (block) HeapBlock(heap, cell_size);
+    return NonnullOwnPtr<HeapBlock>(NonnullOwnPtr<HeapBlock>::Adopt, *block);
+}
+
+void HeapBlock::operator delete(void* ptr)
+{
+#ifdef __serenity__
+    int rc = munmap(ptr, block_size);
+    ASSERT(rc == 0);
+#else
+    free(ptr);
+#endif
+}
+
+HeapBlock::HeapBlock(Heap& heap, size_t cell_size)
+    : m_heap(heap)
+    , m_cell_size(cell_size)
+{
+    ASSERT(cell_size >= sizeof(FreelistEntry));
+
+    FreelistEntry* next = nullptr;
+    for (ssize_t i = cell_count() - 1; i >= 0; i--) {
+        auto* freelist_entry = init_freelist_entry(i);
+        freelist_entry->set_live(false);
+        freelist_entry->next = next;
+        next = freelist_entry;
+    }
+    m_freelist = next;
+}
+
+void HeapBlock::deallocate(Cell* cell)
+{
+    ASSERT(cell->is_live());
+    ASSERT(!cell->is_marked());
+    cell->~Cell();
+    auto* freelist_entry = new (cell) FreelistEntry();
+    freelist_entry->set_live(false);
+    freelist_entry->next = m_freelist;
+    m_freelist = freelist_entry;
+}
+
+}

Userland/Libraries/LibJS/Heap/HeapBlock.h

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/IntrusiveList.h>
+#include <AK/Types.h>
+#include <LibJS/Forward.h>
+#include <LibJS/Runtime/Cell.h>
+
+namespace JS {
+
+class HeapBlock {
+    AK_MAKE_NONCOPYABLE(HeapBlock);
+    AK_MAKE_NONMOVABLE(HeapBlock);
+
+public:
+    static constexpr size_t block_size = 16 * KiB;
+    static NonnullOwnPtr<HeapBlock> create_with_cell_size(Heap&, size_t);
+
+    void operator delete(void*);
+
+    size_t cell_size() const { return m_cell_size; }
+    size_t cell_count() const { return (block_size - sizeof(HeapBlock)) / m_cell_size; }
+    bool is_full() const { return !m_freelist; }
+
+    ALWAYS_INLINE Cell* allocate()
+    {
+        if (!m_freelist)
+            return nullptr;
+        return exchange(m_freelist, m_freelist->next);
+    }
+
+    void deallocate(Cell*);
+
+    template<typename Callback>
+    void for_each_cell(Callback callback)
+    {
+        for (size_t i = 0; i < cell_count(); ++i)
+            callback(cell(i));
+    }
+
+    Heap& heap() { return m_heap; }
+
+    static HeapBlock* from_cell(const Cell* cell)
+    {
+        return reinterpret_cast<HeapBlock*>((FlatPtr)cell & ~(block_size - 1));
+    }
+
+    Cell* cell_from_possible_pointer(FlatPtr pointer)
+    {
+        if (pointer < reinterpret_cast<FlatPtr>(m_storage))
+            return nullptr;
+        size_t cell_index = (pointer - reinterpret_cast<FlatPtr>(m_storage)) / m_cell_size;
+        if (cell_index >= cell_count())
+            return nullptr;
+        return cell(cell_index);
+    }
+
+    IntrusiveListNode m_list_node;
+
+private:
+    HeapBlock(Heap&, size_t cell_size);
+
+    struct FreelistEntry final : public Cell {
+        FreelistEntry* next { nullptr };
+
+        virtual const char* class_name() const override { return "FreelistEntry"; }
+    };
+
+    Cell* cell(size_t index)
+    {
+        return reinterpret_cast<Cell*>(&m_storage[index * cell_size()]);
+    }
+
+    FreelistEntry* init_freelist_entry(size_t index)
+    {
+        return new (&m_storage[index * cell_size()]) FreelistEntry();
+    }
+
+    Heap& m_heap;
+    size_t m_cell_size { 0 };
+    FreelistEntry* m_freelist { nullptr };
+    alignas(Cell) u8 m_storage[];
+};
+
+}