OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "src/v8.h" |
| 6 |
| 7 #include "src/factory.h" |
| 8 #include "src/handles-inl.h" |
| 9 #include "src/interpreter/constant-array-builder.h" |
| 10 #include "src/isolate.h" |
| 11 #include "test/unittests/test-utils.h" |
| 12 |
| 13 namespace v8 { |
| 14 namespace internal { |
| 15 namespace interpreter { |
| 16 |
| 17 class ConstantArrayBuilderTest : public TestWithIsolateAndZone { |
| 18 public: |
| 19 ConstantArrayBuilderTest() {} |
| 20 ~ConstantArrayBuilderTest() override {} |
| 21 |
| 22 static const size_t kLowCapacity = ConstantArrayBuilder::kLowCapacity; |
| 23 static const size_t kMaxCapacity = ConstantArrayBuilder::kMaxCapacity; |
| 24 }; |
| 25 |
| 26 |
| 27 STATIC_CONST_MEMBER_DEFINITION const size_t |
| 28 ConstantArrayBuilderTest::kMaxCapacity; |
| 29 STATIC_CONST_MEMBER_DEFINITION const size_t |
| 30 ConstantArrayBuilderTest::kLowCapacity; |
| 31 |
| 32 |
| 33 TEST_F(ConstantArrayBuilderTest, AllocateAllEntries) { |
| 34 ConstantArrayBuilder builder(isolate(), zone()); |
| 35 for (size_t i = 0; i < kMaxCapacity; i++) { |
| 36 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 37 builder.Insert(object); |
| 38 CHECK_EQ(builder.size(), i + 1); |
| 39 CHECK(builder.At(i)->SameValue(*object)); |
| 40 } |
| 41 for (size_t i = 0; i < kMaxCapacity; i++) { |
| 42 CHECK_EQ(Handle<Smi>::cast(builder.At(i))->value(), static_cast<double>(i)); |
| 43 } |
| 44 } |
| 45 |
| 46 |
| 47 TEST_F(ConstantArrayBuilderTest, AllocateEntriesWithIdx8Reservations) { |
| 48 for (size_t reserved = 1; reserved < kLowCapacity; reserved *= 3) { |
| 49 ConstantArrayBuilder builder(isolate(), zone()); |
| 50 for (size_t i = 0; i < reserved; i++) { |
| 51 OperandSize operand_size = builder.CreateReservedEntry(); |
| 52 CHECK(operand_size == OperandSize::kByte); |
| 53 } |
| 54 for (size_t i = 0; i < 2 * kLowCapacity; i++) { |
| 55 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 56 builder.Insert(object); |
| 57 if (i + reserved < kLowCapacity) { |
| 58 CHECK_LE(builder.size(), kLowCapacity); |
| 59 CHECK_EQ(builder.size(), i + 1); |
| 60 CHECK(builder.At(i)->SameValue(*object)); |
| 61 } else { |
| 62 CHECK_GE(builder.size(), kLowCapacity); |
| 63 CHECK_EQ(builder.size(), i + reserved + 1); |
| 64 CHECK(builder.At(i + reserved)->SameValue(*object)); |
| 65 } |
| 66 } |
| 67 CHECK_EQ(builder.size(), 2 * kLowCapacity + reserved); |
| 68 |
| 69 // Check reserved values represented by the hole. |
| 70 for (size_t i = 0; i < reserved; i++) { |
| 71 Handle<Object> empty = builder.At(kLowCapacity - reserved + i); |
| 72 CHECK(empty->SameValue(isolate()->heap()->the_hole_value())); |
| 73 } |
| 74 |
| 75 // Commmit reserved entries with duplicates and check size does not change. |
| 76 DCHECK_EQ(reserved + 2 * kLowCapacity, builder.size()); |
| 77 size_t duplicates_in_idx8_space = |
| 78 std::min(reserved, kLowCapacity - reserved); |
| 79 for (size_t i = 0; i < duplicates_in_idx8_space; i++) { |
| 80 builder.CommitReservedEntry(OperandSize::kByte, |
| 81 isolate()->factory()->NewNumberFromSize(i)); |
| 82 DCHECK_EQ(reserved + 2 * kLowCapacity, builder.size()); |
| 83 } |
| 84 |
| 85 // Check all committed values match expected (holes where |
| 86 // duplicates_in_idx8_space allocated). |
| 87 for (size_t i = 0; i < kLowCapacity - reserved; i++) { |
| 88 Smi* smi = Smi::FromInt(static_cast<int>(i)); |
| 89 CHECK(Handle<Smi>::cast(builder.At(i))->SameValue(smi)); |
| 90 } |
| 91 for (size_t i = kLowCapacity; i < 2 * kLowCapacity + reserved; i++) { |
| 92 Smi* smi = Smi::FromInt(static_cast<int>(i - reserved)); |
| 93 CHECK(Handle<Smi>::cast(builder.At(i))->SameValue(smi)); |
| 94 } |
| 95 for (size_t i = 0; i < reserved; i++) { |
| 96 size_t index = kLowCapacity - reserved + i; |
| 97 CHECK(builder.At(index)->IsTheHole()); |
| 98 } |
| 99 |
| 100 // Now make reservations, and commit them with unique entries. |
| 101 for (size_t i = 0; i < duplicates_in_idx8_space; i++) { |
| 102 OperandSize operand_size = builder.CreateReservedEntry(); |
| 103 CHECK(operand_size == OperandSize::kByte); |
| 104 } |
| 105 for (size_t i = 0; i < duplicates_in_idx8_space; i++) { |
| 106 Handle<Object> object = |
| 107 isolate()->factory()->NewNumberFromSize(2 * kLowCapacity + i); |
| 108 size_t index = builder.CommitReservedEntry(OperandSize::kByte, object); |
| 109 CHECK_EQ(static_cast<int>(index), kLowCapacity - reserved + i); |
| 110 CHECK(builder.At(static_cast<int>(index))->SameValue(*object)); |
| 111 } |
| 112 CHECK_EQ(builder.size(), 2 * kLowCapacity + reserved); |
| 113 } |
| 114 } |
| 115 |
| 116 |
| 117 TEST_F(ConstantArrayBuilderTest, AllocateEntriesWithIdx16Reservations) { |
| 118 for (size_t reserved = 1; reserved < kLowCapacity; reserved *= 3) { |
| 119 ConstantArrayBuilder builder(isolate(), zone()); |
| 120 for (size_t i = 0; i < kLowCapacity; i++) { |
| 121 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 122 builder.Insert(object); |
| 123 CHECK(builder.At(i)->SameValue(*object)); |
| 124 CHECK_EQ(builder.size(), i + 1); |
| 125 } |
| 126 for (size_t i = 0; i < reserved; i++) { |
| 127 OperandSize operand_size = builder.CreateReservedEntry(); |
| 128 CHECK(operand_size == OperandSize::kShort); |
| 129 CHECK_EQ(builder.size(), kLowCapacity); |
| 130 } |
| 131 for (size_t i = 0; i < reserved; i++) { |
| 132 builder.DiscardReservedEntry(OperandSize::kShort); |
| 133 CHECK_EQ(builder.size(), kLowCapacity); |
| 134 } |
| 135 for (size_t i = 0; i < reserved; i++) { |
| 136 OperandSize operand_size = builder.CreateReservedEntry(); |
| 137 CHECK(operand_size == OperandSize::kShort); |
| 138 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 139 builder.CommitReservedEntry(operand_size, object); |
| 140 CHECK_EQ(builder.size(), kLowCapacity); |
| 141 } |
| 142 for (size_t i = kLowCapacity; i < kLowCapacity + reserved; i++) { |
| 143 OperandSize operand_size = builder.CreateReservedEntry(); |
| 144 CHECK(operand_size == OperandSize::kShort); |
| 145 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 146 builder.CommitReservedEntry(operand_size, object); |
| 147 CHECK_EQ(builder.size(), i + 1); |
| 148 } |
| 149 } |
| 150 } |
| 151 |
| 152 |
| 153 TEST_F(ConstantArrayBuilderTest, ToFixedArray) { |
| 154 ConstantArrayBuilder builder(isolate(), zone()); |
| 155 static const size_t kNumberOfElements = 37; |
| 156 for (size_t i = 0; i < kNumberOfElements; i++) { |
| 157 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 158 builder.Insert(object); |
| 159 CHECK(builder.At(i)->SameValue(*object)); |
| 160 } |
| 161 Handle<FixedArray> constant_array = |
| 162 builder.ToFixedArray(isolate()->factory()); |
| 163 CHECK_EQ(constant_array->length(), kNumberOfElements); |
| 164 for (size_t i = 0; i < kNumberOfElements; i++) { |
| 165 CHECK(constant_array->get(static_cast<int>(i))->SameValue(*builder.At(i))); |
| 166 } |
| 167 } |
| 168 |
| 169 |
| 170 TEST_F(ConstantArrayBuilderTest, GapFilledWhenLowReservationCommitted) { |
| 171 ConstantArrayBuilder builder(isolate(), zone()); |
| 172 for (size_t i = 0; i < kLowCapacity; i++) { |
| 173 OperandSize operand_size = builder.CreateReservedEntry(); |
| 174 CHECK(OperandSize::kByte == operand_size); |
| 175 CHECK_EQ(builder.size(), 0); |
| 176 } |
| 177 for (size_t i = 0; i < kLowCapacity; i++) { |
| 178 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 179 builder.Insert(object); |
| 180 CHECK_EQ(builder.size(), i + kLowCapacity + 1); |
| 181 } |
| 182 for (size_t i = 0; i < kLowCapacity; i++) { |
| 183 builder.CommitReservedEntry(OperandSize::kByte, |
| 184 builder.At(i + kLowCapacity)); |
| 185 CHECK_EQ(builder.size(), 2 * kLowCapacity); |
| 186 } |
| 187 for (size_t i = 0; i < kLowCapacity; i++) { |
| 188 Handle<Object> original = builder.At(kLowCapacity + i); |
| 189 Handle<Object> duplicate = builder.At(i); |
| 190 CHECK(original->SameValue(*duplicate)); |
| 191 Handle<Object> reference = isolate()->factory()->NewNumberFromSize(i); |
| 192 CHECK(original->SameValue(*reference)); |
| 193 } |
| 194 } |
| 195 |
| 196 |
| 197 TEST_F(ConstantArrayBuilderTest, GapNotFilledWhenLowReservationDiscarded) { |
| 198 ConstantArrayBuilder builder(isolate(), zone()); |
| 199 for (size_t i = 0; i < kLowCapacity; i++) { |
| 200 OperandSize operand_size = builder.CreateReservedEntry(); |
| 201 CHECK(OperandSize::kByte == operand_size); |
| 202 CHECK_EQ(builder.size(), 0); |
| 203 } |
| 204 for (size_t i = 0; i < kLowCapacity; i++) { |
| 205 Handle<Object> object = isolate()->factory()->NewNumberFromSize(i); |
| 206 builder.Insert(object); |
| 207 CHECK_EQ(builder.size(), i + kLowCapacity + 1); |
| 208 } |
| 209 for (size_t i = 0; i < kLowCapacity; i++) { |
| 210 builder.DiscardReservedEntry(OperandSize::kByte); |
| 211 builder.Insert(builder.At(i + kLowCapacity)); |
| 212 CHECK_EQ(builder.size(), 2 * kLowCapacity); |
| 213 } |
| 214 for (size_t i = 0; i < kLowCapacity; i++) { |
| 215 Handle<Object> reference = isolate()->factory()->NewNumberFromSize(i); |
| 216 Handle<Object> original = builder.At(kLowCapacity + i); |
| 217 CHECK(original->SameValue(*reference)); |
| 218 Handle<Object> duplicate = builder.At(i); |
| 219 CHECK(duplicate->SameValue(*isolate()->factory()->the_hole_value())); |
| 220 } |
| 221 } |
| 222 |
| 223 } // namespace interpreter |
| 224 } // namespace internal |
| 225 } // namespace v8 |
OLD | NEW |