3cb376dc83
Currently each isolate stores its own array of
{CallInterfaceDescriptorData}. This array has size 173, and each entry
has 40 bytes. That's already 7kB per isolate.
Additionally, each {CallInterfaceDescriptorData} allocates two
heap-allocated arrays, which probably add up to more than the static
size of the {CallInterfaceDescriptorData}. Note that all the
{CallInterfaceDescriptorData} instances are initialized eagerly on
isolate creation.
Since {CallInterfaceDescriptor} is totally isolate independent itself,
this CL refactors the current design to avoid a copy of them per
isolate, and instead shares them process-wide. Still, we need to free
the allocated heap arrays when the last isolate dies to avoid leaks.
This can probably be refactored later by statically initializing more
and avoiding the heap allocations all together.
This refactoring will also allow us to use {CallInterfaceDescriptor}s
from wasm background compilation threads, which are not bound to any
isolate.
R=mstarzinger@chromium.org, titzer@chromium.org
Bug: v8:6600
Change-Id: If8625b89951eec8fa8986b49a5c166e874a72494
Reviewed-on: https://chromium-review.googlesource.com/1100879
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53803}
76 lines
2.6 KiB
C++
76 lines
2.6 KiB
C++
// Copyright 2016 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef V8_TEST_CCTEST_COMPILER_CODE_ASSEMBLER_TESTER_H_
|
|
#define V8_TEST_CCTEST_COMPILER_CODE_ASSEMBLER_TESTER_H_
|
|
|
|
#include "src/compiler/code-assembler.h"
|
|
#include "src/compiler/raw-machine-assembler.h"
|
|
#include "src/handles.h"
|
|
#include "src/interface-descriptors.h"
|
|
#include "src/isolate.h"
|
|
#include "test/cctest/compiler/function-tester.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace compiler {
|
|
|
|
class CodeAssemblerTester {
|
|
public:
|
|
// Test generating code for a stub. Assumes VoidDescriptor call interface.
|
|
explicit CodeAssemblerTester(Isolate* isolate, const char* name = "test")
|
|
: zone_(isolate->allocator(), ZONE_NAME),
|
|
scope_(isolate),
|
|
state_(isolate, &zone_, VoidDescriptor{}, Code::STUB, name,
|
|
PoisoningMitigationLevel::kDontPoison) {}
|
|
|
|
// Test generating code for a JS function (e.g. builtins).
|
|
CodeAssemblerTester(Isolate* isolate, int parameter_count,
|
|
Code::Kind kind = Code::BUILTIN,
|
|
const char* name = "test")
|
|
: zone_(isolate->allocator(), ZONE_NAME),
|
|
scope_(isolate),
|
|
state_(isolate, &zone_, parameter_count, kind, name,
|
|
PoisoningMitigationLevel::kDontPoison) {}
|
|
|
|
CodeAssemblerTester(Isolate* isolate, Code::Kind kind,
|
|
const char* name = "test")
|
|
: zone_(isolate->allocator(), ZONE_NAME),
|
|
scope_(isolate),
|
|
state_(isolate, &zone_, 0, kind, name,
|
|
PoisoningMitigationLevel::kDontPoison) {}
|
|
|
|
CodeAssemblerTester(Isolate* isolate, CallDescriptor* call_descriptor,
|
|
const char* name = "test")
|
|
: zone_(isolate->allocator(), ZONE_NAME),
|
|
scope_(isolate),
|
|
state_(isolate, &zone_, call_descriptor, Code::STUB, name,
|
|
PoisoningMitigationLevel::kDontPoison, 0, -1) {}
|
|
|
|
CodeAssemblerState* state() { return &state_; }
|
|
|
|
// Direct low-level access to the machine assembler, for testing only.
|
|
RawMachineAssembler* raw_assembler_for_testing() {
|
|
return state_.raw_assembler_.get();
|
|
}
|
|
|
|
Handle<Code> GenerateCode() { return CodeAssembler::GenerateCode(&state_); }
|
|
|
|
Handle<Code> GenerateCodeCloseAndEscape() {
|
|
return scope_.CloseAndEscape(GenerateCode());
|
|
}
|
|
|
|
private:
|
|
Zone zone_;
|
|
HandleScope scope_;
|
|
LocalContext context_;
|
|
CodeAssemblerState state_;
|
|
};
|
|
|
|
} // namespace compiler
|
|
} // namespace internal
|
|
} // namespace v8
|
|
|
|
#endif // V8_TEST_CCTEST_COMPILER_CODE_ASSEMBLER_TESTER_H_
|