graal-compiler: src/share/vm/prims/jvmtiTagMap.cpp comparison

comparison src/share/vm/prims/jvmtiTagMap.cpp @ 4137:04b9a2566eec

Merge with hsx23/hotspot.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sat, 17 Dec 2011 21:40:27 +0100
parents	88dce6a60ac8
children	2b150750d53d

comparison

equal deleted inserted replaced

-:9dc19b7d89a3
+:04b9a2566eec
 class ObjectMarker : AllStatic {
 private:
 // saved headers
 static GrowableArray<oop>* _saved_oop_stack;
 static GrowableArray<markOop>* _saved_mark_stack;
+static bool _needs_reset;                  // do we need to reset mark bits?
 public:
 static void init();                       // initialize
 static void done();                       // clean-up
 static inline void mark(oop o);           // mark an object
 static inline bool visited(oop o);        // check if object has been visited
+static inline bool needs_reset()            { return _needs_reset; }
+static inline void set_needs_reset(bool v)  { _needs_reset = v; }
 };
 GrowableArray<oop>* ObjectMarker::_saved_oop_stack = NULL;
 GrowableArray<markOop>* ObjectMarker::_saved_mark_stack = NULL;
+bool ObjectMarker::_needs_reset = true;  // need to reset mark bits by default
 // initialize ObjectMarker - prepares for object marking
 void ObjectMarker::init() {
 assert(Thread::current()->is_VM_thread(), "must be VMThread");
 // Object marking is done so restore object headers
 void ObjectMarker::done() {
 // iterate over all objects and restore the mark bits to
 // their initial value
 RestoreMarksClosure blk;
-Universe::heap()->object_iterate(&blk);
+if (needs_reset()) {
+Universe::heap()->object_iterate(&blk);
+} else {
+// We don't need to reset mark bits on this call, but reset the
+// flag to the default for the next call.
+set_needs_reset(true);
+}
 // When sharing is enabled we need to restore the headers of the objects
 // in the readwrite space too.
 if (UseSharedSpaces) {
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 }
 return true;
 }
-// collects all simple (non-stack) roots.
+// Collects all simple (non-stack) roots except for threads;
+// threads are handled in collect_stack_roots() as an optimization.
 // if there's a heap root callback provided then the callback is
 // invoked for each simple root.
 // if an object reference callback is provided then all simple
 // roots are pushed onto the marking stack so that they can be
 // processed later
 ObjectSynchronizer::oops_do(&blk);
 if (blk.stopped()) {
 return false;
 }
-// Threads
+// threads are now handled in collect_stack_roots()
-for (JavaThread* thread = Threads::first(); thread != NULL ; thread = thread->next()) {
-oop threadObj = thread->threadObj();
-if (threadObj != NULL && !thread->is_exiting() && !thread->is_hidden_from_external_view()) {
-bool cont = CallbackInvoker::report_simple_root(JVMTI_HEAP_REFERENCE_THREAD, threadObj);
-if (!cont) {
-return false;
-}
-}
-}
 // Other kinds of roots maintained by HotSpot
 // Many of these won't be visible but others (such as instances of important
 // exceptions) will be visible.
 blk.set_kind(JVMTI_HEAP_REFERENCE_OTHER);
 }
 return true;
 }
-// collects all stack roots - for each thread it walks the execution
+// Collects the simple roots for all threads and collects all
+// stack roots - for each thread it walks the execution
 // stack to find all references and local JNI refs.
 inline bool VM_HeapWalkOperation::collect_stack_roots() {
 JNILocalRootsClosure blk;
 for (JavaThread* thread = Threads::first(); thread != NULL ; thread = thread->next()) {
 oop threadObj = thread->threadObj();
 if (threadObj != NULL && !thread->is_exiting() && !thread->is_hidden_from_external_view()) {
+// Collect the simple root for this thread before we
+// collect its stack roots
+if (!CallbackInvoker::report_simple_root(JVMTI_HEAP_REFERENCE_THREAD,
+threadObj)) {
+return false;
+}
 if (!collect_stack_roots(thread, &blk)) {
 return false;
 }
 }
 }
 assert(visit_stack()->is_empty(), "visit stack must be empty");
 // the heap walk starts with an initial object or the heap roots
 if (initial_object().is_null()) {
+// If either collect_stack_roots() or collect_simple_roots()
+// returns false at this point, then there are no mark bits
+// to reset.
+ObjectMarker::set_needs_reset(false);
+// Calling collect_stack_roots() before collect_simple_roots()
+// can result in a big performance boost for an agent that is
+// focused on analyzing references in the thread stacks.
+if (!collect_stack_roots()) return;
 if (!collect_simple_roots()) return;
-if (!collect_stack_roots()) return;
+// no early return so enable heap traversal to reset the mark bits
+ObjectMarker::set_needs_reset(true);
 } else {
 visit_stack()->push(initial_object()());
 }
 // object references required

Mercurial > hg > graal-compiler

comparison src/share/vm/prims/jvmtiTagMap.cpp @ 4137:04b9a2566eec