1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright 2019 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 "src/objects/backing-store.h"
#include "src/base/platform/platform.h"
#include "test/unittests/test-utils.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace v8 {
namespace internal {
class BackingStoreTest : public TestWithIsolate {};
TEST_F(BackingStoreTest, GrowWasmMemoryInPlace) {
auto backing_store =
BackingStore::AllocateWasmMemory(isolate(), 1, 2, SharedFlag::kNotShared);
CHECK(backing_store);
EXPECT_TRUE(backing_store->is_wasm_memory());
EXPECT_EQ(1 * wasm::kWasmPageSize, backing_store->byte_length());
EXPECT_EQ(2 * wasm::kWasmPageSize, backing_store->byte_capacity());
bool success = backing_store->GrowWasmMemoryInPlace(isolate(), 1, 2);
EXPECT_TRUE(success);
EXPECT_EQ(2 * wasm::kWasmPageSize, backing_store->byte_length());
}
TEST_F(BackingStoreTest, GrowWasmMemoryInPlace_neg) {
auto backing_store =
BackingStore::AllocateWasmMemory(isolate(), 1, 2, SharedFlag::kNotShared);
CHECK(backing_store);
EXPECT_TRUE(backing_store->is_wasm_memory());
EXPECT_EQ(1 * wasm::kWasmPageSize, backing_store->byte_length());
EXPECT_EQ(2 * wasm::kWasmPageSize, backing_store->byte_capacity());
bool success = backing_store->GrowWasmMemoryInPlace(isolate(), 2, 2);
EXPECT_FALSE(success);
EXPECT_EQ(1 * wasm::kWasmPageSize, backing_store->byte_length());
}
TEST_F(BackingStoreTest, GrowSharedWasmMemoryInPlace) {
auto backing_store =
BackingStore::AllocateWasmMemory(isolate(), 2, 3, SharedFlag::kShared);
CHECK(backing_store);
EXPECT_TRUE(backing_store->is_wasm_memory());
EXPECT_EQ(2 * wasm::kWasmPageSize, backing_store->byte_length());
EXPECT_EQ(3 * wasm::kWasmPageSize, backing_store->byte_capacity());
bool success = backing_store->GrowWasmMemoryInPlace(isolate(), 1, 3);
EXPECT_TRUE(success);
EXPECT_EQ(3 * wasm::kWasmPageSize, backing_store->byte_length());
}
TEST_F(BackingStoreTest, CopyWasmMemory) {
auto bs1 =
BackingStore::AllocateWasmMemory(isolate(), 1, 2, SharedFlag::kNotShared);
CHECK(bs1);
EXPECT_TRUE(bs1->is_wasm_memory());
EXPECT_EQ(1 * wasm::kWasmPageSize, bs1->byte_length());
EXPECT_EQ(2 * wasm::kWasmPageSize, bs1->byte_capacity());
auto bs2 = bs1->CopyWasmMemory(isolate(), 3);
EXPECT_TRUE(bs2->is_wasm_memory());
EXPECT_EQ(3 * wasm::kWasmPageSize, bs2->byte_length());
EXPECT_EQ(3 * wasm::kWasmPageSize, bs2->byte_capacity());
}
class GrowerThread : public base::Thread {
public:
GrowerThread(Isolate* isolate, uint32_t increment, uint32_t max,
std::shared_ptr<BackingStore> backing_store)
: base::Thread(base::Thread::Options("GrowerThread")),
isolate_(isolate),
increment_(increment),
max_(max),
backing_store_(backing_store) {}
void Run() override {
size_t max_length = max_ * wasm::kWasmPageSize;
while (true) {
size_t current_length = backing_store_->byte_length();
if (current_length >= max_length) break;
bool result =
backing_store_->GrowWasmMemoryInPlace(isolate_, increment_, max_);
size_t new_length = backing_store_->byte_length();
if (result) {
CHECK_GE(new_length, current_length + increment_);
} else {
CHECK_EQ(max_length, new_length);
}
}
}
private:
Isolate* isolate_;
uint32_t increment_;
uint32_t max_;
std::shared_ptr<BackingStore> backing_store_;
};
TEST_F(BackingStoreTest, RacyGrowWasmMemoryInPlace) {
constexpr int kNumThreads = 10;
constexpr int kMaxPages = 1024;
GrowerThread* threads[kNumThreads];
std::shared_ptr<BackingStore> backing_store =
BackingStore::AllocateWasmMemory(isolate(), 0, kMaxPages,
SharedFlag::kShared);
for (int i = 0; i < kNumThreads; i++) {
threads[i] = new GrowerThread(isolate(), 1, kMaxPages, backing_store);
CHECK(threads[i]->Start());
}
for (int i = 0; i < kNumThreads; i++) {
threads[i]->Join();
}
EXPECT_EQ(kMaxPages * wasm::kWasmPageSize, backing_store->byte_length());
for (int i = 0; i < kNumThreads; i++) {
delete threads[i];
}
}
} // namespace internal
} // namespace v8
|
