JEP 167: Event-Based JVM Tracing
Lukas Berk
lberk at redhat.com
Wed Oct 3 09:13:14 PDT 2012
Hey,
I've written a patch that adds dtrace style probe points to various
garbage collection events, namely:
Concurrent Mark Sweep Collections
G1 Mark Sweep Collections
ParNew Generation Collections
Parallel Scavenges
Parallel Compactions and Moves
Tenured Generation Collections
DefNew Generation Collections
I've also attached the systemtap script that I've been using on linux
for additional context.
Any objection to applying this patch?
Cheers,
Lukas
-------------- next part --------------
diff -r ede14825dbfa src/share/vm/compiler/oopMap.cpp
--- a/src/share/vm/compiler/oopMap.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/compiler/oopMap.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -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 ede14825dbfa src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -55,6 +55,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;
@@ -1647,7 +1653,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 ede14825dbfa src/share/vm/gc_implementation/g1/g1MarkSweep.cpp
--- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -45,8 +45,14 @@
#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,
@@ -84,6 +90,10 @@
// 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();
@@ -103,6 +113,10 @@
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 ede14825dbfa src/share/vm/gc_implementation/parNew/parNewGeneration.cpp
--- a/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -47,9 +47,15 @@
#include "runtime/java.hpp"
#include "runtime/thread.hpp"
#include "utilities/copy.hpp"
+#include "utilities/dtrace.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/workgroup.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 )
#pragma warning( disable:4355 ) // 'this' : used in base member initializer list
@@ -878,6 +884,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();
assert(gch->kind() == CollectedHeap::GenCollectedHeap,
@@ -1032,6 +1041,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 ede14825dbfa src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
--- a/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -40,8 +40,14 @@
#include "runtime/handles.inline.hpp"
#include "runtime/java.hpp"
#include "runtime/vmThread.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;
@@ -806,7 +812,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 ede14825dbfa src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -53,11 +53,18 @@
#include "runtime/vmThread.hpp"
#include "services/management.hpp"
#include "services/memoryService.hpp"
+#include "utilities/dtrace.hpp"
#include "utilities/events.hpp"
#include "utilities/stack.inline.hpp"
#include <math.h>
+#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 = 9; // 512 words
const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize;
@@ -432,6 +439,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());
}
@@ -1971,6 +1981,9 @@
ParallelScavengeHeap* heap = gc_heap();
GCCause::Cause gc_cause = heap->gc_cause();
assert(!heap->is_gc_active(), "not reentrant");
+#ifndef USDT2
+ HS_DTRACE_PROBE2(hotspot, gc__collection__parallel__collect, heap, heap->gc_cause());
+#endif /* !USDT2 */
PSAdaptiveSizePolicy* policy = heap->size_policy();
IsGCActiveMark mark;
@@ -3377,6 +3390,9 @@
HeapWord* const new_top = _space_info[space_id].new_top();
assert(new_top >= dest_addr, "bad new_top value");
const size_t words = pointer_delta(new_top, dest_addr);
+#ifndef USDT2
+ HS_DTRACE_PROBE4(hotspot, gc__collection__move, &beg_addr, &end_addr, &dest_addr, &new_top);
+#endif /* !USDT2 */
if (words > 0) {
ObjectStartArray* start_array = _space_info[space_id].start_array();
diff -r ede14825dbfa src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
--- a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -51,8 +51,17 @@
#include "runtime/vmThread.hpp"
#include "runtime/vm_operations.hpp"
#include "services/memoryService.hpp"
+#include "utilities/dtrace.cpp"
#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;
@@ -226,7 +235,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;
@@ -243,9 +258,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 ede14825dbfa src/share/vm/memory/defNewGeneration.cpp
--- a/src/share/vm/memory/defNewGeneration.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/memory/defNewGeneration.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -38,6 +38,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"
@@ -52,6 +53,11 @@
# 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.
@@ -528,6 +534,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();
_next_gen = gch->next_gen(this);
@@ -661,6 +670,9 @@
// does not guarantee monotonicity.
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 */
}
class RemoveForwardPointerClosure: public ObjectClosure {
diff -r ede14825dbfa src/share/vm/memory/generation.cpp
--- a/src/share/vm/memory/generation.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/memory/generation.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -39,8 +39,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) {
@@ -470,7 +476,13 @@
// refs discovery is over the entire heap, not just this generation
ReferenceProcessorSpanMutator
x(ref_processor(), GenCollectedHeap::heap()->reserved_region());
+#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 */
SpecializationStats::print();
}
diff -r ede14825dbfa src/share/vm/memory/tenuredGeneration.cpp
--- a/src/share/vm/memory/tenuredGeneration.cpp Mon Sep 24 21:55:54 2012 +0100
+++ b/src/share/vm/memory/tenuredGeneration.cpp Wed Oct 03 11:42:31 2012 -0400
@@ -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,
-------------- next part --------------
/*
* probe - gc_collect_contig_begin
*
* @name: gc_collect_contig_begin
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This marks the start of a contiguous space generation collection.
*
*/
probe hotspot.gc_collect_contig_begin =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__contig__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__contig__begin")
{
name = "gc_collect_contig_begin";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_contig_end
*
* @name: gc_collect_contig_end_
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge.
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This marks the end of a contiguous space generation collection.
*
*/
probe hotspot.gc_collect_contig_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__contig__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__contig__end")
{
name = "gc_collect_contig_end";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_parnew_begin
*
* @name: gc_collect_parnew_begin
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This marks the beginning of a parallel collection of a new
* generation.
*
*/
probe hotspot.gc_collect_parnew =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parnew__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parnew__begin")
{
name = "gc_collect_parnew_begin";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_parnew_end
*
* @name: gc_collect_parnew_end
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This marks the end of a parallel collection of a new
* generation.
*
*/
probe hotspot.gc_collect_parnew_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parnew__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parnew__end")
{
name = "gc_collect_parnew_end";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_defnew_begin
*
* @name: gc_collect_defnew_begin
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This marks the start of a newly defined generation
* collection
*
*/
probe hotspot.gc_collect_defnew_begin =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__defnew__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__defnew__begin")
{
name = "gc_collect_defnew_begin";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_defnew_end
*
* @name: gc_collect_defnew_end
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This marks the end of a newly defined generation
* collection
*
*/
probe hotspot.gc_collect_defnew_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__defnew__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__defnew__end")
{
name = "gc_collect_defnew_end";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_tenured_begin
*
* @name: gc_collect_tenured_begin
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This is the start of a collection of a tenured generation
* (a generation that has survived multiple garbage collections and is
* now in a 'tenured' object space.
*
*/
probe hotspot.gc_collect_tenured_begin =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__tenured__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__tenured__begin")
{
name = "gc_collect_tenured_begin";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_tenured_end
*
* @name: gc_collect_tenured_end
* @is_full: If TRUE, attempt a full collection of the generation.
* Else; perform a scavenge
* @size: The collection should achieve a minimum region of available
* memory to allow for an allocation of 'size'.
* @is_tlab: Is this a Thread Local Allocation Buffer?
*
* Description: This is the end of a collection of a tenured generation
* (a generation that has survived multiple garbage collections and is
* now in a 'tenured' object space.
*
*/
probe hotspot.gc_collect_tenured_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__tenured__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__tenured__end")
{
name = "gc_collect_tenured_end";
is_full = $arg2;
size = $arg3;
is_tlab = $arg4;
probestr = sprintf("%s(is_full='%d', size='%d', is_tlab='%d')", name, is_full, size, is_tlab);
}
/*
* probe - gc_collect_parallel_scavenge_heap_begin
*
* @name: gc_collect_parallel_scavenge_heap_begin
* @address: Address of region being collected.
* @cause: Cause of the collection.
*
* Description: This is a parallel heap scavenge beginning, the jvm process doesn't
* have to halt while the gc is being completed.
*/
probe hotspot.gc_collect_parallel_scavenge =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parscavenge__heap__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parscavenge__heap__begin")
{
name = "gc_collect_parallel_scavenge_heap_begin";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_parallel_scavenge_heap_end
*
* @name: gc_collect_parallel_scavenge_heap_end
* @address: Address of region being collected.
* @cause: Cause of the collection.
*
* Description: This is a parallel heap scavenge ending, the jvm process doesn't
* have to halt while the gc is being completed.
*/
probe hotspot.gc_collect_parallel_scavenge_heap_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parscavenge__heap__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parscavenge__heap__end")
{
name = "gc_collect_parallel_scavenge_heap_end";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_parallel_collect
*
* @name: gc_collect_parallel_collect
* @address: Address of object being collected.
* @cause: Cause of the collection.
*
* Description: This marks a parallel collection.
*
*/
probe hotspot.gc_collect_parallel_collect =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parallel__collect"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parallel__collect")
{
name = "gc_collect_parallel_collect";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_g1_begin
*
* @name: gc_collect_g1_begin
* @address: Address of object being collected.
* @cause: Cause of the collection.
*
* Description: This marks the start of a G1 style garbage collection
* (Garbage-First Garbage Collector).
*
*/
probe hotspot.gc_collect_g1_begin =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__G1__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__G1__begin")
{
name = "gc_collect_g1_begin";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_g1_end
*
* @name: gc_collect_g1_end
* @address: Address of object being collected.
* @cause: Cause of the collection.
*
* Description: This marks then end of a G1 style garbage collection
* (Garbage-First Garbage Collector).
*
*/
probe hotspot.gc_collect_g1_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__G1__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__G1__end")
{
name = "gc_collect_g1_end";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_delete
*
* @name: gc_collect_delete
* @address: Address of object being collected.
* @cause: Cause of the collection.
*
* Description: A delete statement of an object.
*
*/
probe hotspot.gc_collect_delete =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__delete"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__delete")
{
name = "gc_collect_delete";
address = sprintf("0x%x", $arg1);
probestr = sprintf("%s(address='%s')", name, address);
}
/*
* probe - gc_collect_PSScavenge_begin
*
* @name: gc_collect_PSScavenge_begin
* @address: Address of scavenge
* @cause: Cause of the collection.
*
* Description: A parallel scavenge begins. A scavenge is a partial garbage
* collection which should be much more common than a full garbage collection
* throughout the course of the java program.
*
*/
probe hotspot.gc_collect_PSScavenge_begin =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSScavenge__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSScavenge__begin")
{
name = "gc_collect_PSScavenge_begin";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_PSScavenge_end
*
* @name: gc_collect_PSScavenge_end
* @address: Address of scavenge.
* @cause: Cause of the collection.
*
* Description: The end of the parallel scavenge. The beginning and end of
* the scavenge is noted due to the possbility of multiple scavenges occuring
* at the same time.
*
*/
probe hotspot.gc_collect_PSScavenge_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSScavenge__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSScavenge__end")
{
name = "gc_collect_PSScavenge_end";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_PSParallelCompact_begin
*
* @name: gc_collect_PSParallelCompact_begin
* @address: Address of compaction.
* @cause: Cause of the collection.
*
* Description: This marks the start of a parallel compaction.
*
*/
probe hotspot.gc_collect_PSParallelCompact_begin =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSParallelCompact__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSParallelCompact__begin")
{
name = "gc_collect_PSParallelCompact_begin";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_PSParallelCompact_end
*
* @name: gc_collect_PSParallelCompact_end
* @address: Address of compaction.
* @cause: Cause of the collection.
*
* Description: This marks the end of a parallel compaction.
*
*/
probe hotspot.gc_collect_PSParallelCompact_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSParallelCompact__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSParallelCompact__end")
{
name = "gc_collect_PSParallelCompact_end";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_PSMarkSweep_begin
*
* @name: gc_collect_PSMarkSweep_begin
* @address: Address of parallel mark sweep process.
* @cause: Cause of the collection.
*
* Description: This marks the start of a parallel mark sweep for
* objects that require collection.
*
*/
probe hotspot.gc_collect_PSMarkSweep_begin =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__begin"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__begin")
{
name = "gc_collect_PSMarkSweep_begin";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_PSMarkSweep_end
*
* @name: gc_collect_PSMarkSweep_end
* @address: Address of parallel mark sweep process.
* @cause: Cause of the collection.
*
* Description: This marks the start of a parallel mark sweep for
* objects that require collection.
*
*/
probe hotspot.gc_collect_PSMarkSweep_end =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__end"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__end")
{
name = "gc_collect_PSMarkSweep_end";
address = sprintf("0x%x", $arg1);
cause = $arg2;
probestr = sprintf("%s(address='%s', cause='%d')", name, address, cause);
}
/*
* probe - gc_collect_move
*
* @name: gc_collect_move
* @from_bottom_address: The bottom address of the object being moved.
* @from_top_address: The top address of the object being moved.
* @to_bottom_address: The bottom address of where the object is being moved to.
* @to_top_address: The top address of where the object is being moved to.
* @cause: Cause of the collection.
*
* Description: During garbage collections there are times where objects or
* blocks of memory need to be moved. This probe will detail from where
* the memory is moving and where to.
*
*/
probe hotspot.gc_collect_move =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__move"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__move")
{
name = "gc_collect_move";
from_bottom_address = sprintf("0x%x", $arg1);
from_top_address = sprintf("0x%x", $arg2);
to_bottom_address = sprintf("0x%x", $arg3);
to_top_address = sprintf("0x%x", $arg4);
probestr = sprintf("%s(from_bottom_address='%s', from_top_address='%s', to_bottom_address='%s', to_top_address='%s')", name, from_bottom_address, from_top_address, to_bottom_address, to_top_address);
}
/*
* probe - gc_collect_clear
*
* @name: gc_collect_clear
* @address: Address of object being collected.
* @cause: Cause of the collection.
*
* Description: This probe dictates the region of data that needs to be
* cleared in a compaction action.
*
*/
probe hotspot.gc_collect_clear =
process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__ParallelCompact__clear"),
process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__ParallelCompact__clear")
{
name = "gc_collect_clear";
region_data = sprintf("0x%x", $arg1);
data_location = sprintf("0x%x", $arg2);
probestr = sprintf("%s(region_data='%s', data_location='%s')", name, region_data, data_location);
}
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 836 bytes
Desc: not available
Url : http://mail.openjdk.java.net/pipermail/serviceability-dev/attachments/20121003/4c3c97cf/attachment-0001.bin
More information about the serviceability-dev
mailing list