Lines Matching full:marking
38 #include "incremental-marking.h"
49 const char* Marking::kWhiteBitPattern = "00";
50 const char* Marking::kBlackBitPattern = "10";
51 const char* Marking::kGreyBitPattern = "11";
52 const char* Marking::kImpossibleBitPattern = "01";
338 MarkBit mark_bit = Marking::MarkBitFrom(obj);
339 ASSERT(Marking::IsWhite(mark_bit));
373 MarkBit mark_bit = Marking::MarkBitFrom(obj);
380 bool Marking::TransferMark(Address old_start, Address new_start) {
397 if (Marking::IsBlack(old_mark_bit)) {
400 Marking::MarkBlack(new_mark_bit);
402 } else if (Marking::IsGrey(old_mark_bit)) {
661 // Disable collection of maps if incremental marking is enabled.
663 // order which is not implemented for incremental marking.
691 // Clear marking bits if incremental marking is aborted.
700 // marking cycle. We did not collect any slots.
736 // Phase 1: tracing and marking live objects.
740 // Marking all live objects in the heap as part of mark-sweep or mark-compact
741 // collection. Before marking, all objects are in their normal state. After
742 // marking, live objects' map pointers are marked indicating that the object
745 // The marking algorithm is a (mostly) depth-first (because of possible stack
748 // generation's inactive ('from') space is used as a marking stack. The
749 // objects in the marking stack are the ones that have been reached and marked
752 // The marking stack can overflow during traversal. In that case, we set an
753 // overflow flag. When the overflow flag is set, we continue marking objects
754 // reachable from the objects on the marking stack, but no longer push them on
755 // the marking stack. Instead, we mark them as both marked and overflowed.
758 // After emptying the marking stack, we clear the overflow flag and traverse
760 // and continue with marking. This process repeats until all reachable
799 MarkBit code_mark = Marking::MarkBitFrom(code);
833 MarkBit code_mark = Marking::MarkBitFrom(code);
1033 MarkBit mark = Marking::MarkBitFrom(cell);
1043 MarkBit mark = Marking::MarkBitFrom(object);
1057 MarkBit code_mark = Marking::MarkBitFrom(target);
1068 MarkBit code_mark = Marking::MarkBitFrom(target);
1080 MarkBit mark = Marking::MarkBitFrom(object);
1094 MarkBit mark = Marking::MarkBitFrom(obj);
1097 MarkBit map_mark = Marking::MarkBitFrom(map);
1118 MarkBit mark = Marking::MarkBitFrom(obj);
1170 // Mark the backing hash table without pushing it on the marking stack.
1173 collector->SetMark(table, Marking::MarkBitFrom(table));
1174 collector->MarkObject(table->map(), Marking::MarkBitFrom(table->map()));
1226 MarkBit code_mark = Marking::MarkBitFrom(function->code());
1228 if (!Marking::MarkBitFrom(shared_info).Get()) {
1246 Marking::MarkBitFrom(shared_info->code());
1426 MarkBit mark = Marking::MarkBitFrom(code);
1464 MarkBit code_mark = Marking::MarkBitFrom(code);
1506 MarkBit shared_info_mark = Marking::MarkBitFrom(shared_info);
1510 Marking::MarkBitFrom(shared_info_map);
1614 MarkBit shared_mark = Marking::MarkBitFrom(shared);
1615 MarkBit code_mark = Marking::MarkBitFrom(shared->code());
1640 MarkBit inlined_code_mark = Marking::MarkBitFrom(inlined_code);
1655 MarkBit code_mark = Marking::MarkBitFrom(code);
1686 MarkBit descriptor_array_mark = Marking::MarkBitFrom(descriptor_array);
1708 // Visitor class for marking heap roots.
1728 MarkBit mark_bit = Marking::MarkBitFrom(object);
1735 // Mark the map pointer and body, and push them on the marking stack.
1736 MarkBit map_mark = Marking::MarkBitFrom(map);
1760 !Marking::MarkBitFrom(HeapObject::cast(o)).Get()) {
1791 if (Marking::MarkBitFrom(HeapObject::cast(object)).Get()) {
1823 // Mark prototype transitions array but don't push it into marking stack.
1827 MarkBit mark = Marking::MarkBitFrom(prototype_transitions);
1866 MarkBit descriptors_mark = Marking::MarkBitFrom(descriptors);
1878 MarkBit contents_mark = Marking::MarkBitFrom(contents);
1947 // Fill the marking stack with overflowed objects returned by the given
1948 // iterator. Stop when the marking stack is filled or the end of the space
1954 // The caller should ensure that the marking stack is initially not full,
1962 MarkBit markbit = Marking::MarkBitFrom(object);
1963 if ((object->map() != filler_map) && Marking::IsGrey(markbit)) {
1964 Marking::GreyToBlack(markbit);
1977 ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
1978 ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
1979 ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0);
1980 ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
2016 ASSERT(Marking::IsGrey(markbit));
2017 Marking::GreyToBlack(markbit);
2053 MarkBit mark = Marking::MarkBitFrom(heap_object);
2061 MarkBit symbol_table_mark = Marking::MarkBitFrom(symbol_table);
2101 MarkBit mark = Marking::MarkBitFrom(heap_object);
2120 MarkBit mark = Marking::MarkBitFrom(heap_object);
2153 MarkBit mark = Marking::MarkBitFrom(child);
2166 // Mark all objects reachable from the objects on the marking stack.
2167 // Before: the marking stack contains zero or more heap object pointers.
2168 // After: the marking stack is empty, and all objects reachable from the
2169 // marking stack have been marked, or are overflowed in the heap.
2176 ASSERT(Marking::IsBlack(Marking::MarkBitFrom(object)));
2179 MarkBit map_mark = Marking::MarkBitFrom(map);
2193 // push them on the marking stack. Stop early if the marking stack fills
2239 // Mark all objects reachable (transitively) from objects on the marking
2240 // stack. Before: the marking stack contains zero or more heap object
2241 // pointers. After: the marking stack is empty and there are no overflowed
2267 // and switches to a different marking system. JS interrupts interfere
2274 // Finalize the incremental marking and check whether we had an overflow.
2277 // occured during normal marking.
2278 // But incremental marker uses a separate marking deque
2294 // marking stack.
2305 // There are overflowed objects left in the heap after incremental marking.
2313 // of the incremental marking.
2352 // Repeat host application specific marking to mark unmarked objects
2381 // Remove object groups after marking phase.
2436 MarkBit map_cache_markbit = Marking::MarkBitFrom(map_cache);
2481 MarkBit map_mark = Marking::MarkBitFrom(map);
2582 current_is_alive = Marking::MarkBitFrom(current).Get();
2862 MarkBit mark_bit = Marking::MarkBitFrom(object);
2939 ASSERT(Marking::IsBlack(Marking::MarkBitFrom(object)));
2959 // Clear marking bits for current cell.
3114 ASSERT(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
3133 // Clear marking bits for current cell.
3214 MarkBit mark_bit = Marking::MarkBitFrom(code);
3215 if (Marking::IsWhite(mark_bit)) return;
3768 // the marking bitmap for that cell, which describes where the live object
3771 // first word in the marking bit map that indicates a live object.
3801 // Clear marking bits for current cell.
3840 // Clear sweeping flags indicating that marking bits are still intact.
