From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 8094 invoked by alias); 22 Aug 2012 20:34:44 -0000 Received: (qmail 4934 invoked by uid 22791); 22 Aug 2012 20:34:09 -0000 X-SWARE-Spam-Status: No, hits=-7.7 required=5.0 tests=AWL,BAYES_50,KHOP_PGP_SIGNED,KHOP_RCVD_UNTRUST,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,RP_MATCHES_RCVD,SPF_HELO_PASS X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 22 Aug 2012 20:33:36 +0000 Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q7MKXEBi002745 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 22 Aug 2012 16:33:14 -0400 Received: from redhat.com (vpn-239-212.phx2.redhat.com [10.3.239.212]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id q7MKX9iR025586 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NO); Wed, 22 Aug 2012 16:33:11 -0400 Date: Wed, 22 Aug 2012 20:34:00 -0000 From: Lukas Berk To: distro-pkg-dev@openjdk.java.net Cc: systemtap@sourceware.org Subject: Re: [RFC] Enhanced Garbage Collection Probe Points Message-ID: <20120822203308.GA7445@redhat.com> Reply-To: Lukas Berk References: <20120802131039.GA1955@redhat.com> MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha1; protocol="application/pgp-signature"; boundary="JP+T4n/bALQSJXh8" Content-Disposition: inline In-Reply-To: <20120802131039.GA1955@redhat.com> User-Agent: Mutt/1.5.21 (2010-09-15) X-IsSubscribed: yes Mailing-List: contact systemtap-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Post: List-Help: , Sender: systemtap-owner@sourceware.org X-SW-Source: 2012-q3/txt/msg00235.txt.bz2 --JP+T4n/bALQSJXh8 Content-Type: multipart/mixed; boundary="0OAP2g/MAC+5xKAE" Content-Disposition: inline --0OAP2g/MAC+5xKAE Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-Transfer-Encoding: quoted-printable Content-length: 16488 Hey list, I've updated and attached my patch to reflect the comments made in=20 the thread above, primarily: - split begin and end probe points where possible - correct probe point names - include and autoconf version of the tapset for immediate inclusion I've also run the DaCapo benchmarking suite[1] and have attached the results below. In order to properly judge the performance effects (if any) my probe points have had on hotspot, I ran three different sets of tests (using the eclipse benchmark). First, with icedtea configured using --disable-systemtap, then configured with systemtap and no probes run, and finally with the gc probes in use with a basic log(probestr) systemtap script. (ie $stap -ve 'probe hotspot.gc_* {log(probestr)}' -c "java -jar dacapo-9.12-bach.jar eclise -n 10". I ran each test 4 times to get a better sample size. --disable-systemtap: run 1: 44119 msec run 2: 43255 msec run 3: 44517 msec run 4: 44017 msec -------------------- avg: 43977 msec --enable-systemtap but not used: run 1: 44987 msec run 2: 47154 msec run 3: 48099 msec run 4: 41069 msec -------------------- avg: 45327 msec --enable-systemtap and used: run 1: 47538 msec run 2: 43264 msec run 3: 40396 msec run 4: 44422 msec -------------------- avg: 43905 msec Considering that the probe points seem to have relatively little impact on the benchmarking results and the interest in my patch, what else needs to be done to get this patch applied to icedtea? Cheers, Lukas [1] http://dacapobench.org * Lukas Berk [2012-08-02 09:11]: > Hey, >=20 > I've been working on adding improved probe point within the garbage > collection system. This will allow system administrators using various > tools to better analyze which garbage collection algorithms are > effective and java developers to better understand how (often) their > objects are being collected. >=20 > Specific probe points that I've aimed to include are: >=20 > - G1, concurrent mark sweep, parallel mark sweep, and tenured > collections >=20 > - new generation definitions >=20 > - parallel scavenges >=20 > - parallel compaction >=20 > - object 'moves/resizes' between memory addresses >=20 > Please note that the attached patch should be appended to the > patch/systemtap.patch file. Any feedback or suggestions would be > greatly appreciated. >=20 > Cheers, >=20 > Lukas > diff -Nru openjdk.orig/hotspot/src/share/vm/memory/generation.cpp openjdk= /hotspot/src/share/vm/memory/generation.cpp > --- openjdk.orig/hotspot/src/share/vm/memory/generation.cpp 2012-06-15 11= :36:43.022837742 -0400 > +++ openjdk/hotspot/src/share/vm/memory/generation.cpp 2012-06-15 13:35:3= 9.714838057 -0400 > @@ -40,6 +40,11 @@ > #include "runtime/java.hpp" > #include "utilities/copy.hpp" > #include "utilities/events.hpp" > +#include "utilities/dtrace.hpp" > + > +#ifndef USDT2 > + HS_DTRACE_PROBE_DECL4(provider, gc__collection__contig, bool, bool, si= ze_t, bool); > +#endif /* !USDT2 */ >=20=20 > Generation::Generation(ReservedSpace rs, size_t initial_size, int level)= : > _level(level), > @@ -471,6 +476,9 @@ > ReferenceProcessorSpanMutator > x(ref_processor(), GenCollectedHeap::heap()->reserved_region()); > GenMarkSweep::invoke_at_safepoint(_level, ref_processor(), clear_all_s= oft_refs); > +#ifndef USDT2 > + HS_DTRACE_PROBE4(hotspot, gc__collection__contig, full, clear_all_soft= _refs, size, is_tlab); > +#endif /* !USDT2 */ > SpecializationStats::print(); > } >=20=20 > diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/concurrentM= arkSweep/concurrentMarkSweepGeneration.cpp openjdk/hotspot/src/share/vm/gc_= implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp > --- openjdk.orig/hotspot/src/share/vm/gc_implementation/concurrentMarkSwe= ep/concurrentMarkSweepGeneration.cpp 2012-06-15 11:36:42.164837741 -0400 > +++ openjdk/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/co= ncurrentMarkSweepGeneration.cpp 2012-06-15 13:35:45.224838227 -0400 > @@ -55,6 +55,11 @@ > #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, bool, bool, si= ze_t, bool); > +#endif /* !USDT2 */ >=20=20 > // statics > CMSCollector* ConcurrentMarkSweepGeneration::_collector =3D NULL; > @@ -1655,6 +1660,10 @@ > size_t size, > bool tlab) > { > + > +#ifndef USDT2 > + HS_DTRACE_PROBE4(hotspot, gc__collection__contig, full, clear_all_soft= _refs, size, tlab); > +#endif /* !USDT2 */ > if (!UseCMSCollectionPassing && _collectorState > Idling) { > // For debugging purposes skip the collection if the state > // is not currently idle > diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/parNew/parN= ewGeneration.cpp openjdk/hotspot/src/share/vm/gc_implementation/parNew/parN= ewGeneration.cpp > --- openjdk.orig/hotspot/src/share/vm/gc_implementation/parNew/parNewGene= ration.cpp 2012-06-15 11:36:41.816837741 -0400 > +++ openjdk/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneratio= n.cpp 2012-06-15 13:35:56.298821181 -0400 > @@ -49,6 +49,11 @@ > #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, bool, bool, si= ze_t, bool); > +#endif /* !USDT2 */ >=20=20 > #ifdef _MSC_VER > #pragma warning( push ) > @@ -878,6 +883,9 @@ > bool clear_all_soft_refs, > size_t size, > bool is_tlab) { > +#ifndef USDT2 > + HS_DTRACE_PROBE4(hotspot, gc__collection__parnew, full, clear_all_soft= _refs, size, is_tlab); > +#endif /* !USDT2 */ > assert(full || size > 0, "otherwise we don't want to collect"); > GenCollectedHeap* gch =3D GenCollectedHeap::heap(); > assert(gch->kind() =3D=3D CollectedHeap::GenCollectedHeap, > diff -Nru openjdk.orig/hotspot/src/share/vm/memory/defNewGeneration.cpp o= penjdk/hotspot/src/share/vm/memory/defNewGeneration.cpp > --- openjdk.orig/hotspot/src/share/vm/memory/defNewGeneration.cpp 2012-06= -15 11:36:42.970837742 -0400 > +++ openjdk/hotspot/src/share/vm/memory/defNewGeneration.cpp 2012-06-15 1= 3:36:05.328838805 -0400 > @@ -39,6 +39,11 @@ > #include "runtime/java.hpp" > #include "utilities/copy.hpp" > #include "utilities/stack.inline.hpp" > +#include "utilities/dtrace.hpp" > + > +#ifndef USDT2 > + HS_DTRACE_PROBE_DECL4(provider, gc__collection__defnew, bool, bool, si= ze_t, bool); > +#endif /* !USDT2 */ > #ifdef TARGET_OS_FAMILY_linux > # include "thread_linux.inline.hpp" > #endif > @@ -528,6 +533,9 @@ > bool clear_all_soft_refs, > size_t size, > bool is_tlab) { > +#ifndef USDT2 > + HS_DTRACE_PROBE4(hotspot, gc__collection__defnew, full, clear_all_soft= _refs, size, is_tlab); > +#endif /* !USDT2 */ > assert(full || size > 0, "otherwise we don't want to collect"); > GenCollectedHeap* gch =3D GenCollectedHeap::heap(); > _next_gen =3D gch->next_gen(this); > diff -Nru openjdk.orig/hotspot/src/share/vm/memory/tenuredGeneration.cpp = openjdk/hotspot/src/share/vm/memory/tenuredGeneration.cpp > --- openjdk.orig/hotspot/src/share/vm/memory/tenuredGeneration.cpp 2012-0= 6-15 11:36:43.016837742 -0400 > +++ openjdk/hotspot/src/share/vm/memory/tenuredGeneration.cpp 2012-06-15 = 13:36:08.848839364 -0400 > @@ -33,6 +33,11 @@ > #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, bool, bool, s= ize_t, bool); > +#endif /* !USDT2 */ >=20=20 > TenuredGeneration::TenuredGeneration(ReservedSpace rs, > size_t initial_byte_size, int level, > @@ -307,6 +312,9 @@ > size_t size, > bool is_tlab) { > retire_alloc_buffers_before_full_gc(); > +#ifndef USDT2 > + HS_DTRACE_PROBE4(hotspot, gc__collection__tenured, full, clear_all_sof= t_refs, size, is_tlab); > +#endif /* !USDT2 */ > OneContigSpaceCardGeneration::collect(full, clear_all_soft_refs, > size, is_tlab); > } > diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelSca= venge/parallelScavengeHeap.cpp openjdk/hotspot/src/share/vm/gc_implementati= on/parallelScavenge/parallelScavengeHeap.cpp > --- openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScavenge/= parallelScavengeHeap.cpp > +++ openjdk/hotspot/src/share/vm/gc_implementation/parallelScavenge/paral= lelScavengeHeap.cpp > @@ -40,8 +40,13 @@ > #include "runtime/handles.inline.hpp" > #include "runtime/java.hpp" > #include "runtime/vmThread.hpp" > +#include "utilities/dtrace.hpp" > #include "utilities/vmError.hpp" >=20=20 > +#ifndef USDT2 > + HS_DTRACE_PROBE_DECL2(provider, gc__collection__parscavenge, *uintptr_= t, *uintptr_t); > +#endif /* !USDT2 */ > + > PSYoungGen* ParallelScavengeHeap::_young_gen =3D NULL; > PSOldGen* ParallelScavengeHeap::_old_gen =3D NULL; > PSPermGen* ParallelScavengeHeap::_perm_gen =3D NULL; > @@ -806,6 +811,9 @@ > } >=20=20 > VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause); > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__parscavenge, &op, cause); > +#endif /* !USDT2 */ > VMThread::execute(&op); > } >=20 > diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/g1/g1MarkSw= eep.cpp openjdk/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp > --- openjdk.orig/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cp= p 2012-06-26 09:24:22.472325287 -0400 > +++ openjdk/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp 201= 2-07-05 10:43:08.273800575 -0400 > @@ -45,8 +45,13 @@ > #include "runtime/thread.hpp" > #include "runtime/vmThread.hpp" > #include "utilities/copy.hpp" > +#include "utilities/dtrace.hpp" > #include "utilities/events.hpp" >=20=20 > +#ifndef USDT2 > + HS_DTRACE_PROBE_DECL2(provider, gc__collection__G1, *uintptr_t, *uintp= tr_t); > +#endif /* !USDT2 */ > + > class HeapRegion; >=20=20 > void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, > @@ -83,7 +88,9 @@ > // We should save the marks of the currently locked biased monitors. > // The marking doesn't preserve the marks of biased objects. > BiasedLocking::preserve_marks(); > - > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__G1, &sh, sh->gc_cause()); > +#endif /* !USDT2 */ > mark_sweep_phase1(marked_for_unloading, clear_all_softrefs); >=20=20 > mark_sweep_phase2(); > diff -Nru openjdk.orig/hotspot/src/share/vm/compiler/oopMap.cpp openjdk/h= otspot/src/share/vm/compiler/oopMap.cpp > --- openjdk.orig/hotspot/src/share/vm/compiler/oopMap.cpp 2012-06-26 09:2= 4:22.390325184 -0400 > +++ openjdk/hotspot/src/share/vm/compiler/oopMap.cpp 2012-07-06 10:12:44.= 981413003 -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 */ >=20=20 > // OopMapStream >=20=20 > @@ -677,6 +681,9 @@ > " - Derived: " INTPTR_FORMAT " Base: " INTPTR_FORMA= T " (Offset: %d)", > derived_loc, (address)*derived_loc, (address)base, offset); > } > +#ifndef USDT2 > + HS_DTRACE_PROBE1(hotspot, gc__collection__delete, entry); > +#endif /* !USDT2 */ >=20=20 > // Delete entry > delete entry; > --- openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScavenge/= psParallelCompact.cpp 2012-07-12 09:48:40.349999515 -0400 > +++ openjdk/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPar= allelCompact.cpp 2012-07-19 18:38:07.560757426 -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" >=20=20 > #include >=20=20 > +#ifndef USDT2 > + HS_DTRACE_PROBE_DECL2(provider, gc__collection__ParallelCompact__clear= , *uintptr_t, *uintptr_t); > + HS_DTRACE_PROBE_DECL2(provider, gc__collection__partest1, *uintptr_t, = *uintptr_t); > + HS_DTRACE_PROBE_DECL4(provider, gc__collection__move, *uintptr_t, *uin= tptr_t, *uintptr_t, *uintptr_t); > +#endif /* !USDT2 */ > + > // All sizes are in HeapWords. > const size_t ParallelCompactData::Log2RegionSize =3D 9; // 512 words > const size_t ParallelCompactData::RegionSize =3D (size_t)1 << Log2R= egionSize; > @@ -433,6 +439,9 @@ >=20=20 > void ParallelCompactData::clear() > { > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__ParallelCompact__clear, &_re= gion_data, _region_data->data_location()); > +#endif /* !USDT2 */ > memset(_region_data, 0, _region_vspace->committed_size()); > } >=20=20 > @@ -1970,6 +1979,9 @@ > "should be in vm thread"); >=20=20 > ParallelScavengeHeap* heap =3D gc_heap(); > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__partest1, heap, heap->gc_cau= se()); > +#endif /* !USDT2 */ > GCCause::Cause gc_cause =3D heap->gc_cause(); > assert(!heap->is_gc_active(), "not reentrant"); >=20=20 > @@ -3376,6 +3388,9 @@ > // past the end of the partial object entering the region (if any). > HeapWord* const dest_addr =3D sd.partial_obj_end(dp_region); > HeapWord* const new_top =3D _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 >=3D dest_addr, "bad new_top value"); > const size_t words =3D pointer_delta(new_top, dest_addr); >=20=20 > --- openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScavenge/= psScavenge.cpp 2012-07-12 09:48:40.401000822 -0400 > +++ openjdk/hotspot/src/share/vm/gc_implementation/parallelScavenge/psSca= venge.cpp 2012-07-19 18:36:43.787767399 -0400 > @@ -51,8 +51,12 @@ > #include "runtime/vmThread.hpp" > #include "runtime/vm_operations.hpp" > #include "services/memoryService.hpp" > +#include "utilities/dtrace.hpp" > #include "utilities/stack.inline.hpp" >=20=20 > +#ifndef USDT2 > + HS_DTRACE_PROBE_DECL2(provider, name, *uintptr_t, *uintptr_t); > +#endif /* !USDT2 */ >=20=20 > HeapWord* PSScavenge::_to_space_top_before_gc =3D NULL; > int PSScavenge::_consecutive_skipped_scavenges = =3D 0; > @@ -226,7 +230,13 @@ > PSAdaptiveSizePolicy* policy =3D heap->size_policy(); > IsGCActiveMark mark; >=20=20 > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__PSScavenge__begin, *heap, he= ap->gc_cause()); > +#endif /* !USDT2 */ > const bool scavenge_done =3D 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 =3D !scavenge_done || > policy->should_full_GC(heap->old_gen()->free_in_bytes()); > bool full_gc_done =3D false; > @@ -243,9 +253,27 @@ > const bool clear_all_softrefs =3D cp->should_clear_all_soft_refs(); >=20=20 > if (UseParallelOldGC) { > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__PSParallelCompact__begin, *h= eap, heap->gc_cause());=20 > +#endif /* !USDT2 */ > + > full_gc_done =3D PSParallelCompact::invoke_no_policy(clear_all_sof= trefs); > + > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__PSParallelCompact__end, *hea= p, heap->gc_cause()); > +#endif /* !USDT2 */ > + > } else { > + > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__PSMarkSweep__begin, *heap, h= eap->gc_cause()); > +#endif /* !USDT2 */ > + > full_gc_done =3D PSMarkSweep::invoke_no_policy(clear_all_softrefs); > + > +#ifndef USDT2 > + HS_DTRACE_PROBE2(hotspot, gc__collection__PSMarkSweep__end, *heap, hea= p->gc_cause()); > +#endif /* !USDT2 */ > } > } >=20=20 --0OAP2g/MAC+5xKAE Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="icedtea.patch" Content-Transfer-Encoding: quoted-printable Content-length: 35463 diff -r 60bd733bd20c Makefile.am --- a/Makefile.am Thu Aug 16 01:07:29 2012 +0100 +++ b/Makefile.am Wed Aug 22 16:32:18 2012 -0400 @@ -747,6 +747,7 @@ tapset/hotspot.stp.in \ tapset/hotspot_jni.stp.in \ tapset/jstack.stp.in \ + tapset/gc_details.stp.in \ scripts/jni_create_stap.c \ scripts/jni_desc \ rewriter/agpl-3.0.txt \ @@ -1713,11 +1714,16 @@ sed -e '/\/client\/libjvm.so/d' \ < $(abs_top_builddir)/tapset/hotspot_jni.stp \ > $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_jni.stp; \ + sed -e '/\/client\/libjvm.so/d' \ + < $(abs_top_builddir)/tapset/gc_details.stp \ + > $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/gc_details.stp; \ else \ cp $(abs_top_builddir)/tapset/hotspot.stp \ $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot.stp; \ cp $(abs_top_builddir)/tapset/hotspot_jni.stp \ $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_jni.stp; \ + cp $(abs_top_builddir)/tapset/gc_details.stp \ + $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/gc_details.stp; \ fi; \ cp $(abs_top_builddir)/tapset/jstack.stp \ $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/jstack.stp @@ -1779,11 +1785,16 @@ sed -e '/\/client\/libjvm.so/d' \ < $(abs_top_builddir)/tapset/hotspot_jni.stp \ > $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_jni.stp; \ + sed -e '/\/client\/libjvm.so/d' \ + < $(abs_top_builddir)/tapset/gc_details.stp \ + > $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/gc_details.stp; \ else \ cp $(abs_top_builddir)/tapset/hotspot.stp \ $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot.stp; \ cp $(abs_top_builddir)/tapset/hotspot_jni.stp \ $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_jni.stp; \ + cp $(abs_top_builddir)/tapset/gc_details.stp \ + $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/gc_details.stp; \ fi; \ cp $(abs_top_builddir)/tapset/jstack.stp \ $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/jstack.stp diff -r 60bd733bd20c configure.ac --- a/configure.ac Thu Aug 16 01:07:29 2012 +0100 +++ b/configure.ac Wed Aug 22 16:32:18 2012 -0400 @@ -313,6 +313,7 @@ AC_CONFIG_FILES([tapset/hotspot.stp]) AC_CONFIG_FILES([tapset/hotspot_jni.stp]) AC_CONFIG_FILES([tapset/jstack.stp]) + AC_CONFIG_FILES([tapset/gc_details.stp]) fi =20 dnl Check for libXtst headers and libraries. diff -r 60bd733bd20c patches/systemtap.patch --- a/patches/systemtap.patch Thu Aug 16 01:07:29 2012 +0100 +++ b/patches/systemtap.patch Wed Aug 22 16:32:18 2012 -0400 @@ -138,3 +138,375 @@ =20=20 #endif /* !USDT2 */ =20=20 +diff -Nru openjdk.orig/hotspot/src/share/vm/compiler/oopMap.cpp openjdk/ho= tspot/src/share/vm/compiler/oopMap.cpp +--- openjdk.orig/hotspot/src/share/vm/compiler/oopMap.cpp 2012-06-26 09:24= :22.390325184 -0400 ++++ openjdk/hotspot/src/share/vm/compiler/oopMap.cpp 2012-07-06 10:12:44.9= 81413003 -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 */ +=20 + // OopMapStream +=20 +@@ -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 */ +=20 + // Delete entry + delete entry; +--- openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScavenge/p= sParallelCompact.cpp 2012-07-12 09:48:40.349999515 -0400 ++++ openjdk/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPara= llelCompact.cpp 2012-07-19 18:38:07.560757426 -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" +=20 + #include +=20 ++#ifndef USDT2 ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__ParallelCompact__clear,= *uintptr_t, *uintptr_t); ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__parallel__collect, *uin= tptr_t, *uintptr_t); ++ HS_DTRACE_PROBE_DECL4(provider, gc__collection__move, *uintptr_t, *uint= ptr_t, *uintptr_t, *uintptr_t); ++#endif /* !USDT2 */ ++ + // All sizes are in HeapWords. + const size_t ParallelCompactData::Log2RegionSize =3D 9; // 512 words + const size_t ParallelCompactData::RegionSize =3D (size_t)1 << Log2Re= gionSize; +@@ -433,6 +439,9 @@ +=20 + void ParallelCompactData::clear() + { ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__ParallelCompact__clear, &_reg= ion_data, _region_data->data_location()); ++#endif /* !USDT2 */ + memset(_region_data, 0, _region_vspace->committed_size()); + } +=20 +@@ -1970,6 +1979,9 @@ + "should be in vm thread"); +=20 + ParallelScavengeHeap* heap =3D gc_heap(); ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__parallel__collect, heap, heap= ->gc_cause()); ++#endif /* !USDT2 */ + GCCause::Cause gc_cause =3D heap->gc_cause(); + assert(!heap->is_gc_active(), "not reentrant"); +=20 +@@ -3376,6 +3388,9 @@ + // past the end of the partial object entering the region (if any). + HeapWord* const dest_addr =3D sd.partial_obj_end(dp_region); + HeapWord* const new_top =3D _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 >=3D dest_addr, "bad new_top value"); + const size_t words =3D pointer_delta(new_top, dest_addr); +=20 +diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/g1/g1MarkSwe= ep.cpp openjdk/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp +--- openjdk.orig/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp= 2012-08-15 12:04:43.837439833 -0400 ++++ openjdk/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp 2012= -08-15 12:01:47.897745719 -0400 +@@ -45,8 +45,13 @@ + #include "runtime/thread.hpp" + #include "runtime/vmThread.hpp" + #include "utilities/copy.hpp" ++#include "utilities/dtrace.hpp" + #include "utilities/events.hpp" +=20 ++#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, *u= intptr_t); ++ #endif /* !USDT2 */=20 + class HeapRegion; +=20 + void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp, +@@ -84,6 +89,9 @@ + // The marking doesn't preserve the marks of biased objects. + BiasedLocking::preserve_marks(); +=20 ++#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); +=20 + mark_sweep_phase2(); +@@ -103,6 +111,9 @@ + GenRemSet* rs =3D sh->rem_set(); + rs->invalidate(sh->perm_gen()->used_region(), true /*whole_heap*/); +=20 ++#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 -Nru openjdk.orig/hotspot/src/share/vm/memory/tenuredGeneration.cpp o= penjdk/hotspot/src/share/vm/memory/tenuredGeneration.cpp=20 +--- openjdk.orig/hotspot/src/share/vm/memory/tenuredGeneration.cpp 2012-08= -15 12:03:43.009543167 -0400 ++++ openjdk/hotspot/src/share/vm/memory/tenuredGeneration.cpp 2012-08-15 1= 2:14:25.414381449 -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, b= ool, size_t, bool); ++ HS_DTRACE_PROBE_DECL4(provider, gc__collection__tenured__end, bool, boo= l, size_t, bool); ++#endif /* !USDT2 */ +=20 + 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_a= ll_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 */ + } +=20 + void TenuredGeneration::update_gc_stats(int current_level, +diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/parNew/parNe= wGeneration.cpp openjdk/hotspot/src/share/vm/gc_implementation/parNew/parNe= wGeneration.cpp +--- openjdk.orig/hotspot/src/share/vm/gc_implementation/parNew/parNewGener= ation.cpp 2012-08-15 12:03:43.039543116 -0400 ++++ openjdk/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration= .cpp 2012-08-15 12:18:57.181932342 -0400 +@@ -49,6 +49,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, bo= ol, size_t, bool); ++ HS_DTRACE_PROBE_DECL4(provider, gc__collection__parnew__end, bool, bool= , size_t, bool); ++#endif /* !USDT2 */ +=20 + #ifdef _MSC_VER + #pragma warning( push ) +@@ -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_al= l_soft_refs, size, is_tlab); ++#endif /* !USDT2 */ + assert(full || size > 0, "otherwise we don't want to collect"); + GenCollectedHeap* gch =3D GenCollectedHeap::heap(); + assert(gch->kind() =3D=3D CollectedHeap::GenCollectedHeap, +@@ -1032,6 +1041,10 @@ + gch->print_heap_change(gch_prev_used); + } +=20 ++#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 -Nru openjdk.orig/hotspot/src/share/vm/memory/defNewGeneration.cpp op= enjdk/hotspot/src/share/vm/memory/defNewGeneration.cpp +--- openjdk.orig/hotspot/src/share/vm/memory/defNewGeneration.cpp 2012-08-= 15 12:03:43.010543164 -0400 ++++ openjdk/hotspot/src/share/vm/memory/defNewGeneration.cpp 2012-08-15 12= :21:41.076673646 -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" +@@ -51,7 +52,10 @@ + #ifdef TARGET_OS_FAMILY_bsd + # include "thread_bsd.inline.hpp" + #endif +- ++#ifndef USDT2 ++ HS_DTRACE_PROBE_DECL4(provider, gc__collection__defnew__begin, bool, bo= ol, size_t, bool); ++ HS_DTRACE_PROBE_DECL4(provider, gc__collection__defnew__end, bool, bool= , size_t, bool); ++#endif /* !USDT2 */ + // + // DefNewGeneration functions. +=20 +@@ -528,6 +532,9 @@ + bool clear_all_soft_refs, + size_t size, + bool is_tlab) { ++#ifndef USDT2 ++ HS_DTRACE_PROBE4(hotspot, gc__collection__defnew__begin, full, clear_al= l_soft_refs, size, is_tlab); ++#endif /* !USDT2 */ + assert(full || size > 0, "otherwise we don't want to collect"); + GenCollectedHeap* gch =3D GenCollectedHeap::heap(); + _next_gen =3D gch->next_gen(this); +@@ -661,6 +668,10 @@ + // does not guarantee monotonicity. + jlong now =3D 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 */ ++ + } +=20 + class RemoveForwardPointerClosure: public ObjectClosure { +diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/concurrentMa= rkSweep/concurrentMarkSweepGeneration.cpp openjdk/hotspot/src/share/vm/gc_i= mplementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp +--- openjdk.orig/hotspot/src/share/vm/gc_implementation/concurrentMarkSwee= p/concurrentMarkSweepGeneration.cpp 2012-08-15 12:03:43.044543106 -0400 ++++ openjdk/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/con= currentMarkSweepGeneration.cpp 2012-08-15 12:25:26.632316692 -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, bo= ol, size_t, bool); ++ HS_DTRACE_PROBE_DECL4(provider, gc__collection__contig__end, bool, bool= , size_t, bool); ++#endif /* !USDT2 */ +=20 + // statics + CMSCollector* ConcurrentMarkSweepGeneration::_collector =3D NULL; +@@ -1647,7 +1653,13 @@ + size_t size, + bool tlab) + { ++#ifndef USDT2 ++ HS_DTRACE_PROBE4(hotspot, gc__collection__contig__begin, full, clear_al= l_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 */ + } +=20 + void CMSCollector::collect(bool full, +diff -Nru openjdk.orig/hotspot/src/share/vm/memory/generation.cpp openjdk/= hotspot/src/share/vm/memory/generation.cpp +--- openjdk.orig/hotspot/src/share/vm/memory/generation.cpp 2012-08-15 12:= 03:43.009543167 -0400 ++++ openjdk/hotspot/src/share/vm/memory/generation.cpp 2012-08-15 12:27:46= .378095083 -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" +=20 ++#ifndef USDT2 ++ HS_DTRACE_PROBE_DECL4(provider, gc__collection__contig__begin, bool, bo= ol, 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_al= l_soft_refs, size, is_tlab); ++#endif /* !USDT2 */ + GenMarkSweep::invoke_at_safepoint(_level, ref_processor(), clear_all_so= ft_refs); ++#ifndef USDT2 ++ HS_DTRACE_PROBE4(hotspot, gc__collection__contig__end, full, clear_all_= soft_refs, size, is_tlab); ++#endif /* !USDT2 */ + SpecializationStats::print(); + } +=20 +--- openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScavenge/p= arallelScavengeHeap.cpp 2012-08-15 12:03:43.046543102 -0400 ++++ openjdk/hotspot/src/share/vm/gc_implementation/parallelScavenge/parall= elScavengeHeap.cpp 2012-08-15 12:53:47.762647059 -0400 +@@ -40,8 +40,13 @@ + #include "runtime/handles.inline.hpp" + #include "runtime/java.hpp" + #include "runtime/vmThread.hpp" ++#include "utilities/dtrace.hpp" + #include "utilities/vmError.hpp" +=20 ++#ifndef USDT2 ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__parscavenge, *uintptr_t= , *uintptr_t); ++#endif /* !USDT2 */ ++ + PSYoungGen* ParallelScavengeHeap::_young_gen =3D NULL; + PSOldGen* ParallelScavengeHeap::_old_gen =3D NULL; + PSPermGen* ParallelScavengeHeap::_perm_gen =3D NULL; +@@ -806,6 +811,9 @@ + } +=20 + VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause); ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__parscavenge, &op, cause); ++#endif /* !USDT2 */ + VMThread::execute(&op); + } +=20 +diff -Nru openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScav= enge/psScavenge.cpp openjdk/hotspot/src/share/vm/gc_implementation/parallel= Scavenge/psScavenge.cpp +--- openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScavenge/p= sScavenge.cpp 2012-07-25 13:24:07.000000000 -0400 ++++ openjdk/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScav= enge.cpp 2012-08-17 10:26:44.181117802 -0400 +@@ -51,8 +51,17 @@ + #include "runtime/vmThread.hpp" + #include "runtime/vm_operations.hpp" + #include "services/memoryService.hpp" ++#include "utilities/dtrace.hpp" + #include "utilities/stack.inline.hpp" +=20 ++#ifndef USDT2 ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSScavenge__begin, *uin= tptr_t, *uintptr_t); ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSScavenge__end, *uintp= tr_t, *uintptr_t); ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSParallelCompact__begi= n, *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, *ui= ntptr_t, *uintptr_t); ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__PSMarkSweep__end, *uint= ptr_t, *uintptr_t); ++#endif /* !USDT2 */ +=20 + HeapWord* PSScavenge::_to_space_top_before_gc =3D NULL; + int PSScavenge::_consecutive_skipped_scavenges =3D= 0; +@@ -226,7 +235,13 @@ + PSAdaptiveSizePolicy* policy =3D heap->size_policy(); + IsGCActiveMark mark; +=20 ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__PSScavenge__begin, *heap, hea= p->gc_cause()); ++#endif /* !USDT2 */ + const bool scavenge_done =3D 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 =3D !scavenge_done || + policy->should_full_GC(heap->old_gen()->free_in_bytes()); + bool full_gc_done =3D false; +@@ -243,9 +258,21 @@ + const bool clear_all_softrefs =3D cp->should_clear_all_soft_refs(); +=20 + if (UseParallelOldGC) { ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__PSParallelCompact__begin, *he= ap, heap->gc_cause());=20 ++#endif /* !USDT2 */ + full_gc_done =3D PSParallelCompact::invoke_no_policy(clear_all_soft= refs); ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__PSParallelCompact__end, *heap= , heap->gc_cause());=20 ++#endif /* !USDT2 */ + } else { ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__PSMarkSweep__begin, *heap, he= ap->gc_cause()); ++#endif /* !USDT2 */ + full_gc_done =3D PSMarkSweep::invoke_no_policy(clear_all_softrefs); ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__PSMarkSweep__end, *heap, heap= ->gc_cause()); ++#endif /* !USDT2 */ + } + } +=20 diff -r 60bd733bd20c tapset/gc_details.stp.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tapset/gc_details.stp.in Wed Aug 22 16:32:18 2012 -0400 @@ -0,0 +1,495 @@ +/* + * probe - gc_collect_contig_begin + *=20 + * @name: gc_collect_contig_begin + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the start of a contiguous space generation coll= ection + *=20 + */ + +probe hotspot.gc_collect_contig_begin =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__contig__begin"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__contig__begin") +{ + + name =3D "gc_collect_contig_begin"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_contig_end + *=20 + * @name: gc_collect_contig_end_ + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the end of a contiguous space generation collec= tion + *=20 + */ + +probe hotspot.gc_collect_contig_end =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__contig__end"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__contig__end") +{ + + name =3D "gc_collect_contig_end"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_parnew_begin + *=20 + * @name: gc_collect_parnew_begin + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the beginning of a parallel collection of a new= =20 + * generation. + * This is different than a gc_collect_parallel generation due to it being + * specifically defined as a parNewGeneration + *=20 + */ + +probe hotspot.gc_collect_parnew =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parnew__begin"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parnew__begin") +{ + + name =3D "gc_collect_parnew_begin"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_parnew_end + *=20 + * @name: gc_collect_parnew_end + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the end of a parallel collection of a new=20 + * generation. + * This is different than a gc_collect_parallel generation due to it being + * specifically defined as a parNewGeneration + *=20 + */ + +probe hotspot.gc_collect_parnew_end =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parnew__end"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parnew__end") +{ + + name =3D "gc_collect_parnew_end"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_defnew_begin + *=20 + * @name: gc_collect_defnew_begin + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: The start of a newly defined generation collection + *=20 + */ + +probe hotspot.gc_collect_defnew_begin =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__defnew__begin"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__defnew__begin") +{ + + name =3D "gc_collect_defnew_begin"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_defnew_end + *=20 + * @name: gc_collect_defnew_end + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: The end of a newly defined generation collection + *=20 + */ + +probe hotspot.gc_collect_defnew_end =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__defnew__end"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__defnew__end") +{ + + name =3D "gc_collect_defnew_end"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_tenured_begin + *=20 + * @name: gc_collect_tenured_begin + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This is the start of a collection of a tenured generation + * (a geneartion that has survived multiple garbage collections and is=20 + * now in a 'tenured' object space. + *=20 + */ + +probe hotspot.gc_collect_tenured_begin =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__tenured__begin"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__tenured__begin") +{ + + name =3D "gc_collect_tenured_begin"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_tenured_end + *=20 + * @name: gc_collect_tenured_end + * @is_full: If TRUE, attempt a full collection of the generation + * @size: word size to be cleaned + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This is the end of a collection of a tenured generation + * (a geneartion that has survived multiple garbage collections and is=20 + * now in a 'tenured' object space. + *=20 + */ + +probe hotspot.gc_collect_tenured_end =3D=20 + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__tenured__end"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__tenured__end") +{ + + name =3D "gc_collect_tenured_end"; + is_full =3D $arg2; + size =3D $arg3; + is_tlab =3D $arg4; + probestr =3D sprintf("%s(is_full=3D'%d', size=3D'%d', is_tlab=3D'%d')", = name, is_full, size, is_tlab); + +} + +/* + * probe - gc_collect_parallel_scavenge + *=20 + * @name: gc_collect_parallel_scavenge + * @address: address of object being collected + * @cause: cause of the collection + *=20 + * Description: This is a parallel collection, where the jvm process don't + * have to halt while the gc is being completed + */ + +probe hotspot.gc_collect_parallel_scavenge =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parscavenge"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parscavenge") +{ + name =3D "gc_collect_parallel_scavenge"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_parallel_collect + *=20 + * @name: gc_collect_parallel_collect + * @address: address of object being collected + * @cause: cause of the collection + * + * Description: Another placement of a parallel collection + *=20 + */ + +probe hotspot.gc_collect_parallel_collect =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parallel__collec= t"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parallel__collec= t") +{ + name =3D "gc_collect_parallel_collect"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_g1_begin + *=20 + * @name: gc_collect_g1_begin + * @address: address of object being collected + * @cause: cause of the collection + * + * Description: A G1 style garbage collection (halt the world garbage coll= ection) + *=20 + */ + +probe hotspot.gc_collect_g1_begin =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__G1__begin"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__G1__begin") +{ + name =3D "gc_collect_g1_begin"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_g1_end + *=20 + * @name: gc_collect_g1_end + * @address: address of object being collected + * @cause: cause of the collection + * + * Description: A G1 style garbage collection (halt the world garbage coll= ection) + *=20 + */ + +probe hotspot.gc_collect_g1_end =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__G1__end"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__G1__end") +{ + name =3D "gc_collect_g1_end"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_delete + *=20 + * @name: gc_collect_delete + * @address: address of object being collected + * @cause: cause of the collection + * + * Description: A delete statement of an obeject + *=20 + */ + +probe hotspot.gc_collect_delete =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__delete"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__delete") +{ + name =3D "gc_collect_delete"; + address =3D sprintf("0x%x", $arg1); + probestr =3D sprintf("%s(address=3D'%s')", name, address); +} + +/* + * probe - gc_collect_PSScavenge_begin + *=20 + * @name: gc_collect_PSScavenge_begin + * @address: address of scavenge + * @cause: cause of the collection + * + * Description: A parallel scavenge begins. A scavenge is a partial garba= ge + * collection which should be much more common than a full garbage collect= ion + * throughout the course of the java program. + *=20 + */ + +probe hotspot.gc_collect_PSScavenge_begin =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSScavenge__begi= n"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSScavenge__begi= n") +{ + name =3D "gc_collect_PSScavenge_begin"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_PSScavenge_end + *=20 + * @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 occur= ing + * at the same time + *=20 + */ + +probe hotspot.gc_collect_PSScavenge_end =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSScavenge__end"= ), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSScavenge__end") +{ + name =3D "gc_collect_PSScavenge_end"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_PSParallelCompact_begin + *=20 + * @name: gc_collect_PSParallelCompact_begin + * @address: address of compaction + * @cause: cause of the collection + * + * Description: A parallel compaction of a memory space + *=20 + */ + +probe hotspot.gc_collect_PSParallelCompact_begin =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSParallelCompac= t__begin"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSParallelCompac= t__begin") +{ + name =3D "gc_collect_PSParallelCompact_begin"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_PSParallelCompact_end + *=20 + * @name: gc_collect_PSParallelCompact_end + * @address: address of compaction + * @cause: cause of the collection + * + * Description: A parallel compaction of a memory space + *=20 + */ + +probe hotspot.gc_collect_PSParallelCompact_end =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSParallelCompac= t__end"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSParallelCompac= t__end") +{ + name =3D "gc_collect_PSParallelCompact_end"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_PSMarkSweep_begin + *=20 + * @name: gc_collect_PSMarkSweep_begin + * @address: address of parallel mark sweep process + * @cause: cause of the collection + * + * Description: A parallel mark sweep of objects needed for collection beg= ins + *=20 + */ + +probe hotspot.gc_collect_PSMarkSweep_begin =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__beg= in"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__beg= in") +{ + name =3D "gc_collect_PSMarkSweep_begin"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_PSMarkSweep_end + *=20 + * @name: gc_collect_PSMarkSweep_end + * @address: address of parallel mark sweep process + * @cause: cause of the collection + * + * Description: A parallel mark sweep of objects needed for collection ends + *=20 + */ + +probe hotspot.gc_collect_PSMarkSweep_end =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__end= "), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__PSMarkSweep__end= ") +{ + name =3D "gc_collect_PSMarkSweep_end"; + address =3D sprintf("0x%x", $arg1); + cause =3D $arg2; + probestr =3D sprintf("%s(address=3D'%s', cause=3D'%d')", name, address, = cause); +} + +/* + * probe - gc_collect_move + *=20 + * @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 mov= ed 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 o= r=20 + * blocks of memory need to be moved. This probe will detail from where=20 + * the memory is moving and where to. + *=20 + */ + +probe hotspot.gc_collect_move =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__move"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__move") +{ + name =3D "gc_collect_move"; + from_bottom_address =3D sprintf("0x%x", $arg1); + from_top_address =3D sprintf("0x%x", $arg2); + to_bottom_address =3D sprintf("0x%x", $arg3); + to_top_address =3D sprintf("0x%x", $arg4); + probestr =3D sprintf("%s(from_bottom_address=3D'%s', from_top_address=3D= '%s', to_bottom_address=3D'%s', to_top_address=3D'%s')", name, from_bottom_= address, from_top_address, to_bottom_address, to_top_address); + +} + +/* + * probe - gc_collect_clear + *=20 + * @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=20 + * cleared in a compaction action + *=20 + */ + +probe hotspot.gc_collect_clear =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__ParallelCompact_= _clear"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__ParallelCompact_= _clear") +{ + name =3D "gc_collect_clear"; + region_data =3D sprintf("0x%x", $arg1); + data_location =3D sprintf("0x%x", $arg2); + probestr =3D sprintf("%s(region_data=3D'%s', data_location=3D'%s')", nam= e, region_data, data_location); +=20=20 +} --0OAP2g/MAC+5xKAE-- --JP+T4n/bALQSJXh8 Content-Type: application/pgp-signature Content-length: 836 -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAEBAgAGBQJQNUIEAAoJEAaRCclx+kwJeHMP/3BhMGOGurCPlOqjXzpCuDRZ aVKxCGeTUQj4VFwPGDt3FtGXvzcipExBGJC/BdVcDEVr9jkj6XZAm5NvjnFVXKt4 E/0G6xUsaTDq4ONboYutMAxHJSCp2xx3mjyUQnVvwHz2c5mxF2vALdT9MXN2eVCD xm6sJamenUifoNJgR99Ii+1B7lUijtJ9NqwyBjZ6bzm2mquAgVam4SsJ6qgdBj+A tXT8ZqVD7ZpYKp/+Vfdob4GbSzhB9wpfU0M0muXZYGRQTrDlt/2DWJKsssIGsjBw +Vjr3M5fv/o8NBQo9eBPtZpHS8yl2CTvo8Vr5JtKytN3lFqts2lEEIhJcBOyb7tm 2K6xWUXlTkSjvI+LDx3gw9gnmkOdnu10Dkdl0pUnCx4XT9QkJPhjBAIsDKs4MUSz Jrj5ryBV2K10LsjPcpKlTORP6LsJDVepf9L47Dbg4tsc2kTB5Fq4lALzUpAoi+/A gZy3mB5zZqX9MuMRqb0uuCWmyEgSAx8yFTCFnCOg1eAkJfZx7xx7UMbEHYDiXGrr /q7vkjUCAZHolZgcavBqfiAKQGqaLREmPYCF7lDLqBe51g7ol/QS0kn+/agx6anJ 69kp1a2Krj0Xld5Sy8e3lhEK69NM9XZMeRzINdrz9fpDrApZKzEhgvOox3IA1ddy 7xlmMarGEiqUhq8DyEGg =DQbU -----END PGP SIGNATURE----- --JP+T4n/bALQSJXh8--