665 // This closure is used to mark refs into the g1 generation |
665 // This closure is used to mark refs into the g1 generation |
666 // from external roots in the CMS bit map. |
666 // from external roots in the CMS bit map. |
667 // Called at the first checkpoint. |
667 // Called at the first checkpoint. |
668 // |
668 // |
669 |
669 |
670 #define PRINT_REACHABLE_AT_INITIAL_MARK 0 |
|
671 #if PRINT_REACHABLE_AT_INITIAL_MARK |
|
672 static FILE* reachable_file = NULL; |
|
673 |
|
674 class PrintReachableClosure: public OopsInGenClosure { |
|
675 CMBitMap* _bm; |
|
676 int _level; |
|
677 public: |
|
678 PrintReachableClosure(CMBitMap* bm) : |
|
679 _bm(bm), _level(0) { |
|
680 guarantee(reachable_file != NULL, "pre-condition"); |
|
681 } |
|
682 void do_oop(oop* p) { |
|
683 oop obj = *p; |
|
684 HeapWord* obj_addr = (HeapWord*)obj; |
|
685 if (obj == NULL) return; |
|
686 fprintf(reachable_file, "%d: "PTR_FORMAT" -> "PTR_FORMAT" (%d)\n", |
|
687 _level, p, (void*) obj, _bm->isMarked(obj_addr)); |
|
688 if (!_bm->isMarked(obj_addr)) { |
|
689 _bm->mark(obj_addr); |
|
690 _level++; |
|
691 obj->oop_iterate(this); |
|
692 _level--; |
|
693 } |
|
694 } |
|
695 }; |
|
696 #endif // PRINT_REACHABLE_AT_INITIAL_MARK |
|
697 |
|
698 #define SEND_HEAP_DUMP_TO_FILE 0 |
|
699 #if SEND_HEAP_DUMP_TO_FILE |
|
700 static FILE* heap_dump_file = NULL; |
|
701 #endif // SEND_HEAP_DUMP_TO_FILE |
|
702 |
|
703 void ConcurrentMark::clearNextBitmap() { |
670 void ConcurrentMark::clearNextBitmap() { |
704 guarantee(!G1CollectedHeap::heap()->mark_in_progress(), "Precondition."); |
671 guarantee(!G1CollectedHeap::heap()->mark_in_progress(), "Precondition."); |
705 |
672 |
706 // clear the mark bitmap (no grey objects to start with). |
673 // clear the mark bitmap (no grey objects to start with). |
707 // We need to do this in chunks and offer to yield in between |
674 // We need to do this in chunks and offer to yield in between |
735 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
702 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
736 G1CollectorPolicy* g1p = g1h->g1_policy(); |
703 G1CollectorPolicy* g1p = g1h->g1_policy(); |
737 |
704 |
738 _has_aborted = false; |
705 _has_aborted = false; |
739 |
706 |
740 // Find all the reachable objects... |
707 if (G1PrintReachableAtInitialMark) { |
741 #if PRINT_REACHABLE_AT_INITIAL_MARK |
708 print_reachable(true, "before"); |
742 guarantee(reachable_file == NULL, "Protocol"); |
709 } |
743 char fn_buf[100]; |
|
744 sprintf(fn_buf, "/tmp/reachable.txt.%d", os::current_process_id()); |
|
745 reachable_file = fopen(fn_buf, "w"); |
|
746 // clear the mark bitmap (no grey objects to start with) |
|
747 _nextMarkBitMap->clearAll(); |
|
748 PrintReachableClosure prcl(_nextMarkBitMap); |
|
749 g1h->process_strong_roots(true, // activate StrongRootsScope |
|
750 false, // fake perm gen collection |
|
751 SharedHeap::SO_AllClasses, |
|
752 &prcl, // Regular roots |
|
753 NULL, // do not visit active blobs |
|
754 &prcl // Perm Gen Roots |
|
755 ); |
|
756 // The root iteration above "consumed" dirty cards in the perm gen. |
|
757 // Therefore, as a shortcut, we dirty all such cards. |
|
758 g1h->rem_set()->invalidate(g1h->perm_gen()->used_region(), false); |
|
759 fclose(reachable_file); |
|
760 reachable_file = NULL; |
|
761 // clear the mark bitmap again. |
|
762 _nextMarkBitMap->clearAll(); |
|
763 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); |
|
764 COMPILER2_PRESENT(DerivedPointerTable::clear()); |
|
765 #endif // PRINT_REACHABLE_AT_INITIAL_MARK |
|
766 |
710 |
767 // Initialise marking structures. This has to be done in a STW phase. |
711 // Initialise marking structures. This has to be done in a STW phase. |
768 reset(); |
712 reset(); |
769 } |
713 } |
770 |
714 |
1986 if (!_g1h->is_in_g1_reserved(obj)) |
1936 if (!_g1h->is_in_g1_reserved(obj)) |
1987 str = "outside G1 reserved"; |
1937 str = "outside G1 reserved"; |
1988 else { |
1938 else { |
1989 HeapRegion* hr = _g1h->heap_region_containing(obj); |
1939 HeapRegion* hr = _g1h->heap_region_containing(obj); |
1990 guarantee(hr != NULL, "invariant"); |
1940 guarantee(hr != NULL, "invariant"); |
1991 if (hr->obj_allocated_since_prev_marking(obj)) { |
1941 bool over_tams = false; |
|
1942 if (_use_prev_marking) { |
|
1943 over_tams = hr->obj_allocated_since_prev_marking(obj); |
|
1944 } else { |
|
1945 over_tams = hr->obj_allocated_since_next_marking(obj); |
|
1946 } |
|
1947 |
|
1948 if (over_tams) { |
1992 str = "over TAMS"; |
1949 str = "over TAMS"; |
1993 if (_bitmap->isMarked((HeapWord*) obj)) |
1950 if (_bitmap->isMarked((HeapWord*) obj)) { |
1994 str2 = " AND MARKED"; |
1951 str2 = " AND MARKED"; |
1995 } else if (_bitmap->isMarked((HeapWord*) obj)) |
1952 } |
|
1953 } else if (_bitmap->isMarked((HeapWord*) obj)) { |
1996 str = "marked"; |
1954 str = "marked"; |
1997 else |
1955 } else { |
1998 str = "#### NOT MARKED ####"; |
1956 str = "#### NOT MARKED ####"; |
|
1957 } |
1999 } |
1958 } |
2000 |
1959 |
2001 _out->print_cr(" "PTR_FORMAT" contains "PTR_FORMAT" %s%s", |
1960 _out->print_cr(" "PTR_FORMAT" contains "PTR_FORMAT" %s%s", |
2002 p, (void*) obj, str, str2); |
1961 p, (void*) obj, str, str2); |
2003 } |
1962 } |
2004 }; |
1963 }; |
2005 |
1964 |
2006 class ReachablePrinterClosure: public BitMapClosure { |
1965 class ReachablePrinterClosure: public BitMapClosure { |
2007 private: |
1966 private: |
2008 CMBitMapRO* _bitmap; |
1967 CMBitMapRO* _bitmap; |
2009 outputStream* _out; |
1968 outputStream* _out; |
|
1969 bool _use_prev_marking; |
2010 |
1970 |
2011 public: |
1971 public: |
2012 ReachablePrinterClosure(CMBitMapRO* bitmap, outputStream* out) : |
1972 ReachablePrinterClosure(CMBitMapRO* bitmap, |
2013 _bitmap(bitmap), _out(out) { } |
1973 outputStream* out, |
|
1974 bool use_prev_marking) : |
|
1975 _bitmap(bitmap), _out(out), _use_prev_marking(use_prev_marking) { } |
2014 |
1976 |
2015 bool do_bit(size_t offset) { |
1977 bool do_bit(size_t offset) { |
2016 HeapWord* addr = _bitmap->offsetToHeapWord(offset); |
1978 HeapWord* addr = _bitmap->offsetToHeapWord(offset); |
2017 ReachablePrinterOopClosure oopCl(_bitmap, _out); |
1979 ReachablePrinterOopClosure oopCl(_bitmap, _out, _use_prev_marking); |
2018 |
1980 |
2019 _out->print_cr(" obj "PTR_FORMAT", offset %10d (marked)", addr, offset); |
1981 _out->print_cr(" obj "PTR_FORMAT", offset %10d (marked)", addr, offset); |
2020 oop(addr)->oop_iterate(&oopCl); |
1982 oop(addr)->oop_iterate(&oopCl); |
2021 _out->print_cr(""); |
1983 _out->print_cr(""); |
2022 |
1984 |
2024 } |
1986 } |
2025 }; |
1987 }; |
2026 |
1988 |
2027 class ObjInRegionReachablePrinterClosure : public ObjectClosure { |
1989 class ObjInRegionReachablePrinterClosure : public ObjectClosure { |
2028 private: |
1990 private: |
2029 CMBitMapRO* _bitmap; |
1991 CMBitMapRO* _bitmap; |
2030 outputStream* _out; |
1992 outputStream* _out; |
|
1993 bool _use_prev_marking; |
2031 |
1994 |
2032 public: |
1995 public: |
|
1996 ObjInRegionReachablePrinterClosure(CMBitMapRO* bitmap, |
|
1997 outputStream* out, |
|
1998 bool use_prev_marking) : |
|
1999 _bitmap(bitmap), _out(out), _use_prev_marking(use_prev_marking) { } |
|
2000 |
2033 void do_object(oop o) { |
2001 void do_object(oop o) { |
2034 ReachablePrinterOopClosure oopCl(_bitmap, _out); |
2002 ReachablePrinterOopClosure oopCl(_bitmap, _out, _use_prev_marking); |
2035 |
2003 |
2036 _out->print_cr(" obj "PTR_FORMAT" (over TAMS)", (void*) o); |
2004 _out->print_cr(" obj "PTR_FORMAT" (over TAMS)", (void*) o); |
2037 o->oop_iterate(&oopCl); |
2005 o->oop_iterate(&oopCl); |
2038 _out->print_cr(""); |
2006 _out->print_cr(""); |
2039 } |
2007 } |
2040 |
|
2041 ObjInRegionReachablePrinterClosure(CMBitMapRO* bitmap, outputStream* out) : |
|
2042 _bitmap(bitmap), _out(out) { } |
|
2043 }; |
2008 }; |
2044 |
2009 |
2045 class RegionReachablePrinterClosure : public HeapRegionClosure { |
2010 class RegionReachablePrinterClosure : public HeapRegionClosure { |
2046 private: |
2011 private: |
2047 CMBitMapRO* _bitmap; |
2012 CMBitMapRO* _bitmap; |
2048 outputStream* _out; |
2013 outputStream* _out; |
|
2014 bool _use_prev_marking; |
2049 |
2015 |
2050 public: |
2016 public: |
2051 bool doHeapRegion(HeapRegion* hr) { |
2017 bool doHeapRegion(HeapRegion* hr) { |
2052 HeapWord* b = hr->bottom(); |
2018 HeapWord* b = hr->bottom(); |
2053 HeapWord* e = hr->end(); |
2019 HeapWord* e = hr->end(); |
2054 HeapWord* t = hr->top(); |
2020 HeapWord* t = hr->top(); |
2055 HeapWord* p = hr->prev_top_at_mark_start(); |
2021 HeapWord* p = NULL; |
|
2022 if (_use_prev_marking) { |
|
2023 p = hr->prev_top_at_mark_start(); |
|
2024 } else { |
|
2025 p = hr->next_top_at_mark_start(); |
|
2026 } |
2056 _out->print_cr("** ["PTR_FORMAT", "PTR_FORMAT"] top: "PTR_FORMAT" " |
2027 _out->print_cr("** ["PTR_FORMAT", "PTR_FORMAT"] top: "PTR_FORMAT" " |
2057 "PTAMS: "PTR_FORMAT, b, e, t, p); |
2028 "TAMS: "PTR_FORMAT, b, e, t, p); |
2058 _out->print_cr(""); |
2029 _out->print_cr(""); |
2059 |
2030 |
2060 ObjInRegionReachablePrinterClosure ocl(_bitmap, _out); |
2031 ObjInRegionReachablePrinterClosure ocl(_bitmap, _out, _use_prev_marking); |
2061 hr->object_iterate_mem_careful(MemRegion(p, t), &ocl); |
2032 hr->object_iterate_mem_careful(MemRegion(p, t), &ocl); |
2062 |
2033 |
2063 return false; |
2034 return false; |
2064 } |
2035 } |
2065 |
2036 |
2066 RegionReachablePrinterClosure(CMBitMapRO* bitmap, |
2037 RegionReachablePrinterClosure(CMBitMapRO* bitmap, |
2067 outputStream* out) : |
2038 outputStream* out, |
2068 _bitmap(bitmap), _out(out) { } |
2039 bool use_prev_marking) : |
|
2040 _bitmap(bitmap), _out(out), _use_prev_marking(use_prev_marking) { } |
2069 }; |
2041 }; |
2070 |
2042 |
2071 void ConcurrentMark::print_prev_bitmap_reachable() { |
2043 void ConcurrentMark::print_reachable(bool use_prev_marking, const char* str) { |
2072 outputStream* out = gclog_or_tty; |
2044 gclog_or_tty->print_cr("== Doing reachable object dump... "); |
2073 |
2045 |
2074 #if SEND_HEAP_DUMP_TO_FILE |
2046 if (G1PrintReachableBaseFile == NULL) { |
2075 guarantee(heap_dump_file == NULL, "Protocol"); |
2047 gclog_or_tty->print_cr(" #### error: no base file defined"); |
2076 char fn_buf[100]; |
2048 return; |
2077 sprintf(fn_buf, "/tmp/dump.txt.%d", os::current_process_id()); |
2049 } |
2078 heap_dump_file = fopen(fn_buf, "w"); |
2050 |
2079 fileStream fstream(heap_dump_file); |
2051 if (strlen(G1PrintReachableBaseFile) + 1 + strlen(str) > |
2080 out = &fstream; |
2052 (JVM_MAXPATHLEN - 1)) { |
2081 #endif // SEND_HEAP_DUMP_TO_FILE |
2053 gclog_or_tty->print_cr(" #### error: file name too long"); |
2082 |
2054 return; |
2083 RegionReachablePrinterClosure rcl(_prevMarkBitMap, out); |
2055 } |
2084 out->print_cr("--- ITERATING OVER REGIONS WITH PTAMS < TOP"); |
2056 |
|
2057 char file_name[JVM_MAXPATHLEN]; |
|
2058 sprintf(file_name, "%s.%s", G1PrintReachableBaseFile, str); |
|
2059 gclog_or_tty->print_cr(" dumping to file %s", file_name); |
|
2060 |
|
2061 fileStream fout(file_name); |
|
2062 if (!fout.is_open()) { |
|
2063 gclog_or_tty->print_cr(" #### error: could not open file"); |
|
2064 return; |
|
2065 } |
|
2066 |
|
2067 outputStream* out = &fout; |
|
2068 |
|
2069 CMBitMapRO* bitmap = NULL; |
|
2070 if (use_prev_marking) { |
|
2071 bitmap = _prevMarkBitMap; |
|
2072 } else { |
|
2073 bitmap = _nextMarkBitMap; |
|
2074 } |
|
2075 |
|
2076 out->print_cr("-- USING %s", (use_prev_marking) ? "PTAMS" : "NTAMS"); |
|
2077 out->cr(); |
|
2078 |
|
2079 RegionReachablePrinterClosure rcl(bitmap, out, use_prev_marking); |
|
2080 out->print_cr("--- ITERATING OVER REGIONS WITH TAMS < TOP"); |
|
2081 out->cr(); |
2085 _g1h->heap_region_iterate(&rcl); |
2082 _g1h->heap_region_iterate(&rcl); |
2086 out->print_cr(""); |
2083 out->cr(); |
2087 |
2084 |
2088 ReachablePrinterClosure cl(_prevMarkBitMap, out); |
2085 ReachablePrinterClosure cl(bitmap, out, use_prev_marking); |
2089 out->print_cr("--- REACHABLE OBJECTS ON THE BITMAP"); |
2086 out->print_cr("--- ITERATING OVER MARKED OBJECTS ON THE BITMAP"); |
2090 _prevMarkBitMap->iterate(&cl); |
2087 out->cr(); |
2091 out->print_cr(""); |
2088 bitmap->iterate(&cl); |
2092 |
2089 out->cr(); |
2093 #if SEND_HEAP_DUMP_TO_FILE |
2090 |
2094 fclose(heap_dump_file); |
2091 gclog_or_tty->print_cr(" done"); |
2095 heap_dump_file = NULL; |
2092 } |
2096 #endif // SEND_HEAP_DUMP_TO_FILE |
2093 |
2097 } |
2094 #endif // PRODUCT |
2098 |
2095 |
2099 // This note is for drainAllSATBBuffers and the code in between. |
2096 // This note is for drainAllSATBBuffers and the code in between. |
2100 // In the future we could reuse a task to do this work during an |
2097 // In the future we could reuse a task to do this work during an |
2101 // evacuation pause (since now tasks are not active and can be claimed |
2098 // evacuation pause (since now tasks are not active and can be claimed |
2102 // during an evacuation pause). This was a late change to the code and |
2099 // during an evacuation pause). This was a late change to the code and |