ladybird/Userland/Libraries/LibJS/Runtime/EnvironmentCoordinate.h

/*
 * Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <AK/Types.h>
#include <LibJS/Forward.h>

namespace JS {

struct EnvironmentCoordinate {
    u32 hops { invalid_marker };
    u32 index { invalid_marker };

    static FlatPtr hops_offset() { return OFFSET_OF(EnvironmentCoordinate, hops); }
    static FlatPtr index_offset() { return OFFSET_OF(EnvironmentCoordinate, index); }

    bool is_valid() const { return hops != invalid_marker && index != invalid_marker; }

    static constexpr u32 invalid_marker = 0xfffffffe;
};

}
LibJS: Fast non-local variable access :^) This patch introduces the "environment coordinate" concept, which encodes the distance from a variable access to the binding it ends up resolving to. EnvironmentCoordinate has two fields: - hops: The number of hops up the lexical environment chain we have to make before getting to the resolved binding. - index: The index of the resolved binding within its declarative environment record. Whenever a variable lookup resolves somewhere inside a declarative environment, we now cache the coordinates and reuse them in subsequent lookups. This is achieved via a coordinate cache in JS::Identifier. Note that non-strict direct eval() breaks this optimization and so it will not be performed if the resolved environment has been permanently screwed by eval(). This makes variable access significantly faster. :^) 2021-10-07 01:06:21 +02:00			`/*`
			`* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>`
			`*`
			`* SPDX-License-Identifier: BSD-2-Clause`
			`*/`

			`#pragma once`

LibJS: Add missing header in EnvironmentCoordinate.h 2021-10-10 15:44:22 +02:00			`#include <AK/Types.h>`
LibJS: Fast non-local variable access :^) This patch introduces the "environment coordinate" concept, which encodes the distance from a variable access to the binding it ends up resolving to. EnvironmentCoordinate has two fields: - hops: The number of hops up the lexical environment chain we have to make before getting to the resolved binding. - index: The index of the resolved binding within its declarative environment record. Whenever a variable lookup resolves somewhere inside a declarative environment, we now cache the coordinates and reuse them in subsequent lookups. This is achieved via a coordinate cache in JS::Identifier. Note that non-strict direct eval() breaks this optimization and so it will not be performed if the resolved environment has been permanently screwed by eval(). This makes variable access significantly faster. :^) 2021-10-07 01:06:21 +02:00			`#include <LibJS/Forward.h>`

			`namespace JS {`

			`struct EnvironmentCoordinate {`
LibJS: Shrink Identifier's environment coordinate cache This patch does two things: - We now use u32 instead of size_t for the hops and index fields in EnvironmentCoordinate. This means we're limited to an environment nesting level and variable count of 4Gs respectively. - Instead of wrapping it in an Optional, EnvironmentCoordinate now has a custom valid/invalid state using a magic marker value. These two changes reduce the size of Identifier by 16 bytes. :^) 2022-11-21 18:01:22 +01:00			`u32 hops { invalid_marker };`
			`u32 index { invalid_marker };`
LibJS: Cache access to bindings in the global environment This patch adds a special EnvironmentCoordinate::global_marker value that signifies that a binding lookup ended up searching the global environment. It doesn't matter if we find it there or not, the global marker is always returned. This allows us to bypass other environments on subsequent access, going directly to the global environment. 2022-11-10 20:55:03 +01:00
LibJS/JIT: Add fast path for cached GetVariable accesses We can now stay in machine code for environment variable read accesses as long as they are cached and initialized. 20% speed-up on Octane/zlib.js :^) 2023-11-06 15:23:49 +01:00			`static FlatPtr hops_offset() { return OFFSET_OF(EnvironmentCoordinate, hops); }`
			`static FlatPtr index_offset() { return OFFSET_OF(EnvironmentCoordinate, index); }`

LibJS: Shrink Identifier's environment coordinate cache This patch does two things: - We now use u32 instead of size_t for the hops and index fields in EnvironmentCoordinate. This means we're limited to an environment nesting level and variable count of 4Gs respectively. - Instead of wrapping it in an Optional, EnvironmentCoordinate now has a custom valid/invalid state using a magic marker value. These two changes reduce the size of Identifier by 16 bytes. :^) 2022-11-21 18:01:22 +01:00			`bool is_valid() const { return hops != invalid_marker && index != invalid_marker; }`

			`static constexpr u32 invalid_marker = 0xfffffffe;`
LibJS: Fast non-local variable access :^) This patch introduces the "environment coordinate" concept, which encodes the distance from a variable access to the binding it ends up resolving to. EnvironmentCoordinate has two fields: - hops: The number of hops up the lexical environment chain we have to make before getting to the resolved binding. - index: The index of the resolved binding within its declarative environment record. Whenever a variable lookup resolves somewhere inside a declarative environment, we now cache the coordinates and reuse them in subsequent lookups. This is achieved via a coordinate cache in JS::Identifier. Note that non-strict direct eval() breaks this optimization and so it will not be performed if the resolved environment has been permanently screwed by eval(). This makes variable access significantly faster. :^) 2021-10-07 01:06:21 +02:00			`};`

			`}`