src/v8/test/cctest/test-spaces.cc

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include <stdlib.h>
  29
  30 #include "src/snapshot.h"
  31 #include "src/v8.h"
  32 #include "test/cctest/cctest.h"
  33
  34
  35 using namespace v8::internal;
  36
  37 #if 0
  38 static void VerifyRegionMarking(Address page_start) {
  39 #ifdef ENABLE_CARDMARKING_WRITE_BARRIER
  40   Page* p = Page::FromAddress(page_start);
  41
  42   p->SetRegionMarks(Page::kAllRegionsCleanMarks);
  43
  44   for (Address addr = p->ObjectAreaStart();
  45        addr < p->ObjectAreaEnd();
  46        addr += kPointerSize) {
  47     CHECK(!Page::FromAddress(addr)->IsRegionDirty(addr));
  48   }
  49
  50   for (Address addr = p->ObjectAreaStart();
  51        addr < p->ObjectAreaEnd();
  52        addr += kPointerSize) {
  53     Page::FromAddress(addr)->MarkRegionDirty(addr);
  54   }
  55
  56   for (Address addr = p->ObjectAreaStart();
  57        addr < p->ObjectAreaEnd();
  58        addr += kPointerSize) {
  59     CHECK(Page::FromAddress(addr)->IsRegionDirty(addr));
  60   }
  61 #endif
  62 }
  63 #endif
  64
  65
  66 // TODO(gc) you can no longer allocate pages like this. Details are hidden.
  67 #if 0
  68 TEST(Page) {
  69   byte* mem = NewArray<byte>(2*Page::kPageSize);
  70   CHECK(mem != NULL);
  71
  72   Address start = reinterpret_cast<Address>(mem);
  73   Address page_start = RoundUp(start, Page::kPageSize);
  74
  75   Page* p = Page::FromAddress(page_start);
  76   // Initialized Page has heap pointer, normally set by memory_allocator.
  77   p->heap_ = CcTest::heap();
  78   CHECK(p->address() == page_start);
  79   CHECK(p->is_valid());
  80
  81   p->opaque_header = 0;
  82   p->SetIsLargeObjectPage(false);
  83   CHECK(!p->next_page()->is_valid());
  84
  85   CHECK(p->ObjectAreaStart() == page_start + Page::kObjectStartOffset);
  86   CHECK(p->ObjectAreaEnd() == page_start + Page::kPageSize);
  87
  88   CHECK(p->Offset(page_start + Page::kObjectStartOffset) ==
  89         Page::kObjectStartOffset);
  90   CHECK(p->Offset(page_start + Page::kPageSize) == Page::kPageSize);
  91
  92   CHECK(p->OffsetToAddress(Page::kObjectStartOffset) == p->ObjectAreaStart());
  93   CHECK(p->OffsetToAddress(Page::kPageSize) == p->ObjectAreaEnd());
  94
  95   // test region marking
  96   VerifyRegionMarking(page_start);
  97
  98   DeleteArray(mem);
  99 }
 100 #endif
 101
 102
 103 namespace v8 {
 104 namespace internal {
 105
 106 // Temporarily sets a given allocator in an isolate.
 107 class TestMemoryAllocatorScope {
 108  public:
 109   TestMemoryAllocatorScope(Isolate* isolate, MemoryAllocator* allocator)
 110       : isolate_(isolate),
 111         old_allocator_(isolate->memory_allocator_) {
 112     isolate->memory_allocator_ = allocator;
 113   }
 114
 115   ~TestMemoryAllocatorScope() {
 116     isolate_->memory_allocator_ = old_allocator_;
 117   }
 118
 119  private:
 120   Isolate* isolate_;
 121   MemoryAllocator* old_allocator_;
 122
 123   DISALLOW_COPY_AND_ASSIGN(TestMemoryAllocatorScope);
 124 };
 125
 126
 127 // Temporarily sets a given code range in an isolate.
 128 class TestCodeRangeScope {
 129  public:
 130   TestCodeRangeScope(Isolate* isolate, CodeRange* code_range)
 131       : isolate_(isolate),
 132         old_code_range_(isolate->code_range_) {
 133     isolate->code_range_ = code_range;
 134   }
 135
 136   ~TestCodeRangeScope() {
 137     isolate_->code_range_ = old_code_range_;
 138   }
 139
 140  private:
 141   Isolate* isolate_;
 142   CodeRange* old_code_range_;
 143
 144   DISALLOW_COPY_AND_ASSIGN(TestCodeRangeScope);
 145 };
 146
 147 } }  // namespace v8::internal
 148
 149
 150 static void VerifyMemoryChunk(Isolate* isolate,
 151                               Heap* heap,
 152                               CodeRange* code_range,
 153                               size_t reserve_area_size,
 154                               size_t commit_area_size,
 155                               size_t second_commit_area_size,
 156                               Executability executable) {
 157   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 158   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 159                                 heap->MaxExecutableSize()));
 160   TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
 161   TestCodeRangeScope test_code_range_scope(isolate, code_range);
 162
 163   size_t header_size = (executable == EXECUTABLE)
 164                        ? MemoryAllocator::CodePageGuardStartOffset()
 165                        : MemoryChunk::kObjectStartOffset;
 166   size_t guard_size = (executable == EXECUTABLE)
 167                        ? MemoryAllocator::CodePageGuardSize()
 168                        : 0;
 169
 170   MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(reserve_area_size,
 171                                                               commit_area_size,
 172                                                               executable,
 173                                                               NULL);
 174   size_t alignment = code_range != NULL && code_range->valid() ?
 175                      MemoryChunk::kAlignment : v8::base::OS::CommitPageSize();
 176   size_t reserved_size =
 177       ((executable == EXECUTABLE))
 178           ? RoundUp(header_size + guard_size + reserve_area_size + guard_size,
 179                     alignment)
 180           : RoundUp(header_size + reserve_area_size,
 181                     v8::base::OS::CommitPageSize());
 182   CHECK(memory_chunk->size() == reserved_size);
 183   CHECK(memory_chunk->area_start() < memory_chunk->address() +
 184                                      memory_chunk->size());
 185   CHECK(memory_chunk->area_end() <= memory_chunk->address() +
 186                                     memory_chunk->size());
 187   CHECK(static_cast<size_t>(memory_chunk->area_size()) == commit_area_size);
 188
 189   Address area_start = memory_chunk->area_start();
 190
 191   memory_chunk->CommitArea(second_commit_area_size);
 192   CHECK(area_start == memory_chunk->area_start());
 193   CHECK(memory_chunk->area_start() < memory_chunk->address() +
 194                                      memory_chunk->size());
 195   CHECK(memory_chunk->area_end() <= memory_chunk->address() +
 196                                     memory_chunk->size());
 197   CHECK(static_cast<size_t>(memory_chunk->area_size()) ==
 198       second_commit_area_size);
 199
 200   memory_allocator->Free(memory_chunk);
 201   memory_allocator->TearDown();
 202   delete memory_allocator;
 203 }
 204
 205
 206 TEST(Regress3540) {
 207   Isolate* isolate = CcTest::i_isolate();
 208   Heap* heap = isolate->heap();
 209   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 210   CHECK(
 211       memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize()));
 212   TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
 213   CodeRange* code_range = new CodeRange(isolate);
 214   const size_t code_range_size = 4 * MB;
 215   if (!code_range->SetUp(code_range_size)) return;
 216   Address address;
 217   size_t size;
 218   address = code_range->AllocateRawMemory(code_range_size - MB,
 219                                           code_range_size - MB, &size);
 220   CHECK(address != NULL);
 221   Address null_address;
 222   size_t null_size;
 223   null_address = code_range->AllocateRawMemory(
 224       code_range_size - MB, code_range_size - MB, &null_size);
 225   CHECK(null_address == NULL);
 226   code_range->FreeRawMemory(address, size);
 227   delete code_range;
 228   memory_allocator->TearDown();
 229   delete memory_allocator;
 230 }
 231
 232
 233 static unsigned int Pseudorandom() {
 234   static uint32_t lo = 2345;
 235   lo = 18273 * (lo & 0xFFFFF) + (lo >> 16);
 236   return lo & 0xFFFFF;
 237 }
 238
 239
 240 TEST(MemoryChunk) {
 241   Isolate* isolate = CcTest::i_isolate();
 242   Heap* heap = isolate->heap();
 243
 244   size_t reserve_area_size = 1 * MB;
 245   size_t initial_commit_area_size, second_commit_area_size;
 246
 247   for (int i = 0; i < 100; i++) {
 248     initial_commit_area_size = Pseudorandom();
 249     second_commit_area_size = Pseudorandom();
 250
 251     // With CodeRange.
 252     CodeRange* code_range = new CodeRange(isolate);
 253     const size_t code_range_size = 32 * MB;
 254     if (!code_range->SetUp(code_range_size)) return;
 255
 256     VerifyMemoryChunk(isolate,
 257                       heap,
 258                       code_range,
 259                       reserve_area_size,
 260                       initial_commit_area_size,
 261                       second_commit_area_size,
 262                       EXECUTABLE);
 263
 264     VerifyMemoryChunk(isolate,
 265                       heap,
 266                       code_range,
 267                       reserve_area_size,
 268                       initial_commit_area_size,
 269                       second_commit_area_size,
 270                       NOT_EXECUTABLE);
 271     delete code_range;
 272
 273     // Without CodeRange.
 274     code_range = NULL;
 275     VerifyMemoryChunk(isolate,
 276                       heap,
 277                       code_range,
 278                       reserve_area_size,
 279                       initial_commit_area_size,
 280                       second_commit_area_size,
 281                       EXECUTABLE);
 282
 283     VerifyMemoryChunk(isolate,
 284                       heap,
 285                       code_range,
 286                       reserve_area_size,
 287                       initial_commit_area_size,
 288                       second_commit_area_size,
 289                       NOT_EXECUTABLE);
 290   }
 291 }
 292
 293
 294 TEST(MemoryAllocator) {
 295   Isolate* isolate = CcTest::i_isolate();
 296   Heap* heap = isolate->heap();
 297
 298   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 299   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 300                                 heap->MaxExecutableSize()));
 301
 302   int total_pages = 0;
 303   OldSpace faked_space(heap,
 304                        heap->MaxReserved(),
 305                        OLD_POINTER_SPACE,
 306                        NOT_EXECUTABLE);
 307   Page* first_page = memory_allocator->AllocatePage(
 308       faked_space.AreaSize(), &faked_space, NOT_EXECUTABLE);
 309
 310   first_page->InsertAfter(faked_space.anchor()->prev_page());
 311   CHECK(first_page->is_valid());
 312   CHECK(first_page->next_page() == faked_space.anchor());
 313   total_pages++;
 314
 315   for (Page* p = first_page; p != faked_space.anchor(); p = p->next_page()) {
 316     CHECK(p->owner() == &faked_space);
 317   }
 318
 319   // Again, we should get n or n - 1 pages.
 320   Page* other = memory_allocator->AllocatePage(
 321       faked_space.AreaSize(), &faked_space, NOT_EXECUTABLE);
 322   CHECK(other->is_valid());
 323   total_pages++;
 324   other->InsertAfter(first_page);
 325   int page_count = 0;
 326   for (Page* p = first_page; p != faked_space.anchor(); p = p->next_page()) {
 327     CHECK(p->owner() == &faked_space);
 328     page_count++;
 329   }
 330   CHECK(total_pages == page_count);
 331
 332   Page* second_page = first_page->next_page();
 333   CHECK(second_page->is_valid());
 334   memory_allocator->Free(first_page);
 335   memory_allocator->Free(second_page);
 336   memory_allocator->TearDown();
 337   delete memory_allocator;
 338 }
 339
 340
 341 TEST(NewSpace) {
 342   Isolate* isolate = CcTest::i_isolate();
 343   Heap* heap = isolate->heap();
 344   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 345   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 346                                 heap->MaxExecutableSize()));
 347   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 348
 349   NewSpace new_space(heap);
 350
 351   CHECK(new_space.SetUp(CcTest::heap()->ReservedSemiSpaceSize(),
 352                         CcTest::heap()->ReservedSemiSpaceSize()));
 353   CHECK(new_space.HasBeenSetUp());
 354
 355   while (new_space.Available() >= Page::kMaxRegularHeapObjectSize) {
 356     Object* obj = new_space.AllocateRaw(
 357         Page::kMaxRegularHeapObjectSize).ToObjectChecked();
 358     CHECK(new_space.Contains(HeapObject::cast(obj)));
 359   }
 360
 361   new_space.TearDown();
 362   memory_allocator->TearDown();
 363   delete memory_allocator;
 364 }
 365
 366
 367 TEST(OldSpace) {
 368   Isolate* isolate = CcTest::i_isolate();
 369   Heap* heap = isolate->heap();
 370   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 371   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 372                                 heap->MaxExecutableSize()));
 373   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 374
 375   OldSpace* s = new OldSpace(heap,
 376                              heap->MaxOldGenerationSize(),
 377                              OLD_POINTER_SPACE,
 378                              NOT_EXECUTABLE);
 379   CHECK(s != NULL);
 380
 381   CHECK(s->SetUp());
 382
 383   while (s->Available() > 0) {
 384     s->AllocateRaw(Page::kMaxRegularHeapObjectSize).ToObjectChecked();
 385   }
 386
 387   s->TearDown();
 388   delete s;
 389   memory_allocator->TearDown();
 390   delete memory_allocator;
 391 }
 392
 393
 394 TEST(LargeObjectSpace) {
 395   v8::V8::Initialize();
 396
 397   LargeObjectSpace* lo = CcTest::heap()->lo_space();
 398   CHECK(lo != NULL);
 399
 400   int lo_size = Page::kPageSize;
 401
 402   Object* obj = lo->AllocateRaw(lo_size, NOT_EXECUTABLE).ToObjectChecked();
 403   CHECK(obj->IsHeapObject());
 404
 405   HeapObject* ho = HeapObject::cast(obj);
 406
 407   CHECK(lo->Contains(HeapObject::cast(obj)));
 408
 409   CHECK(lo->FindObject(ho->address()) == obj);
 410
 411   CHECK(lo->Contains(ho));
 412
 413   while (true) {
 414     intptr_t available = lo->Available();
 415     { AllocationResult allocation = lo->AllocateRaw(lo_size, NOT_EXECUTABLE);
 416       if (allocation.IsRetry()) break;
 417     }
 418     CHECK(lo->Available() < available);
 419   }
 420
 421   CHECK(!lo->IsEmpty());
 422
 423   CHECK(lo->AllocateRaw(lo_size, NOT_EXECUTABLE).IsRetry());
 424 }
 425
 426
 427 TEST(SizeOfFirstPageIsLargeEnough) {
 428   if (i::FLAG_always_opt) return;
 429   // Bootstrapping without a snapshot causes more allocations.
 430   if (!i::Snapshot::HaveASnapshotToStartFrom()) return;
 431   CcTest::InitializeVM();
 432   Isolate* isolate = CcTest::i_isolate();
 433
 434   // Freshly initialized VM gets by with one page per space.
 435   for (int i = FIRST_PAGED_SPACE; i <= LAST_PAGED_SPACE; i++) {
 436     // Debug code can be very large, so skip CODE_SPACE if we are generating it.
 437     if (i == CODE_SPACE && i::FLAG_debug_code) continue;
 438     CHECK_EQ(1, isolate->heap()->paged_space(i)->CountTotalPages());
 439   }
 440
 441   // Executing the empty script gets by with one page per space.
 442   HandleScope scope(isolate);
 443   CompileRun("/*empty*/");
 444   for (int i = FIRST_PAGED_SPACE; i <= LAST_PAGED_SPACE; i++) {
 445     // Debug code can be very large, so skip CODE_SPACE if we are generating it.
 446     if (i == CODE_SPACE && i::FLAG_debug_code) continue;
 447     CHECK_EQ(1, isolate->heap()->paged_space(i)->CountTotalPages());
 448   }
 449
 450   // No large objects required to perform the above steps.
 451   CHECK(isolate->heap()->lo_space()->IsEmpty());
 452 }