From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 3172 invoked by alias); 28 Aug 2012 21:23:17 -0000 Received: (qmail 3148 invoked by uid 22791); 28 Aug 2012 21:23:11 -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; Tue, 28 Aug 2012 21:22:49 +0000 Received: from int-mx10.intmail.prod.int.phx2.redhat.com (int-mx10.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q7SLMm32031846 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Tue, 28 Aug 2012 17:22:48 -0400 Received: from redhat.com (vpn-224-56.phx2.redhat.com [10.3.224.56]) by int-mx10.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id q7SLMhhA032356 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NO); Tue, 28 Aug 2012 17:22:45 -0400 Date: Tue, 28 Aug 2012 21:23:00 -0000 From: Lukas Berk To: Jon VanAlten Cc: systemtap@sourceware.org, distro-pkg-dev@openjdk.java.net, Mark Wielaard Subject: Re: [RFC] Enhanced Garbage Collection Probe Points Message-ID: <20120828212242.GA29101@redhat.com> Reply-To: Lukas Berk References: <20120822203308.GA7445@redhat.com> <1651488727.58755626.1345838351275.JavaMail.root@redhat.com> MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha1; protocol="application/pgp-signature"; boundary="kORqDWCi7qDJ0mEj" Content-Disposition: inline In-Reply-To: <1651488727.58755626.1345838351275.JavaMail.root@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/msg00250.txt.bz2 --kORqDWCi7qDJ0mEj Content-Type: multipart/mixed; boundary="PNTmBPCT7hxwcZjr" Content-Disposition: inline --PNTmBPCT7hxwcZjr Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-Transfer-Encoding: quoted-printable Content-length: 6972 Hey Jon, Thanks for the comments, I've resolved them or explained them inline. * Jon VanAlten [2012-08-24 15:59]: >=20 [...] > We have a hotspot.stp, a hotspot_jni.stp; maybe this one should be > hotspot_gc.stp? Done, its now included as hotspot_gc.stp.in >=20 > Adding this fluff to the existing systemtap.patch, may not be the > best way. As I understand it, Mark is trying to get the existing > stuff upstream. Combining this into same IcedTea patch may make > it more difficult if/when this upstreaming is eventually successful > and needs to be removed from IcedTea. I'd suggest introducing a > separate patch to the icedtea sources. Makes sense to me, I've adjusted the autoconf files accordingly to include and apply patches/systemtap_gc.patch if icedtea is configure with --enable-systemtap. >=20 > + * @size: word size to be cleaned >=20 > (in several places) > This wording (pun not intended) is not entirely clear. Playing the > ignorant reader, I am not sure if this means the wordsize that the > jvm uses, or the total space, in words, that will be collected on > this gc run. Can this be clarified? I've changed this to: "Word size of the object to be collected." >=20 > + * @is_full: If TRUE, attempt a full collection of the generation >=20 > And if not TRUE? (again playing the ignorant reader). if its false then perform a scavenge, I've adjusted the docs accordingly >=20 > + * 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 bei= ng > + * specifically defined as a parNewGeneration >=20 > The 'clarification' sentence reads to me like "Y is not X because it > is Y". I'd consider leaving it off, or providing a better explanation. I see what you're saying. I've removed it. >=20 > + * Description: The start of a newly defined generation collection >=20 > The previous probes' documentation says "This marks the...", I'd love > to see consistency in the wording. I've changed this to be consistent throughout. Also, I've made sure that all capitalization and punctuation is correct/consistent. >=20 > + * Description: This is the start of a collection of a tenured generation > + * (a geneartion that has survived multiple garbage collections and is=20 >=20 > Here too, also typo "generation" Fixed. >=20 > + * 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 >=20 > I want to make sure I understand this. If I read this correctly, this > probe fires many times between a begin and end of parallel gc run, for > each object that is scavenged? If I do understand this, then saying > "this is a parallel collection" I think is the wrong wording. This > is not a collection, but an event that is part of a collection run. If > I misunderstand, please clarify :) No, a scavenge is just a miniature collection, not a process within a collection. The mechanics are the same, just not on the entire object space/heap. That being said I've s/This is a parallel collection/This is a parallel scavenge/ to be specific. >=20 > + * Description: A delete statement of an obeject >=20 > Typo "obeject" Fixed. >=20 > Otherwise, I don't really have any concerns with this. I hope though > that Mark (who introduced the systemtap support for the existing > probes) could also take a look for sanity. I've added him to CC > directly, even though he probably also gets this through the list. Keeping him on the CC >=20 > on the benchmarking results and the interest in my patch,=20 [...] >=20 > I think there's more to look at in terms of performance. However, > despite what the numbers here show, from my understanding (Mark, > please chime in here!) the existence of these probes in the source > should in theory not affect runtime performance. Otherwise, I might You are correct, from a performance perspective, adding probe points is essentially within the realm of noise. I just wanted to show that actually using them won't cause significant performance hits if anybody had any reservations. > be asking to see data for --enable-systemtap w/o this patch as well > to compare really what this patch adds. Anyhow, unless I am quite > wrong about this, I don't think there is any performance concern > for adding these probes, only for when they are used. So, consider > my next paragraph not for this patch, but more generally to discuss > performance impact of using these probes. >=20 > These numbers do seem to raise some questions, though. Why do we > see such variation between the runs? I'd encourage you to explore > this further. Another aspect to consider: looking at run time of The variations can most likely be attributed to the fact I was running this on a vm on my laptop and had other (non trivial) processes running on the host. > benchmark will show the impact aggregated over entire java process, > but it would be interesting to see the impact relative to time > actually spent in gc. I'd be concerned if simply printing this > probestr at beginning and end of gc made the gc run last 10% longer, > even if it looks relatively minor aggregated over full java process > run time. I'm not sure how you'd go about trying to measure this, > however. I can look into running scripts that would simply increment a variable (ie gc_hit++) every time a probe is hit instead of logging the probestr, also I could run the same tests and start a timer when hotspot.gc_begin is hit and ends when a hotspot.gc_end is hit. (those probes are already there). >=20 > > what else > > needs to be done to get this patch applied to icedtea? > >=20 >=20 > Well, I am basically OK with this aside from the things mentioned > above. I guess remaining still is the question of testing these. I > wouldn't block this based on lacking tests (the previous probes went > untested for ages before I added tests), but I also don't want this > to go in without a plan to eventually add tests; when we did add > tests for the other probes, we actually found regressions and even > things that had never properly worked iirc. >=20 > Have you given any thought to how you might add tests for these > probes to the existing set of probe tests? Ideally I'd have some java test programs that would be able to allocate enough objects to trigger collections. As mentioned earlier, different gc algorithms can be specified with jvm options, but what would be tricky is controlling the gc invocation via jvm options in a reliable enough manner that we can reasonably expect scavenges to occur. I would have to experiment with that to see if its possible, if anybody else knows how to easily do that please let me know. Is this ok to commit? Cheers, Lukas --PNTmBPCT7hxwcZjr Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="icedtea.patch" Content-Transfer-Encoding: quoted-printable Content-length: 34771 diff -r 727519ab8096 Makefile.am --- a/Makefile.am Fri Aug 24 01:53:20 2012 +0100 +++ b/Makefile.am Tue Aug 28 15:26:58 2012 -0400 @@ -291,7 +291,9 @@ endif =20 if ENABLE_SYSTEMTAP -ICEDTEA_PATCHES +=3D patches/systemtap.patch +ICEDTEA_PATCHES +=3D \ + patches/systemtap.patch \ + patches/systemtap_gc.patch endif =20 if ENABLE_NSS @@ -764,6 +766,7 @@ tapset/hotspot.stp.in \ tapset/hotspot_jni.stp.in \ tapset/jstack.stp.in \ + tapset/hotspot_gc.stp.in \ scripts/jni_create_stap.c \ scripts/jni_desc \ rewriter/agpl-3.0.txt \ @@ -1730,11 +1733,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/hotspot_gc.stp \ + > $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_gc.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/hotspot_gc.stp \ + $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_gc.stp; \ fi; \ cp $(abs_top_builddir)/tapset/jstack.stp \ $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/jstack.stp @@ -1796,11 +1804,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/hotspot_gc.stp \ + > $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_gc.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/hotspot_gc.stp \ + $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_gc.stp; \ fi; \ cp $(abs_top_builddir)/tapset/jstack.stp \ $(DEBUG_BUILD_OUTPUT_DIR)/j2sdk-image/tapset/jstack.stp diff -r 727519ab8096 configure.ac --- a/configure.ac Fri Aug 24 01:53:20 2012 +0100 +++ b/configure.ac Tue Aug 28 15:26:58 2012 -0400 @@ -315,6 +315,7 @@ AC_CONFIG_FILES([tapset/hotspot.stp]) AC_CONFIG_FILES([tapset/hotspot_jni.stp]) AC_CONFIG_FILES([tapset/jstack.stp]) + AC_CONFIG_FILES([tapset/hotspot_gc.stp]) fi =20 dnl Check for libXtst headers and libraries. diff -r 727519ab8096 patches/systemtap_gc.patch --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/patches/systemtap_gc.patch Tue Aug 28 15:26:58 2012 -0400 @@ -0,0 +1,364 @@ +--- 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 +--- 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()= ); +--- 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, +--- 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()); +--- 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 { +--- 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, +--- 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 +--- 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 727519ab8096 tapset/hotspot_gc.stp.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tapset/hotspot_gc.stp.in Tue Aug 28 15:26:58 2012 -0400 @@ -0,0 +1,505 @@ +/* + * probe - gc_collect_contig_begin + *=20 + * @name: gc_collect_contig_begin + * @is_full: If TRUE, attempt a full collection of the generation. + * Else; perform a scavenge + * @size: Word size of the object to be collected. + * @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. + * Else; perform a scavenge. + * @size: Word size of the object to be collected. + * @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. + * Else; perform a scavenge + * @size: Word size of the object to be collected. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the beginning of a parallel collection of a new= =20 + * generation. + *=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. + * Else; perform a scavenge + * @size: Word size of the object to be collected. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the end of a parallel collection of a new=20 + * generation. + *=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. + * Else; perform a scavenge + * @size: Word size of the object to be collected. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks 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. + * Else; perform a scavenge + * @size: Word size of the object to be collected. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks 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. + * Else; perform a scavenge + * @size: Word size of the object to be collected. + * @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=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. + * Else; perform a scavenge + * @size: Word size of the object to be collected. + * @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=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 scavenge, where the jvm process doesn'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: This marks 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: This marks the start of a G1 style garbage collection + * (Garbage-First Garbage Collector). + *=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: This marks then end of a G1 style garbage collection + * (Garbage-First Garbage Collector). + *=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 object. + *=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: This marks the start of a parallel compaction. + *=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: This marks the end of a parallel compaction. + *=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: This marks the start of a parallel mark sweep for + * objects that require collection. + *=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: This marks the start of a parallel mark sweep for + * objects that require collection. + *=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 +} --PNTmBPCT7hxwcZjr-- --kORqDWCi7qDJ0mEj Content-Type: application/pgp-signature Content-length: 836 -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAEBAgAGBQJQPTaiAAoJEAaRCclx+kwJUF4P/RDcByt9GXhZ0wSb2Wv+wvcT +pIH11w26Uflzked6zo4FodlxFgf3uLC/rDLr94LuNpj4CvO0KQNW+Gmj2qZ7Cgo 1JKcBBNiQxCnFebv33JocZkbVKUaddeROs9FtJR5+NRwXB4HPcJpHJRH01VxRkB/ dCVSCyoRJjggIGMVwU6np3s9RvRIXrKdmLaGd+1K55TkVV8LBnTHy3Z9RAUOyuH3 GMLSTTyuAOdXRj88SxT0wA7o75GY74/kbXO+TENpBK+5l02Sn9QjrKPmirr2VQk7 fKVPWZzOSmNhkdU7K0VRggKtbCoj8r18GHOkd/WNyg8+2smm8TDsJmBqhFd5t9R7 W1DUVRcR7sEQaE7anNLvKxy+1K/6FikS8QDMwLwROxCWQ3WsabXgplYi0t7aMnQC O9wv0o6c50VX5679zh2BdA9MPUEfmR2vJaGkjlQdZYZvi/sVX5SYonr1YBzzaPmW ojrCWUG6ib+RmcDXM1FfpD/R4Zvfczt8pHfbiu/yIMi621/pAUWyfG9Hu7LScj/T rvnR4GGg3ZAVRh1Ar+/YT6bX0Cla4X88B4u+hzr28QQqut6tdy4nJV2kbq+sLVXX 51nF1U4dPvT5tMpEHkgMyW1fodEr1m1eq/kSbgMsO6XhNjBCHLNkJ+aGZr4mLHBm cIniyue+/4nHP8rz7Z6c =CFaf -----END PGP SIGNATURE----- --kORqDWCi7qDJ0mEj--