Lines Matching full:marking
39 #include "incremental-marking.h"
50 const char* Marking::kWhiteBitPattern = "00";
51 const char* Marking::kBlackBitPattern = "10";
52 const char* Marking::kGreyBitPattern = "11";
53 const char* Marking::kImpossibleBitPattern = "01";
285 // over array bodies, this is easier than intrusive marking.
488 MarkBit mark_bit = Marking::MarkBitFrom(obj);
489 CHECK(Marking::IsWhite(mark_bit));
549 MarkBit mark_bit = Marking::MarkBitFrom(obj);
601 bool Marking::TransferMark(Address old_start, Address new_start) {
618 if (Marking::IsBlack(old_mark_bit)) {
621 Marking::MarkBlack(new_mark_bit);
623 } else if (Marking::IsGrey(old_mark_bit)) {
912 // Clear marking bits if incremental marking is aborted.
921 // marking cycle. We did not collect any slots.
961 // Phase 1: tracing and marking live objects.
965 // Marking all live objects in the heap as part of mark-sweep or mark-compact
966 // collection. Before marking, all objects are in their normal state. After
967 // marking, live objects' map pointers are marked indicating that the object
970 // The marking algorithm is a (mostly) depth-first (because of possible stack
973 // generation's inactive ('from') space is used as a marking stack. The
974 // objects in the marking stack are the ones that have been reached and marked
977 // The marking stack can overflow during traversal. In that case, we set an
978 // overflow flag. When the overflow flag is set, we continue marking objects
979 // reachable from the objects on the marking stack, but no longer push them on
980 // the marking stack. Instead, we mark them as both marked and overflowed.
983 // After emptying the marking stack, we clear the overflow flag and traverse
985 // and continue with marking. This process repeats until all reachable
1001 MarkBit code_mark = Marking::MarkBitFrom(code);
1043 MarkBit code_mark = Marking::MarkBitFrom(code);
1084 MarkBit code_mark = Marking::MarkBitFrom(code);
1093 ASSERT(Marking::IsBlack(
1094 Marking::MarkBitFrom(HeapObject::cast(*context_slot))));
1102 ASSERT(Marking::IsBlack(
1103 Marking::MarkBitFrom(HeapObject::cast(*code_slot))));
1111 ASSERT(Marking::IsBlack(
1112 Marking::MarkBitFrom(HeapObject::cast(*literals_slot))));
1366 // Marks the object black and pushes it on the marking stack.
1368 MarkBit mark = Marking::MarkBitFrom(object);
1372 // Marks the object black without pushing it on the marking stack.
1373 // Returns true if object needed marking and false otherwise.
1375 MarkBit mark_bit = Marking::MarkBitFrom(object);
1390 MarkBit mark = Marking::MarkBitFrom(object);
1404 MarkBit mark = Marking::MarkBitFrom(obj);
1407 MarkBit map_mark = Marking::MarkBitFrom(map);
1428 MarkBit mark = Marking::MarkBitFrom(obj);
1464 // Mark the backing hash table without pushing it on the marking stack.
1470 MarkBit table_mark = Marking::MarkBitFrom(table);
1474 collector->MarkObject(table->map(), Marking::MarkBitFrom(table->map()));
1735 MarkBit shared_mark = Marking::MarkBitFrom(shared);
1736 MarkBit code_mark = Marking::MarkBitFrom(shared->code());
1756 MarkBit code_mark = Marking::MarkBitFrom(code);
1778 MarkBit descriptor_array_mark = Marking::MarkBitFrom(descriptor_array);
1800 // Visitor class for marking heap roots.
1820 MarkBit mark_bit = Marking::MarkBitFrom(object);
1827 // Mark the map pointer and body, and push them on the marking stack.
1828 MarkBit map_mark = Marking::MarkBitFrom(map);
1852 !Marking::MarkBitFrom(HeapObject::cast(o)).Get()) {
1883 if (Marking::MarkBitFrom(HeapObject::cast(object)).Get()) {
1900 // Fill the marking stack with overflowed objects returned by the given
1901 // iterator. Stop when the marking stack is filled or the end of the space
1907 // The caller should ensure that the marking stack is initially not full,
1915 MarkBit markbit = Marking::MarkBitFrom(object);
1916 if ((object->map() != filler_map) && Marking::IsGrey(markbit)) {
1917 Marking::GreyToBlack(markbit);
1932 ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
1933 ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
1934 ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0);
1935 ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
1959 ASSERT(Marking::IsGrey(markbit));
1960 Marking::GreyToBlack(markbit);
1978 ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
1979 ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
1980 ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0);
1981 ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
2071 MarkBit mark = Marking::MarkBitFrom(heap_object);
2081 MarkBit mark = Marking::MarkBitFrom(heap_object);
2089 MarkBit string_table_mark = Marking::MarkBitFrom(string_table);
2098 MarkBit mark_bit = Marking::MarkBitFrom(site);
2140 MarkBit mark = Marking::MarkBitFrom(child);
2157 MarkBit mark = Marking::MarkBitFrom(weak_object_to_code_table);
2163 // Mark all objects reachable from the objects on the marking stack.
2164 // Before: the marking stack contains zero or more heap object pointers.
2165 // After: the marking stack is empty, and all objects reachable from the
2166 // marking stack have been marked, or are overflowed in the heap.
2172 ASSERT(Marking::IsBlack(Marking::MarkBitFrom(object)));
2175 MarkBit map_mark = Marking::MarkBitFrom(map);
2184 // push them on the marking stack. Stop early if the marking stack fills
2234 // Mark all objects reachable (transitively) from objects on the marking
2235 // stack. Before: the marking stack contains zero or more heap object
2236 // pointers. After: the marking stack is empty and there are no overflowed
2247 // Mark all objects reachable (transitively) from objects on the marking
2248 // stack including references only considered in the atomic marking pause.
2284 // and switches to a different marking system. JS interrupts interfere
2291 // Finalize the incremental marking and check whether we had an overflow.
2294 // occured during normal marking.
2295 // But incremental marker uses a separate marking deque
2311 // marking stack.
2322 // There are overflowed objects left in the heap after incremental marking.
2330 // of the incremental marking.
2382 // Repeat host application specific and Harmony weak maps marking to
2411 // Remove object groups after marking phase.
2419 // disable it before incremental marking steps for next cycle.
2475 MarkBit map_cache_markbit = Marking::MarkBitFrom(map_cache);
2516 MarkBit map_mark = Marking::MarkBitFrom(map);
2570 MarkBit mark = Marking::MarkBitFrom(obj);
2640 bool parent_is_alive = Marking::MarkBitFrom(parent).Get();
3026 ASSERT(Marking::IsBlack(Marking::MarkBitFrom(object)));
3046 // Clear marking bits for current cell.
3197 ASSERT(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
3216 // Clear marking bits for current cell.
3305 MarkBit mark_bit = Marking::MarkBitFrom(code);
3306 if (Marking::IsWhite(mark_bit)) return;
3927 // the marking bitmap for that cell, which describes where the live object
3930 // first word in the marking bit map that indicates a live object.
3955 // Clear marking bits for current cell.
4007 // Clear sweeping flags indicating that marking bits are still intact.
4298 MarkBit mark_bit = Marking::MarkBitFrom(host);
4299 if (Marking::IsBlack(mark_bit)) {
