Lines Matching defs:space
88 #include "src/objects/free-space-inl.h"
132 // Code objects are never in new space and thus don't require generational
241 // Compute the semi space size and cap it.
349 for (PagedSpace* space = spaces.Next(); space != nullptr;
350 space = spaces.Next()) {
351 total += space->Capacity();
361 for (PagedSpace* space = spaces.Next(); space != nullptr;
362 space = spaces.Next()) {
363 total += space->CommittedMemory();
446 // Over-estimate the new space size using capacity to allow some slack.
452 // We will always have an old space when the heap is set up.
456 GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space,
459 if (space != NEW_SPACE && space != NEW_LO_SPACE) {
461 *reason = "GC in old space requested";
466 *reason = "GC in old space forced by flags";
514 "Read-only space, used: %6zu KB"
520 "New space, used: %6zu KB"
526 "New large object space, used: %6zu KB"
533 "Old space, used: %6zu KB"
539 "Code space, used: %6zu KB"
546 "Map space, used: %6zu KB"
553 "Large object space, used: %6zu KB"
559 "Code large object space, used: %6zu KB"
639 "%d pages. Free space: %.1f MB (waste: %.2f). "
1035 // There may be an allocation memento behind objects in new space. Upon
1036 // evacuation of a non-full new space (or if we are on the last page) there
1133 Space* space = it.Next();
1134 if (space == new_space()) {
1135 space->AddAllocationObserver(new_space_observer);
1137 space->AddAllocationObserver(observer);
1147 Space* space = it.Next();
1148 if (space == new_space()) {
1149 space->RemoveAllocationObserver(new_space_observer);
1151 space->RemoveAllocationObserver(observer);
1160 for (PagedSpace* space = spaces.Next(); space != nullptr;
1161 space = spaces.Next()) {
1162 space->MoveOriginalTopForward();
1178 // We just transition into tenure state when the semi-space was at
1288 // in old space.
1391 #define UPDATE_COUNTERS_FOR_SPACE(space) \
1392 isolate_->counters()->space##_bytes_available()->Set( \
1393 static_cast<int>(space()->Available())); \
1394 isolate_->counters()->space##_bytes_committed()->Set( \
1395 static_cast<int>(space()->CommittedMemory())); \
1396 isolate_->counters()->space##_bytes_used()->Set( \
1397 static_cast<int>(space()->SizeOfObjects()));
1398 #define UPDATE_FRAGMENTATION_FOR_SPACE(space) \
1399 if (space()->CommittedMemory() > 0) { \
1400 isolate_->counters()->external_fragmentation_##space()->AddSample( \
1401 static_cast<int>(100 - (space()->SizeOfObjects() * 100.0) / \
1402 space()->CommittedMemory())); \
1404 #define UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(space) \
1405 UPDATE_COUNTERS_FOR_SPACE(space) \
1406 UPDATE_FRAGMENTATION_FOR_SPACE(space)
1427 Space* space = it.Next();
1429 for (MemoryChunk* chunk = space->first_page(); chunk != space->last_page();
1550 // Since we are ignoring the return value, the exact choice of space does
1619 // Since we are ignoring the return value, the exact choice of space does
1658 for (PagedSpace* space = spaces.Next(); space != nullptr;
1659 space = spaces.Next()) {
1660 PagedSpaceObjectIterator it(this, space);
1761 bool Heap::CollectGarbage(AllocationSpace space,
1790 GarbageCollector collector = SelectGarbageCollector(space, &collector_reason);
2169 // Committing memory to from space failed.
2171 FatalProcessOutOfMemory("Committing semi space failed.");
2324 // Objects that died in the new space might have been accounted
2685 // Grow the size of new space if there is room to grow, and enough data
2721 // Reset new space.
2795 // Flip the semispaces. After flipping, to space is empty, from space has
2800 // We also flip the young generation large object space. All large objects
2801 // will be in the from space.
2990 // String is still in new space. Update the table entry.
3351 BaseSpace* space = chunk->owner();
3352 space->heap()->VerifySlotRangeHasNoRecordedSlots(start, end);
3379 // with {addr} pointing into large object space; however we currently
3468 // New space object do not have recorded slots.
3517 // space or old space. In a large object space the object's start must
3546 // Technically in new space this write might be omitted (except for
3627 // For now this trick is only applied to objects in new and paged space.
3651 // Technically in new space this write might be omitted (except for
3654 // We do not create a filler for objects in a large object space.
3677 // using release store after creating a filler for the left-over space to
3697 for (PagedSpace* space = spaces.Next(); space != nullptr;
3698 space = spaces.Next()) {
3699 space->MakeLinearAllocationAreaIterable();
3710 for (PagedSpace* space = spaces.Next(); space != nullptr;
3711 space = spaces.Next()) {
3712 space->FreeLinearAllocationArea();
3853 // 2 pages for the old, code, and map space + 1 page for new space.
4394 // We do not look for code in new space, or map space. If code
4501 // TODO(v8:11880): support external code space.
4528 bool Heap::InSpace(HeapObject value, AllocationSpace space) const {
4530 return third_party_heap::Heap::InSpace(value.address(), space);
4536 switch (space) {
4560 bool Heap::InSpaceSlow(Address addr, AllocationSpace space) const {
4566 switch (space) {
4588 bool Heap::IsValidAllocationSpace(AllocationSpace space) {
4589 switch (space) {
4817 for (PagedSpace* space = spaces.Next(); space != nullptr;
4818 space = spaces.Next()) {
4819 space->VerifyCountersAfterSweeping(this);
4825 for (PagedSpace* space = spaces.Next(); space != nullptr;
4826 space = spaces.Next()) {
4827 space->VerifyCountersBeforeConcurrentSweeping();
4833 for (PagedSpace* space = spaces.Next(); space != nullptr;
4834 space = spaces.Next()) {
4835 space->VerifyCommittedPhysicalMemory();
4876 // are in old space.
5234 // Start with at least 1*MB semi-space on machines with a lot of memory.
5389 for (PagedSpace* space = spaces.Next(); space != nullptr;
5390 space = spaces.Next()) {
5391 total += space->SizeOfObjects();
5451 // This predicate is called when an old generation space cannot allocated from
5649 // Update inline allocation limit for new space.
5655 for (PagedSpace* space = spaces.Next(); space != nullptr;
5656 space = spaces.Next()) {
5657 base::MutexGuard guard(space->mutex());
5658 space->EnableInlineAllocation();
5663 // Update inline allocation limit for new space.
5670 for (PagedSpace* space = spaces.Next(); space != nullptr;
5671 space = spaces.Next()) {
5672 base::MutexGuard guard(space->mutex());
5673 space->DisableInlineAllocation();
5692 // Configuration is based on the flags new-space-size (really the semispace
5693 // size) and old-space-size if set or the initial values of semispace_size_
5706 // a contiguous range of virtual address space, so that they can call each
5784 void Heap::ReplaceReadOnlySpace(SharedReadOnlySpace* space) {
5791 read_only_space_ = space;
5930 PrintF("\n### Maximum new space size reached = %.02lf\n",
5973 void Heap::NotifyOldGenerationExpansion(AllocationSpace space,
5979 if (space == CODE_SPACE || space == CODE_LO_SPACE) {
6478 Space* space = heap_->space(current_space_);
6479 if (space) return true;
6489 Space* space = heap_->space(current_space_++);
6490 DCHECK_NOT_NULL(space);
6491 return space;
6647 // space is first returned and that it has been set up.
6691 // Done with the last space.
7118 // 1) Objects in new-space can be migrated to the old space
7119 // that matches their target space or they stay in new-space.
7120 // 2) Objects in old-space stay in the same space when migrating.
7122 // fixed arrays in new-space or old space.