truffle: src/share/vm/runtime/thread.cpp comparison

comparison src/share/vm/runtime/thread.cpp @ 7212:291ffc492eb6

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Fri, 14 Dec 2012 14:35:13 +0100
parents	1baf7f1e3f23 d2f8c38e543d
children	989155e2d07a

comparison

equal deleted inserted replaced

-:2ed8d74e5984
+:291ffc492eb6
 #include "runtime/safepoint.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/statSampler.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/task.hpp"
+#include "runtime/thread.inline.hpp"
 #include "runtime/threadCritical.hpp"
 #include "runtime/threadLocalStorage.hpp"
 #include "runtime/vframe.hpp"
 #include "runtime/vframeArray.hpp"
 #include "runtime/vframe_hp.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/preserveException.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 # include "os_linux.inline.hpp"
-# include "thread_linux.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_solaris
 # include "os_solaris.inline.hpp"
-# include "thread_solaris.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_windows
 # include "os_windows.inline.hpp"
-# include "thread_windows.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_bsd
 # include "os_bsd.inline.hpp"
-# include "thread_bsd.inline.hpp"
 #endif
 #ifndef SERIALGC
 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
 #include "gc_implementation/parallelScavenge/pcTasks.hpp"
 assert(SharedHeap::heap()->workers()->active_workers() > 0,
 "Should only fail when parallel.");
 return false;
 }
-void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
+void Thread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 active_handles()->oops_do(f);
 // Do oop for ThreadShadow
 f->do_oop((oop*)&_pending_exception);
 handle_area()->oops_do(f);
 }
 _cur_thr->set_processed_thread(NULL);
 }
 }
 };
-void JavaThread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
+void JavaThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 // Verify that the deferred card marks have been flushed.
 assert(deferred_card_mark().is_empty(), "Should be empty during GC");
 // The ThreadProfiler oops_do is done from FlatProfiler::oops_do
 // since there may be more than one thread using each ThreadProfiler.
 // Traverse the GCHandles
-Thread::oops_do(f, cf);
+Thread::oops_do(f, cld_f, cf);
 assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
 if (has_last_Java_frame()) {
 chunk->oops_do(f);
 }
 // Traverse the execution stack
 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
-fst.current()->oops_do(f, cf, fst.register_map());
+fst.current()->oops_do(f, cld_f, cf, fst.register_map());
 }
 }
 // callee_target is never live across a gc point so NULL it here should
 // it still contain a methdOop.
 if (jvmti_thread_state() != NULL) {
 jvmti_thread_state()->oops_do(f);
 }
 if (_scanned_nmethod != NULL && cf != NULL) {
 // Safepoints can occur when the sweeper is scanning an nmethod so
 // process it here to make sure it isn't unloaded in the middle of
 // a scan.
 cf->do_code_blob(_scanned_nmethod);
 }
 }
 void JavaThread::nmethods_do(CodeBlobClosure* cf) {
 Thread::nmethods_do(cf);  // (super method is a no-op)
 static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); }
 void JavaThread::verify() {
 // Verify oops in the thread.
-oops_do(&VerifyOopClosure::verify_oop, NULL);
+oops_do(&VerifyOopClosure::verify_oop, NULL, NULL);
 // Verify the stack frames.
 frames_do(frame_verify);
 }
 static void oops_print(frame* f, const RegisterMap *map) {
 PrintAndVerifyOopClosure print;
 f->print_value();
-f->oops_do(&print, NULL, (RegisterMap*)map);
+f->oops_do(&print, NULL, NULL, (RegisterMap*)map);
 }
 // Print our all the locations that contain oops and whether they are
 // valid or not.  This useful when trying to find the oldest frame
 // where an oop has gone bad since the frame walk is from youngest to
 TraceTime timer("Create VM", TraceStartupTime);
 // Initialize the os module after parsing the args
 jint os_init_2_result = os::init_2();
 if (os_init_2_result != JNI_OK) return os_init_2_result;
+jint adjust_after_os_result = Arguments::adjust_after_os();
+if (adjust_after_os_result != JNI_OK) return adjust_after_os_result;
 // intialize TLS
 ThreadLocalStorage::init();
 // Bootstrap native memory tracking, so it can start recording memory
 if (CleanChunkPoolAsync) {
 Chunk::start_chunk_pool_cleaner_task();
 }
 // initialize compiler(s)
-#if defined(COMPILER1) || defined(COMPILER2) || defined(GRAAL)
+#if defined(COMPILER1) || defined(COMPILER2) || defined(SHARK) || defined(GRAALVM)
 CompileBroker::compilation_init();
 #endif
 #if INCLUDE_MANAGEMENT
 Management::initialize(THREAD);
 // In particular, these things should never be called when the Threads_lock
 // is held by some other thread. (Note: the Safepoint abstraction also
 // uses the Threads_lock to gurantee this property. It also makes sure that
 // all threads gets blocked when exiting or starting).
-void Threads::oops_do(OopClosure* f, CodeBlobClosure* cf) {
+void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 ALL_JAVA_THREADS(p) {
-p->oops_do(f, cf);
+p->oops_do(f, cld_f, cf);
 }
-VMThread::vm_thread()->oops_do(f, cf);
+VMThread::vm_thread()->oops_do(f, cld_f, cf);
 }
-void Threads::possibly_parallel_oops_do(OopClosure* f, CodeBlobClosure* cf) {
+void Threads::possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 // Introduce a mechanism allowing parallel threads to claim threads as
 // root groups.  Overhead should be small enough to use all the time,
 // even in sequential code.
 SharedHeap* sh = SharedHeap::heap();
 // Cannot yet substitute active_workers for n_par_threads
 (SharedHeap::heap()->n_par_threads() ==
 SharedHeap::heap()->workers()->active_workers()), "Mismatch");
 int cp = SharedHeap::heap()->strong_roots_parity();
 ALL_JAVA_THREADS(p) {
 if (p->claim_oops_do(is_par, cp)) {
-p->oops_do(f, cf);
+p->oops_do(f, cld_f, cf);
 }
 }
 VMThread* vmt = VMThread::vm_thread();
 if (vmt->claim_oops_do(is_par, cp)) {
-vmt->oops_do(f, cf);
+vmt->oops_do(f, cld_f, cf);
 }
 }
 #ifndef SERIALGC
 // Used by ParallelScavenge

Mercurial > hg > truffle

comparison src/share/vm/runtime/thread.cpp @ 7212:291ffc492eb6