Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(79)

Side by Side Diff: src/heap/heap.cc

Issue 1152513002: Generalize alignment in heap GC functions. (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: Created 5 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2012 the V8 project authors. All rights reserved. 1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "src/v8.h" 5 #include "src/v8.h"
6 6
7 #include "src/accessors.h" 7 #include "src/accessors.h"
8 #include "src/api.h" 8 #include "src/api.h"
9 #include "src/base/bits.h" 9 #include "src/base/bits.h"
10 #include "src/base/once.h" 10 #include "src/base/once.h"
(...skipping 2126 matching lines...) Expand 10 before | Expand all | Expand 10 after
2137 heap->OnMoveEvent(target, source, size); 2137 heap->OnMoveEvent(target, source, size);
2138 } 2138 }
2139 2139
2140 if (marks_handling == TRANSFER_MARKS) { 2140 if (marks_handling == TRANSFER_MARKS) {
2141 if (Marking::TransferColor(source, target)) { 2141 if (Marking::TransferColor(source, target)) {
2142 MemoryChunk::IncrementLiveBytesFromGC(target->address(), size); 2142 MemoryChunk::IncrementLiveBytesFromGC(target->address(), size);
2143 } 2143 }
2144 } 2144 }
2145 } 2145 }
2146 2146
2147 template <int alignment> 2147 template <AllocationAlignment alignment>
2148 static inline bool SemiSpaceCopyObject(Map* map, HeapObject** slot, 2148 static inline bool SemiSpaceCopyObject(Map* map, HeapObject** slot,
2149 HeapObject* object, int object_size) { 2149 HeapObject* object, int object_size) {
2150 Heap* heap = map->GetHeap(); 2150 Heap* heap = map->GetHeap();
2151 2151
2152 DCHECK(heap->AllowedToBeMigrated(object, NEW_SPACE)); 2152 DCHECK(heap->AllowedToBeMigrated(object, NEW_SPACE));
2153 AllocationAlignment align =
2154 alignment == kDoubleAlignment ? kDoubleAligned : kWordAligned;
2155 AllocationResult allocation = 2153 AllocationResult allocation =
2156 heap->new_space()->AllocateRaw(object_size, align); 2154 heap->new_space()->AllocateRaw(object_size, alignment);
2157 2155
2158 HeapObject* target = NULL; // Initialization to please compiler. 2156 HeapObject* target = NULL; // Initialization to please compiler.
2159 if (allocation.To(&target)) { 2157 if (allocation.To(&target)) {
2160 // Order is important here: Set the promotion limit before storing a 2158 // Order is important here: Set the promotion limit before storing a
2161 // filler for double alignment or migrating the object. Otherwise we 2159 // filler for double alignment or migrating the object. Otherwise we
2162 // may end up overwriting promotion queue entries when we migrate the 2160 // may end up overwriting promotion queue entries when we migrate the
2163 // object. 2161 // object.
2164 heap->promotion_queue()->SetNewLimit(heap->new_space()->top()); 2162 heap->promotion_queue()->SetNewLimit(heap->new_space()->top());
2165 2163
2166 MigrateObject(heap, object, target, object_size); 2164 MigrateObject(heap, object, target, object_size);
2167 2165
2168 // Update slot to new target. 2166 // Update slot to new target.
2169 *slot = target; 2167 *slot = target;
2170 2168
2171 heap->IncrementSemiSpaceCopiedObjectSize(object_size); 2169 heap->IncrementSemiSpaceCopiedObjectSize(object_size);
2172 return true; 2170 return true;
2173 } 2171 }
2174 return false; 2172 return false;
2175 } 2173 }
2176 2174
2177 2175
2178 template <ObjectContents object_contents, int alignment> 2176 template <ObjectContents object_contents, AllocationAlignment alignment>
2179 static inline bool PromoteObject(Map* map, HeapObject** slot, 2177 static inline bool PromoteObject(Map* map, HeapObject** slot,
2180 HeapObject* object, int object_size) { 2178 HeapObject* object, int object_size) {
2181 Heap* heap = map->GetHeap(); 2179 Heap* heap = map->GetHeap();
2182 2180
2183 AllocationAlignment align =
2184 alignment == kDoubleAlignment ? kDoubleAligned : kWordAligned;
2185 AllocationResult allocation = 2181 AllocationResult allocation =
2186 heap->old_space()->AllocateRaw(object_size, align); 2182 heap->old_space()->AllocateRaw(object_size, alignment);
2187 2183
2188 HeapObject* target = NULL; // Initialization to please compiler. 2184 HeapObject* target = NULL; // Initialization to please compiler.
2189 if (allocation.To(&target)) { 2185 if (allocation.To(&target)) {
2190 MigrateObject(heap, object, target, object_size); 2186 MigrateObject(heap, object, target, object_size);
2191 2187
2192 // Update slot to new target. 2188 // Update slot to new target.
2193 *slot = target; 2189 *slot = target;
2194 2190
2195 if (object_contents == POINTER_OBJECT) { 2191 if (object_contents == POINTER_OBJECT) {
2196 if (map->instance_type() == JS_FUNCTION_TYPE) { 2192 if (map->instance_type() == JS_FUNCTION_TYPE) {
2197 heap->promotion_queue()->insert(target, 2193 heap->promotion_queue()->insert(target,
2198 JSFunction::kNonWeakFieldsEndOffset); 2194 JSFunction::kNonWeakFieldsEndOffset);
2199 } else { 2195 } else {
2200 heap->promotion_queue()->insert(target, object_size); 2196 heap->promotion_queue()->insert(target, object_size);
2201 } 2197 }
2202 } 2198 }
2203 heap->IncrementPromotedObjectsSize(object_size); 2199 heap->IncrementPromotedObjectsSize(object_size);
2204 return true; 2200 return true;
2205 } 2201 }
2206 return false; 2202 return false;
2207 } 2203 }
2208 2204
2209 2205
2210 template <ObjectContents object_contents, int alignment> 2206 template <ObjectContents object_contents, AllocationAlignment alignment>
2211 static inline void EvacuateObject(Map* map, HeapObject** slot, 2207 static inline void EvacuateObject(Map* map, HeapObject** slot,
2212 HeapObject* object, int object_size) { 2208 HeapObject* object, int object_size) {
2213 SLOW_DCHECK(object_size <= Page::kMaxRegularHeapObjectSize); 2209 SLOW_DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
2214 SLOW_DCHECK(object->Size() == object_size); 2210 SLOW_DCHECK(object->Size() == object_size);
2215 Heap* heap = map->GetHeap(); 2211 Heap* heap = map->GetHeap();
2216 2212
2217 if (!heap->ShouldBePromoted(object->address(), object_size)) { 2213 if (!heap->ShouldBePromoted(object->address(), object_size)) {
2218 // A semi-space copy may fail due to fragmentation. In that case, we 2214 // A semi-space copy may fail due to fragmentation. In that case, we
2219 // try to promote the object. 2215 // try to promote the object.
2220 if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) { 2216 if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) {
(...skipping 29 matching lines...) Expand all
2250 // promotion queue processing (IterateAndMarkPointersToFromSpace) will 2246 // promotion queue processing (IterateAndMarkPointersToFromSpace) will
2251 // miss it as it is not HeapObject-tagged. 2247 // miss it as it is not HeapObject-tagged.
2252 Address code_entry_slot = 2248 Address code_entry_slot =
2253 target->address() + JSFunction::kCodeEntryOffset; 2249 target->address() + JSFunction::kCodeEntryOffset;
2254 Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot)); 2250 Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot));
2255 map->GetHeap()->mark_compact_collector()->RecordCodeEntrySlot( 2251 map->GetHeap()->mark_compact_collector()->RecordCodeEntrySlot(
2256 code_entry_slot, code); 2252 code_entry_slot, code);
2257 } 2253 }
2258 } 2254 }
2259 2255
2256 #if V8_HOST_ARCH_64_BIT
2257 #define kObjectAligned kDoubleAligned
Hannes Payer (out of office) 2015/05/22 06:11:12 Why do we need this?
bbudge 2015/05/22 07:34:33 I was confused about word size vs. word aligned, w
2258 #else
2259 #define kObjectAligned kWordAligned
2260 #endif
2260 2261
2261 static inline void EvacuateFixedArray(Map* map, HeapObject** slot, 2262 static inline void EvacuateFixedArray(Map* map, HeapObject** slot,
2262 HeapObject* object) { 2263 HeapObject* object) {
2263 int object_size = FixedArray::BodyDescriptor::SizeOf(map, object); 2264 int object_size = FixedArray::BodyDescriptor::SizeOf(map, object);
2264 EvacuateObject<POINTER_OBJECT, kObjectAlignment>(map, slot, object, 2265 EvacuateObject<POINTER_OBJECT, kObjectAligned>(map, slot, object,
Hannes Payer (out of office) 2015/05/22 06:11:13 Why not kWordAligned?
bbudge 2015/05/22 07:34:33 Changed to use kWordAligned.
2265 object_size); 2266 object_size);
2266 } 2267 }
2267 2268
2268 2269
2269 static inline void EvacuateFixedDoubleArray(Map* map, HeapObject** slot, 2270 static inline void EvacuateFixedDoubleArray(Map* map, HeapObject** slot,
2270 HeapObject* object) { 2271 HeapObject* object) {
2271 int length = reinterpret_cast<FixedDoubleArray*>(object)->length(); 2272 int length = reinterpret_cast<FixedDoubleArray*>(object)->length();
2272 int object_size = FixedDoubleArray::SizeFor(length); 2273 int object_size = FixedDoubleArray::SizeFor(length);
2273 EvacuateObject<DATA_OBJECT, kDoubleAlignment>(map, slot, object, 2274 EvacuateObject<DATA_OBJECT, kDoubleAligned>(map, slot, object, object_size);
2274 object_size);
2275 } 2275 }
2276 2276
2277 2277
2278 static inline void EvacuateFixedTypedArray(Map* map, HeapObject** slot, 2278 static inline void EvacuateFixedTypedArray(Map* map, HeapObject** slot,
2279 HeapObject* object) { 2279 HeapObject* object) {
2280 int object_size = reinterpret_cast<FixedTypedArrayBase*>(object)->size(); 2280 int object_size = reinterpret_cast<FixedTypedArrayBase*>(object)->size();
2281 EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object, 2281 EvacuateObject<DATA_OBJECT, kObjectAligned>(map, slot, object, object_size);
2282 object_size);
2283 } 2282 }
2284 2283
2285 2284
2286 static inline void EvacuateFixedFloat64Array(Map* map, HeapObject** slot, 2285 static inline void EvacuateFixedFloat64Array(Map* map, HeapObject** slot,
2287 HeapObject* object) { 2286 HeapObject* object) {
2288 int object_size = reinterpret_cast<FixedFloat64Array*>(object)->size(); 2287 int object_size = reinterpret_cast<FixedFloat64Array*>(object)->size();
2289 EvacuateObject<DATA_OBJECT, kDoubleAlignment>(map, slot, object, 2288 EvacuateObject<DATA_OBJECT, kDoubleAligned>(map, slot, object, object_size);
2290 object_size);
2291 } 2289 }
2292 2290
2293 2291
2294 static inline void EvacuateByteArray(Map* map, HeapObject** slot, 2292 static inline void EvacuateByteArray(Map* map, HeapObject** slot,
2295 HeapObject* object) { 2293 HeapObject* object) {
2296 int object_size = reinterpret_cast<ByteArray*>(object)->ByteArraySize(); 2294 int object_size = reinterpret_cast<ByteArray*>(object)->ByteArraySize();
2297 EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object, 2295 EvacuateObject<DATA_OBJECT, kObjectAligned>(map, slot, object, object_size);
2298 object_size);
2299 } 2296 }
2300 2297
2301 2298
2302 static inline void EvacuateSeqOneByteString(Map* map, HeapObject** slot, 2299 static inline void EvacuateSeqOneByteString(Map* map, HeapObject** slot,
2303 HeapObject* object) { 2300 HeapObject* object) {
2304 int object_size = SeqOneByteString::cast(object) 2301 int object_size = SeqOneByteString::cast(object)
2305 ->SeqOneByteStringSize(map->instance_type()); 2302 ->SeqOneByteStringSize(map->instance_type());
2306 EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object, 2303 EvacuateObject<DATA_OBJECT, kObjectAligned>(map, slot, object, object_size);
2307 object_size);
2308 } 2304 }
2309 2305
2310 2306
2311 static inline void EvacuateSeqTwoByteString(Map* map, HeapObject** slot, 2307 static inline void EvacuateSeqTwoByteString(Map* map, HeapObject** slot,
2312 HeapObject* object) { 2308 HeapObject* object) {
2313 int object_size = SeqTwoByteString::cast(object) 2309 int object_size = SeqTwoByteString::cast(object)
2314 ->SeqTwoByteStringSize(map->instance_type()); 2310 ->SeqTwoByteStringSize(map->instance_type());
2315 EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object, 2311 EvacuateObject<DATA_OBJECT, kObjectAligned>(map, slot, object, object_size);
2316 object_size);
2317 } 2312 }
2318 2313
2319 2314
2320 static inline void EvacuateShortcutCandidate(Map* map, HeapObject** slot, 2315 static inline void EvacuateShortcutCandidate(Map* map, HeapObject** slot,
2321 HeapObject* object) { 2316 HeapObject* object) {
2322 DCHECK(IsShortcutCandidate(map->instance_type())); 2317 DCHECK(IsShortcutCandidate(map->instance_type()));
2323 2318
2324 Heap* heap = map->GetHeap(); 2319 Heap* heap = map->GetHeap();
2325 2320
2326 if (marks_handling == IGNORE_MARKS && 2321 if (marks_handling == IGNORE_MARKS &&
(...skipping 16 matching lines...) Expand all
2343 object->set_map_word(MapWord::FromForwardingAddress(target)); 2338 object->set_map_word(MapWord::FromForwardingAddress(target));
2344 return; 2339 return;
2345 } 2340 }
2346 2341
2347 heap->DoScavengeObject(first->map(), slot, first); 2342 heap->DoScavengeObject(first->map(), slot, first);
2348 object->set_map_word(MapWord::FromForwardingAddress(*slot)); 2343 object->set_map_word(MapWord::FromForwardingAddress(*slot));
2349 return; 2344 return;
2350 } 2345 }
2351 2346
2352 int object_size = ConsString::kSize; 2347 int object_size = ConsString::kSize;
2353 EvacuateObject<POINTER_OBJECT, kObjectAlignment>(map, slot, object, 2348 EvacuateObject<POINTER_OBJECT, kObjectAligned>(map, slot, object,
2354 object_size); 2349 object_size);
2355 } 2350 }
2356 2351
2357 template <ObjectContents object_contents> 2352 template <ObjectContents object_contents>
2358 class ObjectEvacuationStrategy { 2353 class ObjectEvacuationStrategy {
2359 public: 2354 public:
2360 template <int object_size> 2355 template <int object_size>
2361 static inline void VisitSpecialized(Map* map, HeapObject** slot, 2356 static inline void VisitSpecialized(Map* map, HeapObject** slot,
2362 HeapObject* object) { 2357 HeapObject* object) {
2363 EvacuateObject<object_contents, kObjectAlignment>(map, slot, object, 2358 EvacuateObject<object_contents, kObjectAligned>(map, slot, object,
2364 object_size); 2359 object_size);
2365 } 2360 }
2366 2361
2367 static inline void Visit(Map* map, HeapObject** slot, HeapObject* object) { 2362 static inline void Visit(Map* map, HeapObject** slot, HeapObject* object) {
2368 int object_size = map->instance_size(); 2363 int object_size = map->instance_size();
2369 EvacuateObject<object_contents, kObjectAlignment>(map, slot, object, 2364 EvacuateObject<object_contents, kObjectAligned>(map, slot, object,
2370 object_size); 2365 object_size);
2371 } 2366 }
2372 }; 2367 };
2373 2368
2374 static VisitorDispatchTable<ScavengingCallback> table_; 2369 static VisitorDispatchTable<ScavengingCallback> table_;
2375 }; 2370 };
2376 2371
2377 2372
2378 template <MarksHandling marks_handling, 2373 template <MarksHandling marks_handling,
2379 LoggingAndProfiling logging_and_profiling_mode> 2374 LoggingAndProfiling logging_and_profiling_mode>
2380 VisitorDispatchTable<ScavengingCallback> 2375 VisitorDispatchTable<ScavengingCallback>
(...skipping 4197 matching lines...) Expand 10 before | Expand all | Expand 10 after
6578 *object_type = "CODE_TYPE"; \ 6573 *object_type = "CODE_TYPE"; \
6579 *object_sub_type = "CODE_AGE/" #name; \ 6574 *object_sub_type = "CODE_AGE/" #name; \
6580 return true; 6575 return true;
6581 CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME) 6576 CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME)
6582 #undef COMPARE_AND_RETURN_NAME 6577 #undef COMPARE_AND_RETURN_NAME
6583 } 6578 }
6584 return false; 6579 return false;
6585 } 6580 }
6586 } 6581 }
6587 } // namespace v8::internal 6582 } // namespace v8::internal
OLDNEW
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698