beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 09:00:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Revert "LibWasm: Some more performance stuff (#8812)"

Browse source 
This reverts commit 35394dbfaa.
I pushed the wrong button again, hopefully this will be the last of
such incidents.
This commit is contained in:
Ali Mohammad Pur 2021-07-17 01:11:28 +04:30
parent 35394dbfaa
commit 23b48f8fe1
Notes: sideshowbarker 2024-07-18 08:54:51 +09:00 
Author: https://github.com/alimpfard
Commit: https://github.com/SerenityOS/serenity/commit/23b48f8fe12
8 changed files with 27 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Tests/LibWasm/test-wasm.cpp
View file

@ -34,7 +34,6 @@ public:
explicit WebAssemblyModule(JS::Object& prototype)
: JS::Object(prototype)
{
m_machine.enable_instruction_count_limit();
}
static Wasm::AbstractMachine& machine() { return m_machine; }

10
Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.cpp
View file

@ -128,8 +128,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
module.for_each_section_of_type<GlobalSection>([&](auto& global_section) {
for (auto& entry : global_section.entries()) {
Configuration config { m_store };
if (m_should_limit_instruction_count)
config.enable_instruction_count_limit();
config.set_frame(Frame {
auxiliary_instance,
Vector<Value> {},
@ -155,8 +153,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
Vector<Reference> references;
for (auto& entry : segment.init) {
Configuration config { m_store };
if (m_should_limit_instruction_count)
config.enable_instruction_count_limit();
config.set_frame(Frame {
main_module_instance,
Vector<Value> {},
@ -208,8 +204,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
return IterationDecision::Break;
}
Configuration config { m_store };
if (m_should_limit_instruction_count)
config.enable_instruction_count_limit();
config.set_frame(Frame {
main_module_instance,
Vector<Value> {},
@ -268,8 +262,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
segment.value().visit(
[&](DataSection::Data::Active const& data) {
Configuration config { m_store };
if (m_should_limit_instruction_count)
config.enable_instruction_count_limit();
config.set_frame(Frame {
main_module_instance,
Vector<Value> {},
@ -447,8 +439,6 @@ Result AbstractMachine::invoke(FunctionAddress address, Vector<Value> arguments)
Result AbstractMachine::invoke(Interpreter& interpreter, FunctionAddress address, Vector<Value> arguments)
{
Configuration configuration { m_store };
if (m_should_limit_instruction_count)
configuration.enable_instruction_count_limit();
return configuration.call(interpreter, address, move(arguments));
}

13
Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.h
View file

@ -130,26 +130,26 @@ public:
}
}
ALWAYS_INLINE Value(Value const& value)
Value(Value const& value)
: m_value(AnyValueType { value.m_value })
, m_type(value.m_type)
{
}
ALWAYS_INLINE Value(Value&& value)
Value(Value&& value)
: m_value(move(value.m_value))
, m_type(move(value.m_type))
{
}
ALWAYS_INLINE Value& operator=(Value&& value)
Value& operator=(Value&& value)
{
m_value = move(value.m_value);
m_type = move(value.m_type);
return *this;
}
ALWAYS_INLINE Value& operator=(Value const& value)
Value& operator=(Value const& value)
{
m_value = value.m_value;
m_type = value.m_type;
@ -157,7 +157,7 @@ public:
}
template<typename T>
ALWAYS_INLINE Optional<T> to()
Optional<T> to()
{
Optional<T> result;
m_value.visit(
@ -505,13 +505,10 @@ public:
auto& store() const { return m_store; }
auto& store() { return m_store; }
void enable_instruction_count_limit() { m_should_limit_instruction_count = true; }
private:
Optional<InstantiationError> allocate_all_initial_phase(Module const&, ModuleInstance&, Vector<ExternValue>&, Vector<Value>& global_values);
Optional<InstantiationError> allocate_all_final_phase(Module const&, ModuleInstance&, Vector<Vector<Reference>>& elements);
Store m_store;
bool m_should_limit_instruction_count { false };
};
class Linker {

27
Userland/Libraries/LibWasm/AbstractMachine/BytecodeInterpreter.cpp
View file

@ -37,15 +37,12 @@ void BytecodeInterpreter::interpret(Configuration& configuration)
auto& instructions = configuration.frame().expression().instructions();
auto max_ip_value = InstructionPointer { instructions.size() };
auto& current_ip_value = configuration.ip();
auto const should_limit_instruction_count = configuration.should_limit_instruction_count();
u64 executed_instructions = 0;
while (current_ip_value < max_ip_value) {
if (should_limit_instruction_count) {
if (executed_instructions++ >= Constants::max_allowed_executed_instructions_per_call) [[unlikely]] {
m_trap = Trap { "Exceeded maximum allowed number of instructions" };
return;
}
if (executed_instructions++ >= Constants::max_allowed_executed_instructions_per_call) [[unlikely]] {
m_trap = Trap { "Exceeded maximum allowed number of instructions" };
return;
}
auto& instruction = instructions[current_ip_value.value()];
auto old_ip = current_ip_value;
@ -1126,15 +1123,17 @@ void DebuggerBytecodeInterpreter::interpret(Configuration& configuration, Instru
}
}
BytecodeInterpreter::interpret(configuration, ip, instruction);
if (post_interpret_hook) {
auto result = post_interpret_hook(configuration, ip, instruction, *this);
if (!result) {
m_trap = Trap { "Trapped by user request" };
return;
ScopeGuard guard { [&] {
if (post_interpret_hook) {
auto result = post_interpret_hook(configuration, ip, instruction, *this);
if (!result) {
m_trap = Trap { "Trapped by user request" };
return;
}
}
}
} };
BytecodeInterpreter::interpret(configuration, ip, instruction);
}
}

2
Userland/Libraries/LibWasm/AbstractMachine/BytecodeInterpreter.h
View file

@ -50,7 +50,7 @@ protected:
T read_value(ReadonlyBytes data);
Vector<Value> pop_values(Configuration& configuration, size_t count);
ALWAYS_INLINE bool trap_if_not(bool value, StringView reason)
bool trap_if_not(bool value, StringView reason)
{
if (!value)
m_trap = Trap { reason };

4
Userland/Libraries/LibWasm/AbstractMachine/Configuration.h
View file

@ -61,9 +61,6 @@ public:
Result call(Interpreter&, FunctionAddress, Vector<Value> arguments);
Result execute(Interpreter&);
void enable_instruction_count_limit() { m_should_limit_instruction_count = true; }
bool should_limit_instruction_count() const { return m_should_limit_instruction_count; }
void dump_stack();
private:
@ -72,7 +69,6 @@ private:
Stack m_stack;
size_t m_depth { 0 };
InstructionPointer m_ip;
bool m_should_limit_instruction_count { false };
};
}

1
Userland/Libraries/LibWeb/WebAssembly/WebAssemblyObject.cpp
View file

@ -25,7 +25,6 @@ namespace Web::Bindings {
WebAssemblyObject::WebAssemblyObject(JS::GlobalObject& global_object)
: Object(*global_object.object_prototype())
{
s_abstract_machine.enable_instruction_count_limit();
}
void WebAssemblyObject::initialize(JS::GlobalObject& global_object)

18
Userland/Utilities/wasm.cpp
View file

@ -512,16 +512,14 @@ int main(int argc, char* argv[])
if (debug)
launch_repl();
if (result.is_trap()) {
warnln("Execution trapped: {}", result.trap().reason);
} else {
if (!result.values().is_empty())
warnln("Returned:");
for (auto& value : result.values()) {
Wasm::Printer printer { stream };
g_stdout.write(" -> "sv.bytes());
g_printer.print(value);
}
if (result.is_trap())
warnln("Execution trapped!");
if (!result.values().is_empty())
warnln("Returned:");
for (auto& value : result.values()) {
Wasm::Printer printer { stream };
g_stdout.write(" -> "sv.bytes());
g_printer.print(value);
}
}
}