deps/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/base/platform/platform.h"
  31 #include "src/snapshot/snapshot.h"
  32 #include "src/v8.h"
  33 #include "test/cctest/cctest.h"
  34
  35
  36 using namespace v8::internal;
  37
  38 #if 0
  39 static void VerifyRegionMarking(Address page_start) {
  40 #ifdef ENABLE_CARDMARKING_WRITE_BARRIER
  41   Page* p = Page::FromAddress(page_start);
  42
  43   p->SetRegionMarks(Page::kAllRegionsCleanMarks);
  44
  45   for (Address addr = p->ObjectAreaStart();
  46        addr < p->ObjectAreaEnd();
  47        addr += kPointerSize) {
  48     CHECK(!Page::FromAddress(addr)->IsRegionDirty(addr));
  49   }
  50
  51   for (Address addr = p->ObjectAreaStart();
  52        addr < p->ObjectAreaEnd();
  53        addr += kPointerSize) {
  54     Page::FromAddress(addr)->MarkRegionDirty(addr);
  55   }
  56
  57   for (Address addr = p->ObjectAreaStart();
  58        addr < p->ObjectAreaEnd();
  59        addr += kPointerSize) {
  60     CHECK(Page::FromAddress(addr)->IsRegionDirty(addr));
  61   }
  62 #endif
  63 }
  64 #endif
  65
  66
  67 // TODO(gc) you can no longer allocate pages like this. Details are hidden.
  68 #if 0
  69 TEST(Page) {
  70   byte* mem = NewArray<byte>(2*Page::kPageSize);
  71   CHECK(mem != NULL);
  72
  73   Address start = reinterpret_cast<Address>(mem);
  74   Address page_start = RoundUp(start, Page::kPageSize);
  75
  76   Page* p = Page::FromAddress(page_start);
  77   // Initialized Page has heap pointer, normally set by memory_allocator.
  78   p->heap_ = CcTest::heap();
  79   CHECK(p->address() == page_start);
  80   CHECK(p->is_valid());
  81
  82   p->opaque_header = 0;
  83   p->SetIsLargeObjectPage(false);
  84   CHECK(!p->next_page()->is_valid());
  85
  86   CHECK(p->ObjectAreaStart() == page_start + Page::kObjectStartOffset);
  87   CHECK(p->ObjectAreaEnd() == page_start + Page::kPageSize);
  88
  89   CHECK(p->Offset(page_start + Page::kObjectStartOffset) ==
  90         Page::kObjectStartOffset);
  91   CHECK(p->Offset(page_start + Page::kPageSize) == Page::kPageSize);
  92
  93   CHECK(p->OffsetToAddress(Page::kObjectStartOffset) == p->ObjectAreaStart());
  94   CHECK(p->OffsetToAddress(Page::kPageSize) == p->ObjectAreaEnd());
  95
  96   // test region marking
  97   VerifyRegionMarking(page_start);
  98
  99   DeleteArray(mem);
 100 }
 101 #endif
 102
 103
 104 namespace v8 {
 105 namespace internal {
 106
 107 // Temporarily sets a given allocator in an isolate.
 108 class TestMemoryAllocatorScope {
 109  public:
 110   TestMemoryAllocatorScope(Isolate* isolate, MemoryAllocator* allocator)
 111       : isolate_(isolate),
 112         old_allocator_(isolate->memory_allocator_) {
 113     isolate->memory_allocator_ = allocator;
 114   }
 115
 116   ~TestMemoryAllocatorScope() {
 117     isolate_->memory_allocator_ = old_allocator_;
 118   }
 119
 120  private:
 121   Isolate* isolate_;
 122   MemoryAllocator* old_allocator_;
 123
 124   DISALLOW_COPY_AND_ASSIGN(TestMemoryAllocatorScope);
 125 };
 126
 127
 128 // Temporarily sets a given code range in an isolate.
 129 class TestCodeRangeScope {
 130  public:
 131   TestCodeRangeScope(Isolate* isolate, CodeRange* code_range)
 132       : isolate_(isolate),
 133         old_code_range_(isolate->code_range_) {
 134     isolate->code_range_ = code_range;
 135   }
 136
 137   ~TestCodeRangeScope() {
 138     isolate_->code_range_ = old_code_range_;
 139   }
 140
 141  private:
 142   Isolate* isolate_;
 143   CodeRange* old_code_range_;
 144
 145   DISALLOW_COPY_AND_ASSIGN(TestCodeRangeScope);
 146 };
 147
 148 } }  // namespace v8::internal
 149
 150
 151 static void VerifyMemoryChunk(Isolate* isolate,
 152                               Heap* heap,
 153                               CodeRange* code_range,
 154                               size_t reserve_area_size,
 155                               size_t commit_area_size,
 156                               size_t second_commit_area_size,
 157                               Executability executable) {
 158   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 159   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 160                                 heap->MaxExecutableSize()));
 161   TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
 162   TestCodeRangeScope test_code_range_scope(isolate, code_range);
 163
 164   size_t header_size = (executable == EXECUTABLE)
 165                        ? MemoryAllocator::CodePageGuardStartOffset()
 166                        : MemoryChunk::kObjectStartOffset;
 167   size_t guard_size = (executable == EXECUTABLE)
 168                        ? MemoryAllocator::CodePageGuardSize()
 169                        : 0;
 170
 171   MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(reserve_area_size,
 172                                                               commit_area_size,
 173                                                               executable,
 174                                                               NULL);
 175   size_t alignment = code_range != NULL && code_range->valid() ?
 176                      MemoryChunk::kAlignment : v8::base::OS::CommitPageSize();
 177   size_t reserved_size =
 178       ((executable == EXECUTABLE))
 179           ? RoundUp(header_size + guard_size + reserve_area_size + guard_size,
 180                     alignment)
 181           : RoundUp(header_size + reserve_area_size,
 182                     v8::base::OS::CommitPageSize());
 183   CHECK(memory_chunk->size() == reserved_size);
 184   CHECK(memory_chunk->area_start() < memory_chunk->address() +
 185                                      memory_chunk->size());
 186   CHECK(memory_chunk->area_end() <= memory_chunk->address() +
 187                                     memory_chunk->size());
 188   CHECK(static_cast<size_t>(memory_chunk->area_size()) == commit_area_size);
 189
 190   Address area_start = memory_chunk->area_start();
 191
 192   memory_chunk->CommitArea(second_commit_area_size);
 193   CHECK(area_start == memory_chunk->area_start());
 194   CHECK(memory_chunk->area_start() < memory_chunk->address() +
 195                                      memory_chunk->size());
 196   CHECK(memory_chunk->area_end() <= memory_chunk->address() +
 197                                     memory_chunk->size());
 198   CHECK(static_cast<size_t>(memory_chunk->area_size()) ==
 199       second_commit_area_size);
 200
 201   memory_allocator->Free(memory_chunk);
 202   memory_allocator->TearDown();
 203   delete memory_allocator;
 204 }
 205
 206
 207 TEST(Regress3540) {
 208   Isolate* isolate = CcTest::i_isolate();
 209   Heap* heap = isolate->heap();
 210   const int pageSize = Page::kPageSize;
 211   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 212   CHECK(
 213       memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize()));
 214   TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
 215   CodeRange* code_range = new CodeRange(isolate);
 216   const size_t code_range_size = 4 * pageSize;
 217   if (!code_range->SetUp(
 218           code_range_size +
 219           RoundUp(v8::base::OS::CommitPageSize() * kReservedCodeRangePages,
 220                   MemoryChunk::kAlignment) +
 221           v8::internal::MemoryAllocator::CodePageAreaSize())) {
 222     return;
 223   }
 224   Address address;
 225   size_t size;
 226   address = code_range->AllocateRawMemory(
 227       code_range_size - 2 * pageSize, code_range_size - 2 * pageSize, &size);
 228   CHECK(address != NULL);
 229   Address null_address;
 230   size_t null_size;
 231   null_address = code_range->AllocateRawMemory(
 232       code_range_size - pageSize, code_range_size - pageSize, &null_size);
 233   CHECK(null_address == NULL);
 234   code_range->FreeRawMemory(address, size);
 235   delete code_range;
 236   memory_allocator->TearDown();
 237   delete memory_allocator;
 238 }
 239
 240
 241 static unsigned int Pseudorandom() {
 242   static uint32_t lo = 2345;
 243   lo = 18273 * (lo & 0xFFFFF) + (lo >> 16);
 244   return lo & 0xFFFFF;
 245 }
 246
 247
 248 TEST(MemoryChunk) {
 249   Isolate* isolate = CcTest::i_isolate();
 250   Heap* heap = isolate->heap();
 251
 252   size_t reserve_area_size = 1 * MB;
 253   size_t initial_commit_area_size, second_commit_area_size;
 254
 255   for (int i = 0; i < 100; i++) {
 256     initial_commit_area_size = Pseudorandom();
 257     second_commit_area_size = Pseudorandom();
 258
 259     // With CodeRange.
 260     CodeRange* code_range = new CodeRange(isolate);
 261     const size_t code_range_size = 32 * MB;
 262     if (!code_range->SetUp(code_range_size)) return;
 263
 264     VerifyMemoryChunk(isolate,
 265                       heap,
 266                       code_range,
 267                       reserve_area_size,
 268                       initial_commit_area_size,
 269                       second_commit_area_size,
 270                       EXECUTABLE);
 271
 272     VerifyMemoryChunk(isolate,
 273                       heap,
 274                       code_range,
 275                       reserve_area_size,
 276                       initial_commit_area_size,
 277                       second_commit_area_size,
 278                       NOT_EXECUTABLE);
 279     delete code_range;
 280
 281     // Without CodeRange.
 282     code_range = NULL;
 283     VerifyMemoryChunk(isolate,
 284                       heap,
 285                       code_range,
 286                       reserve_area_size,
 287                       initial_commit_area_size,
 288                       second_commit_area_size,
 289                       EXECUTABLE);
 290
 291     VerifyMemoryChunk(isolate,
 292                       heap,
 293                       code_range,
 294                       reserve_area_size,
 295                       initial_commit_area_size,
 296                       second_commit_area_size,
 297                       NOT_EXECUTABLE);
 298   }
 299 }
 300
 301
 302 TEST(MemoryAllocator) {
 303   Isolate* isolate = CcTest::i_isolate();
 304   Heap* heap = isolate->heap();
 305
 306   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 307   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 308                                 heap->MaxExecutableSize()));
 309
 310   int total_pages = 0;
 311   OldSpace faked_space(heap, heap->MaxReserved(), OLD_POINTER_SPACE,
 312                        NOT_EXECUTABLE);
 313   Page* first_page = memory_allocator->AllocatePage(
 314       faked_space.AreaSize(), &faked_space, NOT_EXECUTABLE);
 315
 316   first_page->InsertAfter(faked_space.anchor()->prev_page());
 317   CHECK(first_page->is_valid());
 318   CHECK(first_page->next_page() == faked_space.anchor());
 319   total_pages++;
 320
 321   for (Page* p = first_page; p != faked_space.anchor(); p = p->next_page()) {
 322     CHECK(p->owner() == &faked_space);
 323   }
 324
 325   // Again, we should get n or n - 1 pages.
 326   Page* other = memory_allocator->AllocatePage(
 327       faked_space.AreaSize(), &faked_space, NOT_EXECUTABLE);
 328   CHECK(other->is_valid());
 329   total_pages++;
 330   other->InsertAfter(first_page);
 331   int page_count = 0;
 332   for (Page* p = first_page; p != faked_space.anchor(); p = p->next_page()) {
 333     CHECK(p->owner() == &faked_space);
 334     page_count++;
 335   }
 336   CHECK(total_pages == page_count);
 337
 338   Page* second_page = first_page->next_page();
 339   CHECK(second_page->is_valid());
 340   memory_allocator->Free(first_page);
 341   memory_allocator->Free(second_page);
 342   memory_allocator->TearDown();
 343   delete memory_allocator;
 344 }
 345
 346
 347 TEST(NewSpace) {
 348   Isolate* isolate = CcTest::i_isolate();
 349   Heap* heap = isolate->heap();
 350   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 351   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 352                                 heap->MaxExecutableSize()));
 353   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 354
 355   NewSpace new_space(heap);
 356
 357   CHECK(new_space.SetUp(CcTest::heap()->ReservedSemiSpaceSize(),
 358                         CcTest::heap()->ReservedSemiSpaceSize()));
 359   CHECK(new_space.HasBeenSetUp());
 360
 361   while (new_space.Available() >= Page::kMaxRegularHeapObjectSize) {
 362     Object* obj = new_space.AllocateRaw(
 363         Page::kMaxRegularHeapObjectSize).ToObjectChecked();
 364     CHECK(new_space.Contains(HeapObject::cast(obj)));
 365   }
 366
 367   new_space.TearDown();
 368   memory_allocator->TearDown();
 369   delete memory_allocator;
 370 }
 371
 372
 373 TEST(OldSpace) {
 374   Isolate* isolate = CcTest::i_isolate();
 375   Heap* heap = isolate->heap();
 376   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
 377   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
 378                                 heap->MaxExecutableSize()));
 379   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 380
 381   OldSpace* s = new OldSpace(heap, heap->MaxOldGenerationSize(),
 382                              OLD_POINTER_SPACE, NOT_EXECUTABLE);
 383   CHECK(s != NULL);
 384
 385   CHECK(s->SetUp());
 386
 387   while (s->Available() > 0) {
 388     s->AllocateRaw(Page::kMaxRegularHeapObjectSize).ToObjectChecked();
 389   }
 390
 391   s->TearDown();
 392   delete s;
 393   memory_allocator->TearDown();
 394   delete memory_allocator;
 395 }
 396
 397
 398 TEST(LargeObjectSpace) {
 399   v8::V8::Initialize();
 400
 401   LargeObjectSpace* lo = CcTest::heap()->lo_space();
 402   CHECK(lo != NULL);
 403
 404   int lo_size = Page::kPageSize;
 405
 406   Object* obj = lo->AllocateRaw(lo_size, NOT_EXECUTABLE).ToObjectChecked();
 407   CHECK(obj->IsHeapObject());
 408
 409   HeapObject* ho = HeapObject::cast(obj);
 410
 411   CHECK(lo->Contains(HeapObject::cast(obj)));
 412
 413   CHECK(lo->FindObject(ho->address()) == obj);
 414
 415   CHECK(lo->Contains(ho));
 416
 417   while (true) {
 418     intptr_t available = lo->Available();
 419     { AllocationResult allocation = lo->AllocateRaw(lo_size, NOT_EXECUTABLE);
 420       if (allocation.IsRetry()) break;
 421     }
 422     // The available value is conservative such that it may report
 423     // zero prior to heap exhaustion.
 424     CHECK(lo->Available() < available || available == 0);
 425   }
 426
 427   CHECK(!lo->IsEmpty());
 428
 429   CHECK(lo->AllocateRaw(lo_size, NOT_EXECUTABLE).IsRetry());
 430 }
 431
 432
 433 TEST(SizeOfFirstPageIsLargeEnough) {
 434   if (i::FLAG_always_opt) return;
 435   // Bootstrapping without a snapshot causes more allocations.
 436   CcTest::InitializeVM();
 437   Isolate* isolate = CcTest::i_isolate();
 438   if (!isolate->snapshot_available()) return;
 439   if (Snapshot::EmbedsScript(isolate)) return;
 440
 441   // Freshly initialized VM gets by with one page per space.
 442   for (int i = FIRST_PAGED_SPACE; i <= LAST_PAGED_SPACE; i++) {
 443     // Debug code can be very large, so skip CODE_SPACE if we are generating it.
 444     if (i == CODE_SPACE && i::FLAG_debug_code) continue;
 445     CHECK_EQ(1, isolate->heap()->paged_space(i)->CountTotalPages());
 446   }
 447
 448   // Executing the empty script gets by with one page per space.
 449   HandleScope scope(isolate);
 450   CompileRun("/*empty*/");
 451   for (int i = FIRST_PAGED_SPACE; i <= LAST_PAGED_SPACE; i++) {
 452     // Debug code can be very large, so skip CODE_SPACE if we are generating it.
 453     if (i == CODE_SPACE && i::FLAG_debug_code) continue;
 454     CHECK_EQ(1, isolate->heap()->paged_space(i)->CountTotalPages());
 455   }
 456
 457   // No large objects required to perform the above steps.
 458   CHECK(isolate->heap()->lo_space()->IsEmpty());
 459 }
 460
 461
 462 UNINITIALIZED_TEST(NewSpaceGrowsToTargetCapacity) {
 463   FLAG_target_semi_space_size = 2 * (Page::kPageSize / MB);
 464   if (FLAG_optimize_for_size) return;
 465
 466   v8::Isolate* isolate = v8::Isolate::New();
 467   {
 468     v8::Isolate::Scope isolate_scope(isolate);
 469     v8::HandleScope handle_scope(isolate);
 470     v8::Context::New(isolate)->Enter();
 471
 472     Isolate* i_isolate = reinterpret_cast<Isolate*>(isolate);
 473
 474     NewSpace* new_space = i_isolate->heap()->new_space();
 475
 476     // This test doesn't work if we start with a non-default new space
 477     // configuration.
 478     if (new_space->InitialTotalCapacity() == Page::kPageSize) {
 479       CHECK(new_space->CommittedMemory() == new_space->InitialTotalCapacity());
 480
 481       // Fill up the first (and only) page of the semi space.
 482       FillCurrentPage(new_space);
 483
 484       // Try to allocate out of the new space. A new page should be added and
 485       // the
 486       // allocation should succeed.
 487       v8::internal::AllocationResult allocation = new_space->AllocateRaw(80);
 488       CHECK(!allocation.IsRetry());
 489       CHECK(new_space->CommittedMemory() == 2 * Page::kPageSize);
 490
 491       // Turn the allocation into a proper object so isolate teardown won't
 492       // crash.
 493       HeapObject* free_space = NULL;
 494       CHECK(allocation.To(&free_space));
 495       new_space->heap()->CreateFillerObjectAt(free_space->address(), 80);
 496     }
 497   }
 498   isolate->Dispose();
 499 }