# HG changeset patch # User andrew # Date 1401893382 -3600 # Node ID a6583ef990c25a9f8336a7224360575fdb6a751f # Parent b231464d67345f770802ed120fb678633cbb293b SystemTap probes for the garbage collector. Contributed-by: Lukas Berk diff -r b231464d6734 -r a6583ef990c2 src/share/vm/compiler/oopMap.cpp --- a/src/share/vm/compiler/oopMap.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/compiler/oopMap.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -33,9 +33,13 @@ #include "memory/resourceArea.hpp" #include "runtime/frame.inline.hpp" #include "runtime/signature.hpp" +#include "utilities/dtrace.hpp" #ifdef COMPILER1 #include "c1/c1_Defs.hpp" #endif +#ifndef USDT2 + HS_DTRACE_PROBE_DECL1(provider, gc__collection__delete, *uintptr_t); +#endif /* !USDT2 */ // OopMapStream @@ -677,6 +681,9 @@ " - Derived: " INTPTR_FORMAT " Base: " INTPTR_FORMAT " (Offset: %d)", derived_loc, (address)*derived_loc, (address)base, offset); } +#ifndef USDT2 + HS_DTRACE_PROBE1(hotspot, gc__collection__delete, entry); +#endif /* !USDT2 */ // Delete entry delete entry; diff -r b231464d6734 -r a6583ef990c2 src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -59,6 +59,12 @@ #include "runtime/vmThread.hpp" #include "services/memoryService.hpp" #include "services/runtimeService.hpp" +#include "utilities/dtrace.hpp" + +#ifndef USDT2 + HS_DTRACE_PROBE_DECL4(provider, gc__collection__contig__begin, bool, bool, size_t, bool); + HS_DTRACE_PROBE_DECL4(provider, gc__collection__contig__end, bool, bool, size_t, bool); +#endif /* !USDT2 */ // statics CMSCollector* ConcurrentMarkSweepGeneration::_collector = NULL; @@ -1648,7 +1654,13 @@ size_t size, bool tlab) { +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__contig__begin, full, clear_all_soft_refs, size, tlab); +#endif /* !USDT2 */ collector()->collect(full, clear_all_soft_refs, size, tlab); +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__contig__end, full, clear_all_soft_refs, size, tlab); +#endif /* !USDT2 */ } void CMSCollector::collect(bool full, diff -r b231464d6734 -r a6583ef990c2 src/share/vm/gc_implementation/g1/g1MarkSweep.cpp --- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -50,8 +50,13 @@ #include "runtime/thread.hpp" #include "runtime/vmThread.hpp" #include "utilities/copy.hpp" +#include "utilities/dtrace.hpp" #include "utilities/events.hpp" +#ifndef USDT2 + HS_DTRACE_PROBE_DECL2(provider, gc__collection__G1__begin, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__G1__end, *uintptr_t, *uintptr_t); + #endif /* !USDT2 */ class HeapRegion; void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, @@ -89,6 +94,9 @@ // The marking doesn't preserve the marks of biased objects. BiasedLocking::preserve_marks(); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__G1__begin, &sh, sh->gc_cause()); +#endif /* !USDT2 */ mark_sweep_phase1(marked_for_unloading, clear_all_softrefs); mark_sweep_phase2(); @@ -108,6 +116,9 @@ GenRemSet* rs = sh->rem_set(); rs->invalidate(sh->perm_gen()->used_region(), true /*whole_heap*/); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__G1__end, &sh, sh->gc_cause()); +#endif /* !USDT2 */ // "free at last gc" is calculated from these. // CHF: cheating for now!!! // Universe::set_heap_capacity_at_last_gc(Universe::heap()->capacity()); diff -r b231464d6734 -r a6583ef990c2 src/share/vm/gc_implementation/parNew/parNewGeneration.cpp --- a/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -54,6 +54,12 @@ #include "utilities/copy.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/workgroup.hpp" +#include "utilities/dtrace.hpp" + +#ifndef USDT2 + HS_DTRACE_PROBE_DECL4(provider, gc__collection__parnew__begin, bool, bool, size_t, bool); + HS_DTRACE_PROBE_DECL4(provider, gc__collection__parnew__end, bool, bool, size_t, bool); +#endif /* !USDT2 */ #ifdef _MSC_VER #pragma warning( push ) @@ -919,6 +925,9 @@ bool clear_all_soft_refs, size_t size, bool is_tlab) { +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__parnew__begin, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ assert(full || size > 0, "otherwise we don't want to collect"); GenCollectedHeap* gch = GenCollectedHeap::heap(); @@ -1070,6 +1079,10 @@ gch->print_heap_change(gch_prev_used); } +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__parnew__end, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ + if (PrintGCDetails && ParallelGCVerbose) { TASKQUEUE_STATS_ONLY(thread_state_set.print_termination_stats()); TASKQUEUE_STATS_ONLY(thread_state_set.print_taskqueue_stats()); diff -r b231464d6734 -r a6583ef990c2 src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp --- a/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -43,8 +43,14 @@ #include "runtime/java.hpp" #include "runtime/vmThread.hpp" #include "services/memTracker.hpp" +#include "utilities/dtrace.hpp" #include "utilities/vmError.hpp" +#ifndef USDT2 + HS_DTRACE_PROBE_DECL2(provider, gc__collection__parscavenge__heap__begin, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__parscavenge__heap__end, *uintptr_t, *uintptr_t); +#endif /* !USDT2 */ + PSYoungGen* ParallelScavengeHeap::_young_gen = NULL; PSOldGen* ParallelScavengeHeap::_old_gen = NULL; PSPermGen* ParallelScavengeHeap::_perm_gen = NULL; @@ -815,7 +821,13 @@ } VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__parscavenge__heap__begin, &op, cause); +#endif /* !USDT2 */ VMThread::execute(&op); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__parscavenge__heap__end, &op, cause); +#endif /* !USDT2 */ } // This interface assumes that it's being called by the diff -r b231464d6734 -r a6583ef990c2 src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp --- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -58,11 +58,18 @@ #include "services/management.hpp" #include "services/memoryService.hpp" #include "services/memTracker.hpp" +#include "utilities/dtrace.hpp" #include "utilities/events.hpp" #include "utilities/stack.inline.hpp" #include +#ifndef USDT2 + HS_DTRACE_PROBE_DECL2(provider, gc__collection__ParallelCompact__clear, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__parallel__collect, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL4(provider, gc__collection__move, *uintptr_t, *uintptr_t, *uintptr_t, *uintptr_t); +#endif /* !USDT2 */ + // All sizes are in HeapWords. const size_t ParallelCompactData::Log2RegionSize = 16; // 64K words const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize; @@ -469,6 +476,9 @@ void ParallelCompactData::clear() { +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__ParallelCompact__clear, &_region_data, _region_data->data_location()); +#endif /* !USDT2 */ memset(_region_data, 0, _region_vspace->committed_size()); memset(_block_data, 0, _block_vspace->committed_size()); } @@ -2011,6 +2021,9 @@ "should be in vm thread"); ParallelScavengeHeap* heap = gc_heap(); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__parallel__collect, heap, heap->gc_cause()); +#endif /* !USDT2 */ GCCause::Cause gc_cause = heap->gc_cause(); assert(!heap->is_gc_active(), "not reentrant"); @@ -3509,6 +3522,9 @@ // past the end of the partial object entering the region (if any). HeapWord* const dest_addr = sd.partial_obj_end(dp_region); HeapWord* const new_top = _space_info[space_id].new_top(); +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__move, &beg_addr, &end_addr, &dest_addr, &new_top); +#endif /* !USDT2 */ assert(new_top >= dest_addr, "bad new_top value"); const size_t words = pointer_delta(new_top, dest_addr); diff -r b231464d6734 -r a6583ef990c2 src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp --- a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -55,8 +55,17 @@ #include "runtime/vmThread.hpp" #include "runtime/vm_operations.hpp" #include "services/memoryService.hpp" +#include "utilities/dtrace.hpp" #include "utilities/stack.inline.hpp" +#ifndef USDT2 + HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSScavenge__begin, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSScavenge__end, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSParallelCompact__begin, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSParallelCompact__end, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSMarkSweep__begin, *uintptr_t, *uintptr_t); + HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSMarkSweep__end, *uintptr_t, *uintptr_t); +#endif /* !USDT2 */ HeapWord* PSScavenge::_to_space_top_before_gc = NULL; int PSScavenge::_consecutive_skipped_scavenges = 0; @@ -231,7 +240,13 @@ PSAdaptiveSizePolicy* policy = heap->size_policy(); IsGCActiveMark mark; +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__PSScavenge__begin, &heap, heap->gc_cause()); +#endif /* !USDT2 */ const bool scavenge_done = PSScavenge::invoke_no_policy(); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__PSScavenge__end, &heap, heap->gc_cause()); +#endif /* !USDT2 */ const bool need_full_gc = !scavenge_done || policy->should_full_GC(heap->old_gen()->free_in_bytes()); bool full_gc_done = false; @@ -248,9 +263,21 @@ const bool clear_all_softrefs = cp->should_clear_all_soft_refs(); if (UseParallelOldGC) { +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__PSParallelCompact__begin, &heap, heap->gc_cause()); +#endif /* !USDT2 */ full_gc_done = PSParallelCompact::invoke_no_policy(clear_all_softrefs); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__PSParallelCompact__end, &heap, heap->gc_cause()); +#endif /* !USDT2 */ } else { +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__PSMarkSweep__begin, &heap, heap->gc_cause()); +#endif /* !USDT2 */ full_gc_done = PSMarkSweep::invoke_no_policy(clear_all_softrefs); +#ifndef USDT2 + HS_DTRACE_PROBE2(hotspot, gc__collection__PSMarkSweep__end, &heap, heap->gc_cause()); +#endif /* !USDT2 */ } } diff -r b231464d6734 -r a6583ef990c2 src/share/vm/memory/defNewGeneration.cpp --- a/src/share/vm/memory/defNewGeneration.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/memory/defNewGeneration.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -42,6 +42,7 @@ #include "oops/oop.inline.hpp" #include "runtime/java.hpp" #include "utilities/copy.hpp" +#include "utilities/dtrace.hpp" #include "utilities/stack.inline.hpp" #ifdef TARGET_OS_FAMILY_linux # include "thread_linux.inline.hpp" @@ -58,7 +59,10 @@ #ifdef TARGET_OS_FAMILY_bsd # include "thread_bsd.inline.hpp" #endif - +#ifndef USDT2 + HS_DTRACE_PROBE_DECL4(provider, gc__collection__defnew__begin, bool, bool, size_t, bool); + HS_DTRACE_PROBE_DECL4(provider, gc__collection__defnew__end, bool, bool, size_t, bool); +#endif /* !USDT2 */ // // DefNewGeneration functions. @@ -537,6 +541,9 @@ bool clear_all_soft_refs, size_t size, bool is_tlab) { +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__defnew__begin, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ assert(full || size > 0, "otherwise we don't want to collect"); GenCollectedHeap* gch = GenCollectedHeap::heap(); @@ -682,6 +689,10 @@ jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC; update_time_of_last_gc(now); +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__defnew__end, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ + gch->trace_heap_after_gc(&gc_tracer); gc_tracer.report_tenuring_threshold(tenuring_threshold()); diff -r b231464d6734 -r a6583ef990c2 src/share/vm/memory/generation.cpp --- a/src/share/vm/memory/generation.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/memory/generation.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -41,8 +41,14 @@ #include "oops/oop.inline.hpp" #include "runtime/java.hpp" #include "utilities/copy.hpp" +#include "utilities/dtrace.hpp" #include "utilities/events.hpp" +#ifndef USDT2 + HS_DTRACE_PROBE_DECL4(provider, gc__collection__contig__begin, bool, bool, size_t, bool); + HS_DTRACE_PROBE_DECL4(provider, gc__collection__contig__end, bool, bool, size_t, bool); +#endif /* !USDT2 */ + Generation::Generation(ReservedSpace rs, size_t initial_size, int level) : _level(level), _ref_processor(NULL) { @@ -481,7 +487,13 @@ SerialOldTracer* gc_tracer = GenMarkSweep::gc_tracer(); gc_tracer->report_gc_start(gch->gc_cause(), gc_timer->gc_start()); +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__contig__begin, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ GenMarkSweep::invoke_at_safepoint(_level, ref_processor(), clear_all_soft_refs); +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__contig__end, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ gc_timer->register_gc_end(); diff -r b231464d6734 -r a6583ef990c2 src/share/vm/memory/tenuredGeneration.cpp --- a/src/share/vm/memory/tenuredGeneration.cpp Fri Oct 24 18:47:24 2014 +0100 +++ b/src/share/vm/memory/tenuredGeneration.cpp Wed Jun 04 15:49:42 2014 +0100 @@ -33,6 +33,12 @@ #include "memory/tenuredGeneration.hpp" #include "oops/oop.inline.hpp" #include "runtime/java.hpp" +#include "utilities/dtrace.hpp" + +#ifndef USDT2 + HS_DTRACE_PROBE_DECL4(provider, gc__collection__tenured__begin, bool, bool, size_t, bool); + HS_DTRACE_PROBE_DECL4(provider, gc__collection__tenured__end, bool, bool, size_t, bool); +#endif /* !USDT2 */ TenuredGeneration::TenuredGeneration(ReservedSpace rs, size_t initial_byte_size, int level, @@ -307,8 +313,14 @@ size_t size, bool is_tlab) { retire_alloc_buffers_before_full_gc(); +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__tenured__begin, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ OneContigSpaceCardGeneration::collect(full, clear_all_soft_refs, size, is_tlab); +#ifndef USDT2 + HS_DTRACE_PROBE4(hotspot, gc__collection__tenured__end, full, clear_all_soft_refs, size, is_tlab); +#endif /* !USDT2 */ } void TenuredGeneration::update_gc_stats(int current_level,