e659917aa3
Introduce OffThreadFactory with initial string construction support.
The OffThreadFactory shares with Factory a new CRTP base class, called
FactoryBase. Methods in FactoryBase return a FactoryHandle<Factory, T>
alias, which is Handle<T> for normal Factory and a new OffThreadHandle<T>
for OffThreadFactory. OffThreadHandle<T> behaves like Handle<T>, except
it stores the object in-line rather than needing external storage.
Any shared factory methods are moved into FactoryBase, which uses CRTP
to call the sub-class's AllocateRaw method (plus a few more customization
points which need Isolate access on the main thread).
Methods that used to take an Isolate or Factory, and are needed off the
main thread, are now expected to be templated on the factory type and
to use the appropriate handle.
Once an OffThreadFactory has finished being used (e.g. off-thread
compilation completed) its pages are "Published" into the main-thread
Heap. To deal with string internalization without creating a bunch of
ThinStrings, this is done in two stages:
1. 'FinishOffThread': The off-thread pages are walked to
collect all slots pointing to "internalized" strings. After this is
called it is invalid to allocate any more objects with the factory.
2. 'Publish': On the main thread, we transform these slots into
<Handle to holder, offset> pairs, then for each saved slot
re-internalize its string and update the slot to point to the
internalized string.
Bug: chromium:1011762
Change-Id: I008a694da3c357de34362bd86fe7e1f46b535d5e
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1992434
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Cr-Commit-Position: refs/heads/master@{#65787}
105 lines
4.0 KiB
C++
105 lines
4.0 KiB
C++
// Copyright 2020 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.
|
|
|
|
#include <cmath>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <memory>
|
|
|
|
#include "src/handles/handles-inl.h"
|
|
#include "src/heap/off-thread-factory.h"
|
|
#include "src/objects/string.h"
|
|
#include "test/unittests/test-utils.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
class OffThreadFactoryTest : public TestWithIsolateAndZone {
|
|
public:
|
|
OffThreadFactoryTest()
|
|
: TestWithIsolateAndZone(), off_thread_factory_(isolate()) {}
|
|
|
|
OffThreadFactory* off_thread_factory() { return &off_thread_factory_; }
|
|
|
|
private:
|
|
OffThreadFactory off_thread_factory_;
|
|
};
|
|
|
|
TEST_F(OffThreadFactoryTest, OneByteInternalizedString_IsAddedToStringTable) {
|
|
Vector<const uint8_t> string_vector = StaticCharVector("foo");
|
|
uint32_t hash_field = StringHasher::HashSequentialString<uint8_t>(
|
|
string_vector.begin(), string_vector.length(), HashSeed(isolate()));
|
|
|
|
OffThreadHandle<String> off_thread_string =
|
|
off_thread_factory()->NewOneByteInternalizedString(string_vector,
|
|
hash_field);
|
|
|
|
// We only internalize strings which are referred to in other slots, so create
|
|
// a wrapper pointing at the off_thread_string.
|
|
// TODO(leszeks): Replace with a different holder (e.g. FixedArray) once
|
|
// OffThreadFactory supports it.
|
|
OffThreadHandle<FixedArray> off_thread_wrapper =
|
|
off_thread_factory()->StringWrapperForTest(off_thread_string);
|
|
|
|
off_thread_factory()->FinishOffThread();
|
|
|
|
Handle<FixedArray> wrapper = handle(*off_thread_wrapper, isolate());
|
|
off_thread_factory()->Publish(isolate());
|
|
|
|
Handle<String> string = handle(String::cast(wrapper->get(0)), isolate());
|
|
|
|
EXPECT_TRUE(string->IsOneByteEqualTo(CStrVector("foo")));
|
|
EXPECT_TRUE(string->IsInternalizedString());
|
|
|
|
Handle<String> same_string = isolate()
|
|
->factory()
|
|
->NewStringFromOneByte(string_vector)
|
|
.ToHandleChecked();
|
|
EXPECT_NE(*string, *same_string);
|
|
EXPECT_FALSE(same_string->IsInternalizedString());
|
|
|
|
Handle<String> internalized_string =
|
|
isolate()->factory()->InternalizeString(same_string);
|
|
EXPECT_EQ(*string, *internalized_string);
|
|
}
|
|
|
|
TEST_F(OffThreadFactoryTest,
|
|
OneByteInternalizedString_DuplicateIsDeduplicated) {
|
|
Vector<const uint8_t> string_vector = StaticCharVector("foo");
|
|
uint32_t hash_field = StringHasher::HashSequentialString<uint8_t>(
|
|
string_vector.begin(), string_vector.length(), HashSeed(isolate()));
|
|
|
|
OffThreadHandle<String> off_thread_string_1 =
|
|
off_thread_factory()->NewOneByteInternalizedString(string_vector,
|
|
hash_field);
|
|
OffThreadHandle<String> off_thread_string_2 =
|
|
off_thread_factory()->NewOneByteInternalizedString(string_vector,
|
|
hash_field);
|
|
|
|
// We only internalize strings which are referred to in other slots, so create
|
|
// a wrapper pointing at the off_thread_string.
|
|
// TODO(leszeks): Replace with a different holder (e.g. FixedArray) once
|
|
// OffThreadFactory supports it.
|
|
OffThreadHandle<FixedArray> off_thread_wrapper_1 =
|
|
off_thread_factory()->StringWrapperForTest(off_thread_string_1);
|
|
OffThreadHandle<FixedArray> off_thread_wrapper_2 =
|
|
off_thread_factory()->StringWrapperForTest(off_thread_string_2);
|
|
|
|
off_thread_factory()->FinishOffThread();
|
|
|
|
Handle<FixedArray> wrapper_1 = handle(*off_thread_wrapper_1, isolate());
|
|
Handle<FixedArray> wrapper_2 = handle(*off_thread_wrapper_2, isolate());
|
|
off_thread_factory()->Publish(isolate());
|
|
|
|
Handle<String> string_1 = handle(String::cast(wrapper_1->get(0)), isolate());
|
|
Handle<String> string_2 = handle(String::cast(wrapper_2->get(0)), isolate());
|
|
|
|
EXPECT_TRUE(string_1->IsOneByteEqualTo(CStrVector("foo")));
|
|
EXPECT_TRUE(string_1->IsInternalizedString());
|
|
EXPECT_EQ(*string_1, *string_2);
|
|
}
|
|
|
|
} // namespace internal
|
|
} // namespace v8
|