Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-28 03:44:15 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibJS/Heap/Cell.h

86 lines
1.7 KiB
C
Raw Normal View History

LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
*/
#pragma once
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
#include <AK/Format.h>
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
#include <AK/Forward.h>
LibJS: Make JS::Cell non-copyable and non-movable Also make the JS::Cell default constructor protected to provove a compilation error if you tried to allocate a plain cell.
2020-04-02 14:55:29 +02:00
#include <AK/Noncopyable.h>
LibJS: Add a convenience helper for visiting a JS::Value We only really care to visit values if they refer to a Cell, but it's nice to be able to say visit(some_value).
2020-03-09 22:14:51 +01:00
#include <LibJS/Forward.h>
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
namespace JS {
class Cell {
LibJS: Make JS::Cell non-copyable and non-movable Also make the JS::Cell default constructor protected to provove a compilation error if you tried to allocate a plain cell.
2020-04-02 14:55:29 +02:00
AK_MAKE_NONCOPYABLE(Cell);
AK_MAKE_NONMOVABLE(Cell);
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
public:
LibJS: Simplify Cell::initialize() Remove the Interpreter& argument and pass only GlobalObject&. We can find everything we need via the global object anyway.
2020-07-22 17:50:18 +02:00
virtual void initialize(GlobalObject&) { }
LibJS: Move native objects towards two-pass construction To make sure that everything is set up correctly in objects before we start adding properties to them, we split cell allocation into 3 steps: 1. Allocate a cell of appropriate size from the Heap 2. Call the C++ constructor on the cell 3. Call initialize() on the constructed object The job of initialize() is to define all the initial properties. Doing it in a second pass guarantees that the Object has a valid Shape and can find its own GlobalObject.
2020-06-20 15:40:48 +02:00
virtual ~Cell() { }
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
bool is_marked() const { return m_mark; }
void set_marked(bool b) { m_mark = b; }
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#ifdef JS_TRACK_ZOMBIE_CELLS
virtual void did_become_zombie()
{
}
#endif
LibJS+js+test-js: Add GC debug mode that keeps cells "alive" as zombies This patch adds a `-z` option to js and test-js. When run in this mode, garbage cells are never actually destroyed. We instead keep them around in a special zombie state. This allows us to validate that zombies don't get marked in future GC scans (since there were not supposed to be any more references!) :^) Cells get notified when they become a zombie (via did_become_zombie()) and this is used by WeakContainer cells to deregister themselves from the heap.
2021-09-11 16:44:40 +02:00
LibJS: Replace Cell live bit with a cell state So far we only have two states: Live and Dead. In the future, we can add additional states to support incremental sweeping and/or multi- stage cell destruction.
2021-05-25 18:35:27 +02:00
enum class State {
Live,
Dead,
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#ifdef JS_TRACK_ZOMBIE_CELLS
LibJS+js+test-js: Add GC debug mode that keeps cells "alive" as zombies This patch adds a `-z` option to js and test-js. When run in this mode, garbage cells are never actually destroyed. We instead keep them around in a special zombie state. This allows us to validate that zombies don't get marked in future GC scans (since there were not supposed to be any more references!) :^) Cells get notified when they become a zombie (via did_become_zombie()) and this is used by WeakContainer cells to deregister themselves from the heap.
2021-09-11 16:44:40 +02:00
Zombie,
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#endif
LibJS: Replace Cell live bit with a cell state So far we only have two states: Live and Dead. In the future, we can add additional states to support incremental sweeping and/or multi- stage cell destruction.
2021-05-25 18:35:27 +02:00
};
State state() const { return m_state; }
void set_state(State state) { m_state = state; }
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
virtual const char* class_name() const = 0;
class Visitor {
public:
LibJS: Inline Cell::Visitor::visit() functions This allows the calls to MarkingVisitor::visit_impl() during GC to be devirtualized in Heap::mark_live_cells().
2021-05-25 18:17:41 +02:00
void visit(Cell* cell)
{
if (cell)
LibJS: Make Cell::Visitor::visit_impl() take a Cell& Passing a null cell pointer is not supported.
2021-05-25 18:39:01 +02:00
visit_impl(*cell);
LibJS: Inline Cell::Visitor::visit() functions This allows the calls to MarkingVisitor::visit_impl() during GC to be devirtualized in Heap::mark_live_cells().
2021-05-25 18:17:41 +02:00
}
LibJS: Add a convenience helper for visiting a JS::Value We only really care to visit values if they refer to a Cell, but it's nice to be able to say visit(some_value).
2020-03-09 22:14:51 +01:00
void visit(Value);
LibJS: Allow cells to mark null pointers This simplifies the cell visiting functions by letting them not worry about the pointers they pass to the visitor being null.
2020-04-16 16:07:50 +02:00
protected:
LibJS: Make Cell::Visitor::visit_impl() take a Cell& Passing a null cell pointer is not supported.
2021-05-25 18:39:01 +02:00
virtual void visit_impl(Cell&) = 0;
Everything: Add `-Wnon-virtual-dtor` flag This flag warns on classes which have `virtual` functions but do not have a `virtual` destructor. This patch adds both the flag and missing destructors. The access level of the destructors was determined by a two rules of thumb: 1. A destructor should have a similar or lower access level to that of a constructor. 2. Having a `private` destructor implicitly deletes the default constructor, which is probably undesirable for "interface" types (classes with only virtual functions and no data). In short, most of the added destructors are `protected`, unless the compiler complained about access.
2021-04-15 10:43:29 -07:00
virtual ~Visitor() = default;
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
};
LibJS: Drop "Record" suffix from all the *Environment record classes "Records" in the spec are basically C++ classes, so let's drop this mouthful of a suffix.
2021-07-01 12:24:46 +02:00
virtual bool is_environment() const { return false; }
LibJS: Rename Cell::visit_children() => Cell::visit_edges() The GC heap is really a graph of cells, so "children" didn't quite feel appropriate here.
2020-11-28 14:33:36 +01:00
virtual void visit_edges(Visitor&) { }
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
LibJS: Loosen type system This commits makes effort towards tolerating some of javascript's quirks when it comes to its type system, note that the interpreter's way of handling type coercion is still not mature at all, for example, we still have to implement NaN instead of just crashing when trying to parse a string and failing.
2020-03-16 00:19:41 +02:00
Heap& heap() const;
LibJS: Add a way to get from a Cell to the VM
2020-09-21 15:30:14 +02:00
VM& vm() const;
LibJS: Make it possible to go from a Cell* to its Heap& This patch makes all HeapBlock allocations aligned to their block size, enabling us to find the HeapBlock* for a given Cell* by simply masking bits off of the cell address. Use this to make a simple Heap& getter for Cell, which lets us avoid plumbing the Heap& everywhere.
2020-03-13 11:01:44 +01:00
LibJS: Make JS::Cell non-copyable and non-movable Also make the JS::Cell default constructor protected to provove a compilation error if you tried to allocate a plain cell.
2020-04-02 14:55:29 +02:00
protected:
LibJS: Move native objects towards two-pass construction To make sure that everything is set up correctly in objects before we start adding properties to them, we split cell allocation into 3 steps: 1. Allocate a cell of appropriate size from the Heap 2. Call the C++ constructor on the cell 3. Call initialize() on the constructed object The job of initialize() is to define all the initial properties. Doing it in a second pass guarantees that the Object has a valid Shape and can find its own GlobalObject.
2020-06-20 15:40:48 +02:00
Cell() { }
LibJS: Make JS::Cell non-copyable and non-movable Also make the JS::Cell default constructor protected to provove a compilation error if you tried to allocate a plain cell.
2020-04-02 14:55:29 +02:00
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
private:
LibJS: Replace Cell live bit with a cell state So far we only have two states: Live and Dead. In the future, we can add additional states to support incremental sweeping and/or multi- stage cell destruction.
2021-05-25 18:35:27 +02:00
bool m_mark : 1 { false };
State m_state : 7 { State::Live };
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
};
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
}
template<>
AK: Add Formatter<FormatString> as helper class.
2021-01-09 01:00:22 +01:00
struct AK::Formatter<JS::Cell> : AK::Formatter<FormatString> {
AK+Format: Remove TypeErasedFormatParams& from format function.
2020-12-30 12:14:15 +01:00
void format(FormatBuilder& builder, const JS::Cell* cell)
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
{
if (!cell)
AK: Add Formatter<FormatString> as helper class.
2021-01-09 01:00:22 +01:00
Formatter<FormatString>::format(builder, "Cell{nullptr}");
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
else
AK: Add Formatter<FormatString> as helper class.
2021-01-09 01:00:22 +01:00
Formatter<FormatString>::format(builder, "{}({})", cell->class_name(), cell);
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
}
};
Reference in a new issue Copy permalink