OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (C) 2013 Google Inc. All rights reserved. | 2 * Copyright (C) 2013 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 554 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
565 if (objectFields[i] != 0) | 565 if (objectFields[i] != 0) |
566 return false; | 566 return false; |
567 } | 567 } |
568 return true; | 568 return true; |
569 } | 569 } |
570 #endif | 570 #endif |
571 | 571 |
572 template<> | 572 template<> |
573 void LargeObject<FinalizedHeapObjectHeader>::mark(Visitor* visitor) | 573 void LargeObject<FinalizedHeapObjectHeader>::mark(Visitor* visitor) |
574 { | 574 { |
575 if (heapObjectHeader()->hasVTable() && !vTableInitialized(payload())) { | 575 FinalizedHeapObjectHeader* header = heapObjectHeader(); |
576 FinalizedHeapObjectHeader* header = heapObjectHeader(); | 576 if (header->hasVTable() && !vTableInitialized(payload())) { |
577 visitor->markNoTracing(header); | 577 visitor->markNoTracing(header); |
578 ASSERT(isUninitializedMemory(header->payload(), header->payloadSize())); | 578 ASSERT(isUninitializedMemory(header->payload(), header->payloadSize())); |
579 } else { | 579 } else { |
580 visitor->mark(heapObjectHeader(), heapObjectHeader()->traceCallback()); | 580 visitor->mark(header, header->traceCallback()); |
581 } | 581 } |
582 } | 582 } |
583 | 583 |
584 template<> | 584 template<> |
585 void LargeObject<HeapObjectHeader>::mark(Visitor* visitor) | 585 void LargeObject<HeapObjectHeader>::mark(Visitor* visitor) |
586 { | 586 { |
587 ASSERT(gcInfo()); | 587 ASSERT(gcInfo()); |
588 if (gcInfo()->hasVTable() && !vTableInitialized(payload())) { | 588 if (gcInfo()->hasVTable() && !vTableInitialized(payload())) { |
589 HeapObjectHeader* header = heapObjectHeader(); | 589 HeapObjectHeader* header = heapObjectHeader(); |
590 visitor->markNoTracing(header); | 590 visitor->markNoTracing(header); |
(...skipping 1386 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1977 result.storedValue->value.add(reinterpret_cast<uintptr_t>(objectPoin ter)); | 1977 result.storedValue->value.add(reinterpret_cast<uintptr_t>(objectPoin ter)); |
1978 } | 1978 } |
1979 ObjectGraph::AddResult result = objectGraph().add(reinterpret_cast<uintp tr_t>(objectPointer), std::make_pair(reinterpret_cast<uintptr_t>(m_hostObject), m_hostName)); | 1979 ObjectGraph::AddResult result = objectGraph().add(reinterpret_cast<uintp tr_t>(objectPointer), std::make_pair(reinterpret_cast<uintptr_t>(m_hostObject), m_hostName)); |
1980 ASSERT(result.isNewEntry); | 1980 ASSERT(result.isNewEntry); |
1981 // fprintf(stderr, "%s[%p] -> %s[%p]\n", m_hostName.ascii().data(), m_ho stObject, className.ascii().data(), objectPointer); | 1981 // fprintf(stderr, "%s[%p] -> %s[%p]\n", m_hostName.ascii().data(), m_ho stObject, className.ascii().data(), objectPointer); |
1982 #endif | 1982 #endif |
1983 if (callback) | 1983 if (callback) |
1984 Heap::pushTraceCallback(m_markingStack, const_cast<void*>(objectPoin ter), callback); | 1984 Heap::pushTraceCallback(m_markingStack, const_cast<void*>(objectPoin ter), callback); |
1985 } | 1985 } |
1986 | 1986 |
1987 // We need both HeapObjectHeader and FinalizedHeapObjectHeader versions to c orrectly find the payload. | |
1987 virtual void mark(HeapObjectHeader* header, TraceCallback callback) override | 1988 virtual void mark(HeapObjectHeader* header, TraceCallback callback) override |
1988 { | 1989 { |
1989 // We need both the HeapObjectHeader and FinalizedHeapObjectHeader | |
1990 // version to correctly find the payload. | |
1991 visitHeader(header, header->payload(), callback); | 1990 visitHeader(header, header->payload(), callback); |
1992 } | 1991 } |
1993 | 1992 |
1994 virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) override | 1993 virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) override |
1995 { | 1994 { |
1996 // We need both the HeapObjectHeader and FinalizedHeapObjectHeader | |
1997 // version to correctly find the payload. | |
1998 visitHeader(header, header->payload(), callback); | 1995 visitHeader(header, header->payload(), callback); |
1999 } | 1996 } |
2000 | 1997 |
2001 virtual void mark(const void* objectPointer, TraceCallback callback) overrid e | 1998 virtual void mark(const void* objectPointer, TraceCallback callback) overrid e |
2002 { | 1999 { |
2003 if (!objectPointer) | 2000 if (!objectPointer) |
2004 return; | 2001 return; |
2005 FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPaylo ad(objectPointer); | 2002 FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPaylo ad(objectPointer); |
2006 visitHeader(header, header->payload(), callback); | 2003 visitHeader(header, header->payload(), callback); |
2007 } | 2004 } |
(...skipping 18 matching lines...) Expand all Loading... | |
2026 { | 2023 { |
2027 return Heap::weakTableRegistered(closure); | 2024 return Heap::weakTableRegistered(closure); |
2028 } | 2025 } |
2029 #endif | 2026 #endif |
2030 | 2027 |
2031 virtual bool isMarked(const void* objectPointer) override | 2028 virtual bool isMarked(const void* objectPointer) override |
2032 { | 2029 { |
2033 return FinalizedHeapObjectHeader::fromPayload(objectPointer)->isMarked() ; | 2030 return FinalizedHeapObjectHeader::fromPayload(objectPointer)->isMarked() ; |
2034 } | 2031 } |
2035 | 2032 |
2033 virtual bool ensureMarked(const void* objectPointer) override | |
haraken
2014/11/28 05:20:05
Shall we flip true/false of the return value? It l
haraken
2014/11/28 05:20:05
Can we share the implementation of ensureMarked wi
sof
2014/11/28 12:05:08
I would prefer not to do that exercise; there's tr
sof
2014/11/28 12:05:08
Meaning is still not self-evident, but flipped.
haraken
2014/11/28 12:39:27
Sounds reasonable. Given that the code that ensure
| |
2034 { | |
2035 if (!objectPointer) | |
2036 return true; | |
2037 #if ENABLE(ASSERT) | |
2038 if (isMarked(objectPointer)) | |
2039 return true; | |
2040 | |
2041 markNoTracing(objectPointer); | |
2042 #else | |
2043 FinalizedHeapObjectHeader* header = | |
2044 FinalizedHeapObjectHeader::fromPayload(objectPointer); | |
2045 if (header->isMarked()) | |
2046 return true; | |
2047 header->mark(); | |
2048 #endif | |
2049 return false; | |
2050 } | |
2051 | |
2052 #if ENABLE(ASSERT) | |
kouhei (in TOK)
2014/11/28 01:00:57
Would you describe why we need ENABLE(ASSERT) / no
sof
2014/11/28 12:05:08
A debug-specific version is provided essentially b
kouhei (in TOK)
2014/12/02 00:41:58
Thanks for the explanation. Would you add a commen
sof
2014/12/02 09:52:15
Certainly, done.
| |
2053 #define DEFINE_ENSURE_MARKED_METHOD(Type) \ | |
2054 virtual bool ensureMarked(const Type* objectPointer) override \ | |
2055 { \ | |
2056 if (!objectPointer) \ | |
2057 return true; \ | |
2058 COMPILE_ASSERT(!NeedsAdjustAndMark<Type>::value, CanOnlyUseIsMarkedOnNon AdjustedTypes); \ | |
2059 if (isMarked(objectPointer)) \ | |
2060 return true; \ | |
2061 markNoTracing(objectPointer); \ | |
2062 return false; \ | |
2063 } | |
2064 #else | |
2065 #define DEFINE_ENSURE_MARKED_METHOD(Type) \ | |
2066 virtual bool ensureMarked(const Type* objectPointer) override \ | |
2067 { \ | |
2068 if (!objectPointer) \ | |
2069 return true; \ | |
2070 HeapObjectHeader* header = \ | |
2071 HeapObjectHeader::fromPayload(objectPointer); \ | |
2072 if (header->isMarked()) \ | |
2073 return true; \ | |
2074 header->mark(); \ | |
2075 return false; \ | |
2076 } | |
2077 #endif | |
2078 | |
2036 // This macro defines the necessary visitor methods for typed heaps | 2079 // This macro defines the necessary visitor methods for typed heaps |
2037 #define DEFINE_VISITOR_METHODS(Type) \ | 2080 #define DEFINE_VISITOR_METHODS(Type) \ |
2038 virtual void mark(const Type* objectPointer, TraceCallback callback) overrid e \ | 2081 virtual void mark(const Type* objectPointer, TraceCallback callback) overrid e \ |
2039 { \ | 2082 { \ |
2040 if (!objectPointer) \ | 2083 if (!objectPointer) \ |
2041 return; \ | 2084 return; \ |
2042 HeapObjectHeader* header = \ | 2085 HeapObjectHeader* header = \ |
2043 HeapObjectHeader::fromPayload(objectPointer); \ | 2086 HeapObjectHeader::fromPayload(objectPointer); \ |
2044 visitHeader(header, header->payload(), callback); \ | 2087 visitHeader(header, header->payload(), callback); \ |
2045 } \ | 2088 } \ |
2046 virtual bool isMarked(const Type* objectPointer) override \ | 2089 virtual bool isMarked(const Type* objectPointer) override \ |
2047 { \ | 2090 { \ |
2048 return HeapObjectHeader::fromPayload(objectPointer)->isMarked(); \ | 2091 return HeapObjectHeader::fromPayload(objectPointer)->isMarked(); \ |
2049 } | 2092 } \ |
2093 DEFINE_ENSURE_MARKED_METHOD(Type) | |
2050 | 2094 |
2051 FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS) | 2095 FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS) |
2052 #undef DEFINE_VISITOR_METHODS | 2096 #undef DEFINE_VISITOR_METHODS |
2053 | 2097 |
2054 #if ENABLE(GC_PROFILE_MARKING) | 2098 #if ENABLE(GC_PROFILE_MARKING) |
2055 void reportStats() | 2099 void reportStats() |
2056 { | 2100 { |
2057 fprintf(stderr, "\n---------- AFTER MARKING -------------------\n"); | 2101 fprintf(stderr, "\n---------- AFTER MARKING -------------------\n"); |
2058 for (LiveObjectMap::iterator it = currentlyLive().begin(), end = current lyLive().end(); it != end; ++it) { | 2102 for (LiveObjectMap::iterator it = currentlyLive().begin(), end = current lyLive().end(); it != end; ++it) { |
2059 fprintf(stderr, "%s %u", it->key.ascii().data(), it->value.size()); | 2103 fprintf(stderr, "%s %u", it->key.ascii().data(), it->value.size()); |
(...skipping 767 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2827 bool Heap::s_lastGCWasConservative = false; | 2871 bool Heap::s_lastGCWasConservative = false; |
2828 bool Heap::s_inGC = false; | 2872 bool Heap::s_inGC = false; |
2829 FreePagePool* Heap::s_freePagePool; | 2873 FreePagePool* Heap::s_freePagePool; |
2830 OrphanedPagePool* Heap::s_orphanedPagePool; | 2874 OrphanedPagePool* Heap::s_orphanedPagePool; |
2831 Heap::RegionTree* Heap::s_regionTree = 0; | 2875 Heap::RegionTree* Heap::s_regionTree = 0; |
2832 size_t Heap::s_allocatedObjectSize = 0; | 2876 size_t Heap::s_allocatedObjectSize = 0; |
2833 size_t Heap::s_allocatedSpace = 0; | 2877 size_t Heap::s_allocatedSpace = 0; |
2834 size_t Heap::s_markedObjectSize = 0; | 2878 size_t Heap::s_markedObjectSize = 0; |
2835 | 2879 |
2836 } // namespace blink | 2880 } // namespace blink |
OLD | NEW |