2018-12-05 16:12:12 +00:00
|
|
|
// Copyright 2018 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.
|
|
|
|
|
2019-05-13 15:13:08 +00:00
|
|
|
#include <memory>
|
|
|
|
|
2018-12-05 16:12:12 +00:00
|
|
|
#include "include/v8.h"
|
|
|
|
|
2019-05-21 09:30:15 +00:00
|
|
|
#include "src/codegen/code-desc.h"
|
2019-05-22 07:55:37 +00:00
|
|
|
#include "src/execution/isolate.h"
|
2019-05-22 12:44:24 +00:00
|
|
|
#include "src/handles/handles-inl.h"
|
2018-12-05 16:12:12 +00:00
|
|
|
#include "test/cctest/cctest.h"
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
namespace test_factory {
|
|
|
|
|
2019-05-13 15:13:08 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
// This needs to be large enough to create a new nosnap Isolate, but smaller
|
|
|
|
// than kMaximalCodeRangeSize so we can recover from the OOM.
|
|
|
|
constexpr int kInstructionSize = 100 * MB;
|
2020-02-20 18:02:57 +00:00
|
|
|
STATIC_ASSERT(kInstructionSize < kMaximalCodeRangeSize ||
|
|
|
|
!kPlatformRequiresCodeRange);
|
2019-05-13 15:13:08 +00:00
|
|
|
|
|
|
|
size_t NearHeapLimitCallback(void* raw_bool, size_t current_heap_limit,
|
|
|
|
size_t initial_heap_limit) {
|
|
|
|
bool* oom_triggered = static_cast<bool*>(raw_bool);
|
|
|
|
*oom_triggered = true;
|
|
|
|
return kInstructionSize * 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
class SetupIsolateWithSmallHeap {
|
|
|
|
public:
|
|
|
|
SetupIsolateWithSmallHeap() {
|
|
|
|
FLAG_max_old_space_size = kInstructionSize / MB / 2; // In MB.
|
|
|
|
v8::Isolate::CreateParams create_params;
|
|
|
|
create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
|
|
|
|
isolate_ = reinterpret_cast<Isolate*>(v8::Isolate::New(create_params));
|
|
|
|
isolate_->heap()->AddNearHeapLimitCallback(NearHeapLimitCallback,
|
|
|
|
&oom_triggered_);
|
|
|
|
}
|
|
|
|
|
|
|
|
~SetupIsolateWithSmallHeap() {
|
|
|
|
reinterpret_cast<v8::Isolate*>(isolate_)->Dispose();
|
|
|
|
}
|
|
|
|
|
|
|
|
Isolate* isolate() { return isolate_; }
|
|
|
|
bool oom_triggered() const { return oom_triggered_; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
Isolate* isolate_;
|
|
|
|
bool oom_triggered_ = false;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2019-05-03 13:59:06 +00:00
|
|
|
TEST(Factory_CodeBuilder) {
|
2019-05-13 15:13:08 +00:00
|
|
|
Isolate* isolate = CcTest::i_isolate();
|
|
|
|
HandleScope scope(isolate);
|
2018-12-05 16:12:12 +00:00
|
|
|
|
|
|
|
// Create a big function that ends up in CODE_LO_SPACE.
|
[heap] Make maximum regular code object size a runtime value.
Executable V8 pages include 3 reserved OS pages: one for the writable
header and two as guards. On systems with 64k OS pages, the amount of
allocatable space left for objects can then be quite smaller than the
page size, only 64k for each 256k page.
This means regular code objects cannot be larger than 64k, while the
maximum regular object size is fixed to 128k, half of the page size. As
a result code object never reach this limit and we can end up filling
regular pages with few large code objects.
To fix this, we change the maximum code object size to be runtime value,
set to half of the allocatable space per page. On systems with 64k OS
pages, the limit will be 32k.
Alternatively, we could increase the V8 page size to 512k on Arm64 linux
so we wouldn't waste code space. However, systems with 4k OS pages are
more common, and those with 64k pages tend to have more memory available
so we should be able to live with it.
Bug: v8:10808
Change-Id: I5d807e7a3df89f1e9c648899e9ba2f8e2648264c
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2460809
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Pierre Langlois <pierre.langlois@arm.com>
Cr-Commit-Position: refs/heads/master@{#70569}
2020-10-15 10:21:40 +00:00
|
|
|
const int instruction_size =
|
|
|
|
MemoryChunkLayout::MaxRegularCodeObjectSize() + 1;
|
2018-12-05 16:12:12 +00:00
|
|
|
std::unique_ptr<byte[]> instructions(new byte[instruction_size]);
|
|
|
|
|
|
|
|
CodeDesc desc;
|
|
|
|
desc.buffer = instructions.get();
|
|
|
|
desc.buffer_size = instruction_size;
|
|
|
|
desc.instr_size = instruction_size;
|
|
|
|
desc.reloc_size = 0;
|
|
|
|
desc.constant_pool_size = 0;
|
|
|
|
desc.unwinding_info = nullptr;
|
|
|
|
desc.unwinding_info_size = 0;
|
|
|
|
desc.origin = nullptr;
|
|
|
|
Handle<Code> code =
|
2020-08-05 11:48:03 +00:00
|
|
|
Factory::CodeBuilder(isolate, desc, CodeKind::WASM_FUNCTION).Build();
|
2018-12-05 16:12:12 +00:00
|
|
|
|
2019-05-13 15:13:08 +00:00
|
|
|
CHECK(isolate->heap()->InSpace(*code, CODE_LO_SPACE));
|
2018-12-05 16:12:12 +00:00
|
|
|
#if VERIFY_HEAP
|
2019-05-13 15:13:08 +00:00
|
|
|
code->ObjectVerify(isolate);
|
2018-12-05 16:12:12 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2019-05-13 15:13:08 +00:00
|
|
|
UNINITIALIZED_TEST(Factory_CodeBuilder_BuildOOM) {
|
|
|
|
SetupIsolateWithSmallHeap isolate_scope;
|
|
|
|
HandleScope scope(isolate_scope.isolate());
|
|
|
|
std::unique_ptr<byte[]> instructions(new byte[kInstructionSize]);
|
|
|
|
CodeDesc desc;
|
|
|
|
desc.instr_size = kInstructionSize;
|
|
|
|
desc.buffer = instructions.get();
|
|
|
|
|
2020-08-05 11:48:03 +00:00
|
|
|
const Handle<Code> code = Factory::CodeBuilder(isolate_scope.isolate(), desc,
|
|
|
|
CodeKind::WASM_FUNCTION)
|
|
|
|
.Build();
|
2019-05-13 15:13:08 +00:00
|
|
|
|
|
|
|
CHECK(!code.is_null());
|
|
|
|
CHECK(isolate_scope.oom_triggered());
|
|
|
|
}
|
|
|
|
|
|
|
|
UNINITIALIZED_TEST(Factory_CodeBuilder_TryBuildOOM) {
|
|
|
|
SetupIsolateWithSmallHeap isolate_scope;
|
|
|
|
HandleScope scope(isolate_scope.isolate());
|
|
|
|
std::unique_ptr<byte[]> instructions(new byte[kInstructionSize]);
|
|
|
|
CodeDesc desc;
|
|
|
|
desc.instr_size = kInstructionSize;
|
|
|
|
desc.buffer = instructions.get();
|
|
|
|
|
|
|
|
const MaybeHandle<Code> code =
|
2020-08-05 11:48:03 +00:00
|
|
|
Factory::CodeBuilder(isolate_scope.isolate(), desc,
|
|
|
|
CodeKind::WASM_FUNCTION)
|
2019-05-13 15:13:08 +00:00
|
|
|
.TryBuild();
|
|
|
|
|
|
|
|
CHECK(code.is_null());
|
|
|
|
CHECK(!isolate_scope.oom_triggered());
|
|
|
|
}
|
|
|
|
|
2018-12-05 16:12:12 +00:00
|
|
|
} // namespace test_factory
|
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|