Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-27 03:14:15 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/Runtime/IteratorHelper.cpp

73 lines
2.5 KiB
C++
Raw Normal View History

LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
/*
* Copyright (c) 2023, Tim Flynn <trflynn89@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibJS/Runtime/GlobalObject.h>
LibJS+LibWeb: Move IteratorOperations.h AOs to Iterator.h Rather than splitting the Iterator type and its AOs into two files, let's combine them into one file to match every other JS runtime object that we have.
2023-07-19 06:54:48 -04:00
#include <LibJS/Runtime/Iterator.h>
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
#include <LibJS/Runtime/IteratorHelper.h>
#include <LibJS/Runtime/Realm.h>
namespace JS {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_DEFINE_ALLOCATOR(IteratorHelper);
LibJS: Segregate GC-allocated objects by type This patch adds two macros to declare per-type allocators: - JS_DECLARE_ALLOCATOR(TypeName) - JS_DEFINE_ALLOCATOR(TypeName) When used, they add a type-specific CellAllocator that the Heap will delegate allocation requests to. The result of this is that GC objects of the same type always end up within the same HeapBlock, drastically reducing the ability to perform type confusion attacks. It also improves HeapBlock utilization, since each block now has cells sized exactly to the type used within that block. (Previously we only had a handful of block sizes available, and most GC allocations ended up with a large amount of slack in their tails.) There is a small performance hit from this, but I'm sure we can make up for it elsewhere. Note that the old size-based allocators still exist, and we fall back to them for any type that doesn't have its own CellAllocator.
2023-11-19 09:45:05 +01:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
ThrowCompletionOr<GC::Ref<IteratorHelper>> IteratorHelper::create(Realm& realm, GC::Ref<IteratorRecord> underlying_iterator, GC::Ref<Closure> closure, GC::Ptr<AbruptClosure> abrupt_closure)
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
{
LibJS+LibWeb: Use realm.create<T> instead of heap.allocate<T> The main motivation behind this is to remove JS specifics of the Realm from the implementation of the Heap. As a side effect of this change, this is a bit nicer to read than the previous approach, and in my opinion, also makes it a little more clear that this method is specific to a JavaScript Realm.
2024-11-14 05:50:17 +13:00
return realm.create<IteratorHelper>(realm, realm.intrinsics().iterator_helper_prototype(), move(underlying_iterator), closure, abrupt_closure);
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
}
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
IteratorHelper::IteratorHelper(Realm& realm, Object& prototype, GC::Ref<IteratorRecord> underlying_iterator, GC::Ref<Closure> closure, GC::Ptr<AbruptClosure> abrupt_closure)
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
: GeneratorObject(realm, prototype, realm.vm().running_execution_context().copy(), "Iterator Helper"sv)
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
, m_underlying_iterator(move(underlying_iterator))
LibJS: Use HeapFunction for IteratorHelper
2024-08-18 14:54:48 +12:00
, m_closure(closure)
, m_abrupt_closure(abrupt_closure)
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
{
}
void IteratorHelper::visit_edges(Visitor& visitor)
{
Base::visit_edges(visitor);
LibJS: Stop converting between Object <-> IteratorRecord all the time This patch makes IteratorRecord an Object. Although it's not exposed to author code, this does allow us to store it in a VM register. Now that we can store it in a VM register, we don't need to convert it back and forth between IteratorRecord and Object when accessing it from bytecode. The big win here is avoiding 3 [[Get]] accesses on every iteration step of for..of loops. There are also a bunch of smaller efficiencies gained. 20% speed-up on this microbenchmark: function go(a) { for (const p of a) { } } const a = []; a.length = 1_000_000; go(a);
2023-12-07 10:44:41 +01:00
visitor.visit(m_underlying_iterator);
LibJS: Use HeapFunction for IteratorHelper
2024-08-18 14:54:48 +12:00
visitor.visit(m_closure);
visitor.visit(m_abrupt_closure);
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
}
Value IteratorHelper::result(Value value)
{
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
set_generator_state(value.is_undefined() ? GeneratorState::Completed : GeneratorState::SuspendedYield);
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
return value;
}
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
ThrowCompletionOr<Value> IteratorHelper::close_result(VM& vm, Completion completion)
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
{
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
set_generator_state(GeneratorState::Completed);
LibJS: Make Completion.[[Value]] non-optional Instead, just use js_undefined() whenever the [[Value]] field is unused. This avoids a whole bunch of presence checks.
2025-04-04 18:11:45 +02:00
return TRY(iterator_close(vm, underlying_iterator(), move(completion)));
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
}
LibJS: Skip iteration result allocation in AsyncFunctionDriverWrapper - Create less GC pressure by making each `await` in async function skip iteration result object allocation. - Skip uncached `Object::get()` calls to extract `value` and `done` from the iteration result object. With this change, following function goes 30% faster on my computer: ```js (async () => { const resolved = Promise.resolve(); for (let i = 0; i < 5_000_000; i++) { await resolved; } })(); ```
2025-05-09 04:23:30 +03:00
ThrowCompletionOr<GeneratorObject::IterationResult> IteratorHelper::execute(VM& vm, JS::Completion const& completion)
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
{
ScopeGuard guard { [&] { vm.pop_execution_context(); } };
LibJS: Handle abrupt closures from Iterator.prototype.flatMap This is in preparation of implementing %IteratorHelperPrototype%.return. That will invoke GeneratorResumeAbrupt, which will execute the generator with an abrupt completion. At that time, we must take care to close the current inner iterator.
2023-07-16 15:50:56 -04:00
if (completion.is_abrupt()) {
LibJS: Skip iteration result allocation in AsyncFunctionDriverWrapper - Create less GC pressure by making each `await` in async function skip iteration result object allocation. - Skip uncached `Object::get()` calls to extract `value` and `done` from the iteration result object. With this change, following function goes 30% faster on my computer: ```js (async () => { const resolved = Promise.resolve(); for (let i = 0; i < 5_000_000; i++) { await resolved; } })(); ```
2025-05-09 04:23:30 +03:00
if (m_abrupt_closure) {
auto abrupt_result = TRY(m_abrupt_closure->function()(vm, *this, completion));
return IterationResult(abrupt_result, true);
}
auto close_result = TRY(this->close_result(vm, completion));
return IterationResult(close_result, true);
LibJS: Handle abrupt closures from Iterator.prototype.flatMap This is in preparation of implementing %IteratorHelperPrototype%.return. That will invoke GeneratorResumeAbrupt, which will execute the generator with an abrupt completion. At that time, we must take care to close the current inner iterator.
2023-07-16 15:50:56 -04:00
}
LibJS: Use HeapFunction for IteratorHelper
2024-08-18 14:54:48 +12:00
auto result_value = m_closure->function()(vm, *this);
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
if (result_value.is_throw_completion()) {
set_generator_state(GeneratorState::Completed);
LibJS: Skip iteration result allocation in AsyncFunctionDriverWrapper - Create less GC pressure by making each `await` in async function skip iteration result object allocation. - Skip uncached `Object::get()` calls to extract `value` and `done` from the iteration result object. With this change, following function goes 30% faster on my computer: ```js (async () => { const resolved = Promise.resolve(); for (let i = 0; i < 5_000_000; i++) { await resolved; } })(); ```
2025-05-09 04:23:30 +03:00
return result_value.throw_completion();
LibJS: Convert IteratorHelper to be a GeneratorObject This is required for %IteratorHelperPrototype%.return, which needs to operate on the internal slots of the base GeneratorObject. Doing so also provides us with the appropriate VM to be used in invocations to the overridden IteratorHelper::execute.
2023-07-16 15:04:59 -04:00
}
LibJS: Skip iteration result allocation in AsyncFunctionDriverWrapper - Create less GC pressure by making each `await` in async function skip iteration result object allocation. - Skip uncached `Object::get()` calls to extract `value` and `done` from the iteration result object. With this change, following function goes 30% faster on my computer: ```js (async () => { const resolved = Promise.resolve(); for (let i = 0; i < 5_000_000; i++) { await resolved; } })(); ```
2025-05-09 04:23:30 +03:00
return IterationResult(result(result_value.release_value()), generator_state() == GeneratorState::Completed);
LibJS: Implement Iterator.prototype.map This uses a new Iterator type called IteratorHelper. This does not implement IteratorHelper.prototype.return as that relies on generator objects (i.e. the internal slots of JS::GeneratorObject), which are not hooked up here.
2023-06-25 09:39:33 -04:00
}
}
Reference in a new issue Copy permalink