From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 21724 invoked by alias); 31 Aug 2012 20:07:14 -0000 Received: (qmail 21651 invoked by uid 22791); 31 Aug 2012 20:07:05 -0000 X-SWARE-Spam-Status: No, hits=-8.8 required=5.0 tests=AWL,BAYES_00,KHOP_PGP_SIGNED,KHOP_RCVD_UNTRUST,MAY_BE_FORGED,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; Fri, 31 Aug 2012 20:06:44 +0000 Received: from int-mx01.intmail.prod.int.phx2.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q7VK6htL009054 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Fri, 31 Aug 2012 16:06:43 -0400 Received: from redhat.com (unused [10.15.16.143] (may be forged)) by int-mx01.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id q7VK6e7P003585 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NO); Fri, 31 Aug 2012 16:06:42 -0400 Date: Fri, 31 Aug 2012 20:07:00 -0000 From: Lukas Berk To: Jon VanAlten Cc: systemtap@sourceware.org, distro-pkg-dev@openjdk.java.net Subject: Re: [RFC] Enhanced Garbage Collection Probe Points Message-ID: <20120831200639.GA3000@redhat.com> Reply-To: Lukas Berk References: <20120828212242.GA29101@redhat.com> <1348752799.62002180.1346289556603.JavaMail.root@redhat.com> MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha1; protocol="application/pgp-signature"; boundary="dTy3Mrz/UPE2dbVg" Content-Disposition: inline In-Reply-To: <1348752799.62002180.1346289556603.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/msg00257.txt.bz2 --dTy3Mrz/UPE2dbVg Content-Type: multipart/mixed; boundary="IS0zKkzwUGydFO0o" Content-Disposition: inline --IS0zKkzwUGydFO0o Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-Transfer-Encoding: quoted-printable Content-length: 6481 Hey, [...] > > > this gc run. Can this be clarified? > > I've changed this to: "Word size of the object to be collected." >=20 > So, this maybe is not a great improvement. Does this mean that in the > gc run there will be a single object collected? Is that single object > @size words big? I think I know better that this is not what you > mean here, but it reads unclear. Let me ask my question another way, > is @size a target for this collection run? Or is it the size of the > region to be collected? >=20 > This also introduces a terminology collision for java-centric folks. > I think you maybe mean 'region' or 'generation' rather than 'object', > which has a specific meaning in Java-land. This is also an issue > below... >=20 > If the meaning of this value is what I think it is, can I suggest: >=20 > "The number of words of memory that this collection will try to reclaim" As per our discussion on irc, I've changed this to "The collection should achieve a minimum region of available memory to allow for an allocation of 'size'." This should satisfy all possible situations where where @size is used. >=20 > > >=20 > > > + * probe - gc_collect_parallel_scavenge > > > + * > > > + * @name: gc_collect_parallel_scavenge > > > + * @address: address of object being collected > > > + * @cause: cause of the collection > > > + * > > > + * 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 > I think this is another place where the use of 'object' causes confusion. > Maybe in this case you mean 'region' or 'generation'? I've changed it to 'region' to avoid the confusion :) >=20 > Another question I have about this; what relationship does this probe > have to the corresponding _begin and _end probes? Does this probe > fire near the beginning or near the end or before the beginning or > after the end? Why do we need this probe, if we already can say > when this process begins and ends? This is simply another occurrence (in a different area of the hotspot code) that corresponds to a scavenge. In order to remain more consistent, I've split the probe into begin/end probes and renamed it to reflect the portion of code its located in (gc_collect_parscavenge_heap_{begin,end}. I've also tweaked the docs to remain consistent with the 'This marks a ...' style description. >=20 > Anyways, this is mainly me being picky about documentation. On the > technical level, this is fine, so while I think it would be nice to get > the docs perfect on the first try I don't demand it. If my understanding > above about semantics of these variables is correct and you'd like to > accept my suggestions, please do commit this with those tiny updates. If > my understanding is incorrect, let's not hold this commit back; just put > it in the way it is, but then I would like to better understand what the > values those particular probes are telling me (both for if I try to use > them, and for documenting them for other users!). >=20 > That's all I have to say about the patch :) >=20 > > >=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. >=20 > Ah, so these numbers really don't tell us anything at all then! >=20 > Maybe we can collaborate on some better methodology... Sure, I'll contact you off list regarding this. [...] > > > 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. > >=20 >=20 > So, this is in some ways analogous to what I struggled with in testing > some of the existing probes. For example, the probes that fire when > a method is JIT compiled. This happens (depending on tuning options > of course) after a certain number invocations of a particular method, > so in order to test that the probe fires when expected, I wrote a > java program that did call a certain method the correct number of times, > and checked that the output indicated the probe firing showing that > particular method being JIT compiled. >=20 > For your problem, instead of controlling the number of times a method > is called, you need to cause certain amounts of space to be allocated > for Java objects. You probably to start from some baseline (an empty > main()), learn about the tuning options that affect the GC behaviour, > and so forth. I think this is rather non-trivial, another reason why > not to block the patch for testing. And then, as Mark pointed out in > his reply, there is also the matter of integrating with the existing > tests. My apologies in advance about the wrapper script, and please > consider me available to help when you get to that point. >=20 Thanks for the offer, I've already taken a look and once again I'll contact you off list with any specifics :) > > Is this ok to commit? > >=20 >=20 > With caveats noted above, I say yes :) >=20 Thanks! Please let me know if there is anything else you'd like to know, updated patch is attached. Cheers, Lukas --IS0zKkzwUGydFO0o Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="icedtea1.patch" Content-Transfer-Encoding: quoted-printable Content-length: 36537 diff -r 727519ab8096 Makefile.am --- a/Makefile.am Fri Aug 24 01:53:20 2012 +0100 +++ b/Makefile.am Fri Aug 31 15:47:32 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 Fri Aug 31 15:47:32 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 Fri Aug 31 15:47:32 2012 -0400 @@ -0,0 +1,369 @@ +--- 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= 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 +--- openjdk.orig/hotspot/src/share/vm/gc_implementation/parallelScavenge/p= arallelScavengeHeap.cpp 2012-07-25 13:24:07.000000000 -0400 ++++ openjdk/hotspot/src/share/vm/gc_implementation/parallelScavenge/parall= elScavengeHeap.cpp 2012-08-31 15:14:23.936576341 -0400 +@@ -40,8 +40,14 @@ + #include "runtime/handles.inline.hpp" + #include "runtime/java.hpp" + #include "runtime/vmThread.hpp" ++#include "utilities/dtrace.hpp" + #include "utilities/vmError.hpp" +=20 ++#ifndef USDT2 ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__parscavenge__heap__begi= n, *uintptr_t, *uintptr_t); ++ HS_DTRACE_PROBE_DECL2(provider, gc__collection__parscavenge__heap__end,= *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,7 +812,13 @@ + } +=20 + VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause); ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__parscavenge__heap__begin, &op= , cause); ++#endif /* !USDT2 */ + VMThread::execute(&op); ++#ifndef USDT2 ++ HS_DTRACE_PROBE2(hotspot, gc__collection__parscavenge__heap__end, &op, = cause); ++#endif /* !USDT2 */ + } +=20 + // This interface assumes that it's being called by the diff -r 727519ab8096 tapset/hotspot_gc.stp.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tapset/hotspot_gc.stp.in Fri Aug 31 15:47:32 2012 -0400 @@ -0,0 +1,534 @@ +/* + * 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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the start of a contiguous space generation 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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the end of a contiguous space generation 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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the beginning of a parallel collection of a new= =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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the end of a parallel collection of a new=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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the start of a newly defined generation + * collection + *=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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This marks the end of a newly defined generation + * collection + *=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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This is the start of a collection of a tenured generation + * (a generation that has survived multiple garbage collections and is=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: The collection should achieve a minimum region of available + * memory to allow for an allocation of 'size'. + * @is_tlab: Is this a Thread Local Allocation Buffer? + * + * Description: This is the end of a collection of a tenured generation + * (a generation that has survived multiple garbage collections and is=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_heap_begin + *=20 + * @name: gc_collect_parallel_scavenge_heap_begin + * @address: Address of region being collected. + * @cause: Cause of the collection. + *=20 + * Description: This is a parallel heap scavenge beginning, the jvm proces= s 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__hea= p__begin"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parscavenge__hea= p__begin") +{ + name =3D "gc_collect_parallel_scavenge_heap_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_parallel_scavenge_heap_end + *=20 + * @name: gc_collect_parallel_scavenge_heap_end + * @address: Address of region being collected. + * @cause: Cause of the collection. + *=20 + * Description: This is a parallel heap scavenge ending, the jvm process d= oesn't + * have to halt while the gc is being completed. + */ + +probe hotspot.gc_collect_parallel_scavenge_heap_end =3D + process("@ABS_CLIENT_LIBJVM_SO@").mark("gc__collection__parscavenge__hea= p__end"), + process("@ABS_SERVER_LIBJVM_SO@").mark("gc__collection__parscavenge__hea= p__end") +{ + name =3D "gc_collect_parallel_scavenge_heap_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_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 +} --IS0zKkzwUGydFO0o-- --dTy3Mrz/UPE2dbVg Content-Type: application/pgp-signature Content-length: 836 -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAEBAgAGBQJQQRlPAAoJEAaRCclx+kwJookP/0zex+KpZtbmJ2GzYaj7KpW4 t6DQ8M+uewjaWa5MVH7zI/CEbfNuINMYqb9ofD1tnxbZWGdqUmDK34fCFChy9Fy8 +Yrxp8E0uhAQEMEcPDyyFsfFlXqowHBzfwqB5ppdO8IeQQfmhui2l1cHwD/xWCNd 8SW4QjEMtnjeRFMun4CCpn6AEwCWZ2k1YgDUQA75j0K2DxTqH0Xn62HCHxjJO16/ LwP2FFgSAIp4poZQpZJVdU9O/Pu2tGTUEFfI1uMyV3h/e/QExsC+ZLQwKvf0gzqU rvvuT1dcyvwoHYKBEDckRl1l8uGV8IpiW7t2DftoUjnYO63zP6wWW613U8YJcooP A0BkC4RP+jNGy1/LoRT1vzxsKOXz48uaIGUomENSQq7KOAOEnRYbm3ASZb43SRWW n5pisk/RkiieQUo2HuVziMXvXTGDJx6f8Uc1lmrOoifTmyf6HnOp5eLL3z5q6jix Wq+rRD4z/81LqoDzf7bawCGtH4L+LK6qkNl9dB2qa1Y/feQeCW7TSKssXK2uV4wK O/cTrg3IfzP4OLdjYhnSqTPSiqBfpccmHaehO7Hbd4uO5XAZJg+Q3EjZ9IwO8ou6 K9feD9bfpeBIjWoGnIYGDkCmcKH7zG6hwQ2sTo6hSQKFDFPUfJlxaoDSPL6uwzPP ETZDanWeYJ5009a0Lw2y =cdtY -----END PGP SIGNATURE----- --dTy3Mrz/UPE2dbVg--