Line data Source code
1 : // Copyright 2018 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 : #ifndef V8_HEAP_LOCAL_ALLOCATOR_INL_H_
6 : #define V8_HEAP_LOCAL_ALLOCATOR_INL_H_
7 :
8 : #include "src/heap/local-allocator.h"
9 :
10 : #include "src/heap/spaces-inl.h"
11 :
12 : namespace v8 {
13 : namespace internal {
14 :
15 186396099 : AllocationResult LocalAllocator::Allocate(AllocationSpace space,
16 : int object_size,
17 : AllocationAlignment alignment) {
18 186396099 : switch (space) {
19 : case NEW_SPACE:
20 89632413 : return AllocateInNewSpace(object_size, alignment);
21 : case OLD_SPACE:
22 96762103 : return compaction_spaces_.Get(OLD_SPACE)->AllocateRaw(object_size,
23 96836833 : alignment);
24 : case CODE_SPACE:
25 1583 : return compaction_spaces_.Get(CODE_SPACE)
26 1583 : ->AllocateRaw(object_size, alignment);
27 : default:
28 0 : UNREACHABLE();
29 : break;
30 : }
31 : }
32 :
33 478137 : void LocalAllocator::FreeLast(AllocationSpace space, HeapObject object,
34 : int object_size) {
35 478137 : switch (space) {
36 : case NEW_SPACE:
37 156945 : FreeLastInNewSpace(object, object_size);
38 156945 : return;
39 : case OLD_SPACE:
40 321192 : FreeLastInOldSpace(object, object_size);
41 320884 : return;
42 : default:
43 : // Only new and old space supported.
44 0 : UNREACHABLE();
45 : break;
46 : }
47 : }
48 :
49 156945 : void LocalAllocator::FreeLastInNewSpace(HeapObject object, int object_size) {
50 156945 : if (!new_space_lab_.TryFreeLast(object, object_size)) {
51 : // We couldn't free the last object so we have to write a proper filler.
52 : heap_->CreateFillerObjectAt(object->address(), object_size,
53 9 : ClearRecordedSlots::kNo);
54 : }
55 156945 : }
56 :
57 321242 : void LocalAllocator::FreeLastInOldSpace(HeapObject object, int object_size) {
58 642347 : if (!compaction_spaces_.Get(OLD_SPACE)->TryFreeLast(object, object_size)) {
59 : // We couldn't free the last object so we have to write a proper filler.
60 : heap_->CreateFillerObjectAt(object->address(), object_size,
61 0 : ClearRecordedSlots::kNo);
62 : }
63 321105 : }
64 :
65 89311508 : AllocationResult LocalAllocator::AllocateInLAB(int object_size,
66 : AllocationAlignment alignment) {
67 : AllocationResult allocation;
68 89311508 : if (!new_space_lab_.IsValid() && !NewLocalAllocationBuffer()) {
69 : return AllocationResult::Retry(OLD_SPACE);
70 : }
71 89309006 : allocation = new_space_lab_.AllocateRawAligned(object_size, alignment);
72 89231247 : if (allocation.IsRetry()) {
73 883341 : if (!NewLocalAllocationBuffer()) {
74 : return AllocationResult::Retry(OLD_SPACE);
75 : } else {
76 120696 : allocation = new_space_lab_.AllocateRawAligned(object_size, alignment);
77 120696 : CHECK(!allocation.IsRetry());
78 : }
79 : }
80 88468602 : return allocation;
81 : }
82 :
83 968182 : bool LocalAllocator::NewLocalAllocationBuffer() {
84 968182 : if (lab_allocation_will_fail_) return false;
85 203320 : LocalAllocationBuffer saved_lab_ = new_space_lab_;
86 : AllocationResult result =
87 203318 : new_space_->AllocateRawSynchronized(kLabSize, kWordAligned);
88 406668 : new_space_lab_ = LocalAllocationBuffer::FromResult(heap_, result, kLabSize);
89 203330 : if (new_space_lab_.IsValid()) {
90 : new_space_lab_.TryMerge(&saved_lab_);
91 : return true;
92 : }
93 260 : new_space_lab_ = saved_lab_;
94 260 : lab_allocation_will_fail_ = true;
95 260 : return false;
96 : }
97 :
98 89622334 : AllocationResult LocalAllocator::AllocateInNewSpace(
99 : int object_size, AllocationAlignment alignment) {
100 89622334 : if (object_size > kMaxLabObjectSize) {
101 303279 : return new_space_->AllocateRawSynchronized(object_size, alignment);
102 : }
103 89319055 : return AllocateInLAB(object_size, alignment);
104 : }
105 :
106 : } // namespace internal
107 : } // namespace v8
108 :
109 : #endif // V8_HEAP_LOCAL_ALLOCATOR_INL_H_
|