graal-compiler: src/share/vm/compiler/compileBroker.cpp comparison

comparison src/share/vm/compiler/compileBroker.cpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	1d7922586cf6
children	aed758eda82a

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 #include "compiler/compileBroker.hpp"
 #include "compiler/compileLog.hpp"
 #include "compiler/compilerOracle.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "memory/allocation.inline.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/nativeLookup.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/compilationPolicy.hpp"
 #include "runtime/init.hpp"
 CompileTask* task = thread->task();
 CompileLog*  log  = thread->log();
 if (log != NULL)  task->log_task_done(log);
 thread->set_task(NULL);
 task->set_code_handle(NULL);
-DEBUG_ONLY(thread->set_env((ciEnv*)badAddress));
+thread->set_env(NULL);
 if (task->is_blocking()) {
 MutexLocker notifier(task->lock(), thread);
 task->mark_complete();
 // Notify the waiting thread that the compilation has completed.
 task->lock()->notify_all();
 const char* comment,
 bool is_blocking) {
 assert(!_lock->is_locked(), "bad locking");
 _compile_id = compile_id;
-_method = JNIHandles::make_global(method);
+_method = method();
+_method_loader = JNIHandles::make_global(_method->method_holder()->class_loader());
 _osr_bci = osr_bci;
 _is_blocking = is_blocking;
 _comp_level = comp_level;
 _num_inlined_bytecodes = 0;
 _is_complete = false;
 _is_success = false;
 _code_handle = NULL;
 _hot_method = NULL;
+_hot_method_loader = NULL;
 _hot_count = hot_count;
 _time_queued = 0;  // tidy
 _comment = comment;
 if (LogCompilation) {
 _time_queued = os::elapsed_counter();
 if (hot_method.not_null()) {
 if (hot_method == method) {
 _hot_method = _method;
 } else {
-_hot_method = JNIHandles::make_global(hot_method);
+_hot_method = hot_method();
 }
+_hot_method_loader = JNIHandles::make_global(_hot_method->method_holder()->class_loader());
 }
 }
 _next = NULL;
 }
 // ------------------------------------------------------------------
 // CompileTask::free
 void CompileTask::free() {
 set_code(NULL);
 assert(!_lock->is_locked(), "Should not be locked when freed");
-if (_hot_method != NULL && _hot_method != _method) {
+JNIHandles::destroy_global(_method_loader);
-JNIHandles::destroy_global(_hot_method);
+JNIHandles::destroy_global(_hot_method_loader);
 }
-JNIHandles::destroy_global(_method);
-}
+void CompileTask::mark_on_stack() {
+// Mark these methods as something redefine classes cannot remove.
+_method->set_on_stack(true);
+if (_hot_method != NULL) {
+_hot_method->set_on_stack(true);
+}
+}
 // ------------------------------------------------------------------
 // CompileTask::print
 void CompileTask::print() {
 tty->print("<CompileTask compile_id=%d ", _compile_id);
 tty->print("method=");
-((methodOop)JNIHandles::resolve(_method))->print_name(tty);
+_method->print_name(tty);
 tty->print_cr(" osr_bci=%d is_blocking=%s is_complete=%s is_success=%s>",
 _osr_bci, bool_to_str(_is_blocking),
 bool_to_str(_is_complete), bool_to_str(_is_success));
 }
 }
 // ------------------------------------------------------------------
 // CompileTask::print_compilation_impl
-void CompileTask::print_compilation_impl(outputStream* st, methodOop method, int compile_id, int comp_level,
+void CompileTask::print_compilation_impl(outputStream* st, Method* method, int compile_id, int comp_level,
 bool is_osr_method, int osr_bci, bool is_blocking,
 const char* msg, bool short_form) {
 if (!short_form) {
 st->print("%7d ", (int) st->time_stamp().milliseconds());  // print timestamp
 }
 }
 // ------------------------------------------------------------------
 // CompileTask::print_compilation
 void CompileTask::print_compilation(outputStream* st, bool short_form) {
-oop rem = JNIHandles::resolve(method_handle());
-assert(rem != NULL && rem->is_method(), "must be");
-methodOop method = (methodOop) rem;
 bool is_osr_method = osr_bci() != InvocationEntryBci;
-print_compilation_impl(st, method, compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), NULL, short_form);
+print_compilation_impl(st, method(), compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), NULL, short_form);
 }
 // ------------------------------------------------------------------
 // CompileTask::log_task
 void CompileTask::log_task(xmlStream* log) {
 Thread* thread = Thread::current();
-methodHandle method(thread,
+methodHandle method(thread, this->method());
-(methodOop)JNIHandles::resolve(method_handle()));
 ResourceMark rm(thread);
 // <task id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'>
 if (_compile_id != 0)   log->print(" compile_id='%d'", _compile_id);
 if (_osr_bci != CompileBroker::standard_entry_bci) {
 log_task(xtty);
 if (_comment != NULL) {
 xtty->print(" comment='%s'", _comment);
 }
 if (_hot_method != NULL) {
-methodHandle hot(thread,
+methodHandle hot(thread, _hot_method);
-(methodOop)JNIHandles::resolve(_hot_method));
+methodHandle method(thread, _method);
-methodHandle method(thread,
-(methodOop)JNIHandles::resolve(_method));
 if (hot() != method()) {
 xtty->method(hot);
 }
 }
 if (_hot_count != 0) {
 // ------------------------------------------------------------------
 // CompileTask::log_task_done
 void CompileTask::log_task_done(CompileLog* log) {
 Thread* thread = Thread::current();
-methodHandle method(thread,
+methodHandle method(thread, this->method());
-(methodOop)JNIHandles::resolve(method_handle()));
 ResourceMark rm(thread);
 // <task_done ... stamp='1.234'>  </task>
 nmethod* nm = code();
 log->begin_elem("task_done success='%d' nmsize='%d' count='%d'",
 _last = task;
 }
 ++_size;
 // Mark the method as being in the compile queue.
-((methodOop)JNIHandles::resolve(task->method_handle()))->set_queued_for_compilation();
+task->method()->set_queued_for_compilation();
 if (CIPrintCompileQueue) {
 print();
 }
 _last = task->prev();
 }
 --_size;
 }
+// methods in the compile queue need to be marked as used on the stack
+// so that they don't get reclaimed by Redefine Classes
+void CompileQueue::mark_on_stack() {
+CompileTask* task = _first;
+while (task != NULL) {
+task->mark_on_stack();
+task = task->next();
+}
+}
 // ------------------------------------------------------------------
 // CompileQueue::print
 void CompileQueue::print() {
 tty->print_cr("Contents of %s", name());
 tty->print_cr("----------------------");
 // ------------------------------------------------------------------
 // CompileBroker::make_compiler_thread
 CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) {
 CompilerThread* compiler_thread = NULL;
-klassOop k =
+Klass* k =
 SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(),
 true, CHECK_0);
 instanceKlassHandle klass (THREAD, k);
 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_0);
 Handle string = java_lang_String::create_from_str(name, CHECK_0);
 }
 if (UsePerfData) {
 PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,
 compiler_count, CHECK);
+}
+}
+// Set the methods on the stack as on_stack so that redefine classes doesn't
+// reclaim them
+void CompileBroker::mark_on_stack() {
+if (_c2_method_queue != NULL) {
+_c2_method_queue->mark_on_stack();
+}
+if (_c1_method_queue != NULL) {
+_c1_method_queue->mark_on_stack();
 }
 }
 // ------------------------------------------------------------------
 // CompileBroker::is_idle
 if (!_initialized ) {
 return;
 }
 guarantee(!method->is_abstract(), "cannot compile abstract methods");
-assert(method->method_holder()->klass_part()->oop_is_instance(),
+assert(method->method_holder()->oop_is_instance(),
 "sanity check");
-assert(!instanceKlass::cast(method->method_holder())->is_not_initialized(),
+assert(!InstanceKlass::cast(method->method_holder())->is_not_initialized(),
 "method holder must be initialized");
 assert(!method->is_method_handle_intrinsic(), "do not enqueue these guys");
 if (CIPrintRequests) {
 tty->print("request: ");
 nmethod* CompileBroker::compile_method(methodHandle method, int osr_bci,
 int comp_level,
 methodHandle hot_method, int hot_count,
 const char* comment, Thread* THREAD) {
 // make sure arguments make sense
-assert(method->method_holder()->klass_part()->oop_is_instance(), "not an instance method");
+assert(method->method_holder()->oop_is_instance(), "not an instance method");
 assert(osr_bci == InvocationEntryBci || (0 <= osr_bci && osr_bci < method->code_size()), "bci out of range");
 assert(!method->is_abstract() && (osr_bci == InvocationEntryBci || !method->is_native()), "cannot compile abstract/native methods");
-assert(!instanceKlass::cast(method->method_holder())->is_not_initialized(), "method holder must be initialized");
+assert(!InstanceKlass::cast(method->method_holder())->is_not_initialized(), "method holder must be initialized");
 if (!TieredCompilation) {
 comp_level = CompLevel_highest_tier;
 }
 // some prerequisites that are compiler specific
 if (compiler(comp_level)->is_c2() || compiler(comp_level)->is_shark()) {
 method->constants()->resolve_string_constants(CHECK_AND_CLEAR_NULL);
 // Resolve all classes seen in the signature of the method
 // we are compiling.
-methodOopDesc::load_signature_classes(method, CHECK_AND_CLEAR_NULL);
+Method::load_signature_classes(method, CHECK_AND_CLEAR_NULL);
 }
 // If the method is native, do the lookup in the thread requesting
 // the compilation. Native lookups can load code, which is not
 // permitted during compilation.
 assert(task->is_blocking(), "can only wait on blocking task");
 JavaThread *thread = JavaThread::current();
 thread->set_blocked_on_compilation(true);
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 {
 MutexLocker waiter(task->lock(), thread);
 while (!task->is_complete())
 task->lock()->wait();
 // Assign the task to the current thread.  Mark this compilation
 // thread as active for the profiler.
 CompileTaskWrapper ctw(task);
 nmethodLocker result_handle;  // (handle for the nmethod produced by this task)
 task->set_code_handle(&result_handle);
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 // Never compile a method if breakpoints are present in it
 if (method()->number_of_breakpoints() == 0) {
 // Compile the method.
 if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
 #endif
 ThreadInVMfromNative tivfn(JavaThread::current());
 }
 }
 // ------------------------------------------------------------------
 // CompileBroker::invoke_compiler_on_method
 //
 // Compile a method.
 //
 {
 // create the handle inside it's own block so it can't
 // accidentally be referenced once the thread transitions to
 // native.  The NoHandleMark before the transition should catch
 // any cases where this occurs in the future.
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 should_break = check_break_at(method, compile_id, is_osr);
 if (should_log && !CompilerOracle::should_log(method)) {
 should_log = false;
 }
 assert(!method->is_native(), "no longer compile natives");
 DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler(task->comp_level()), method);
 }
 // Allocate a new set of JNI handles.
 push_jni_handle_block();
-jobject target_handle = JNIHandles::make_local(thread, JNIHandles::resolve(task->method_handle()));
+Method* target_handle = task->method();
 int compilable = ciEnv::MethodCompilable;
 {
 int system_dictionary_modification_counter;
 {
 MutexLocker locker(Compile_lock, thread);
 }
 }
 }
 pop_jni_handle_block();
-methodHandle method(thread,
+methodHandle method(thread, task->method());
-(methodOop)JNIHandles::resolve(task->method_handle()));
 DTRACE_METHOD_COMPILE_END_PROBE(compiler(task->comp_level()), method, task->is_success());
 collect_statistics(thread, time, task);
 strncpy(_last_method_compiled, method_name, CompileBroker::name_buffer_length);
 char current_method[CompilerCounters::cmname_buffer_length];
 size_t maxLen = CompilerCounters::cmname_buffer_length;
 if (UsePerfData) {
-const char* class_name = method->method_holder()->klass_part()->name()->as_C_string();
+const char* class_name = method->method_holder()->name()->as_C_string();
 size_t s1len = strlen(class_name);
 size_t s2len = strlen(method_name);
 // check if we need to truncate the string
 //
 // Collect statistics about the compilation.
 void CompileBroker::collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task) {
 bool success = task->is_success();
-methodHandle method (thread, (methodOop)JNIHandles::resolve(task->method_handle()));
+methodHandle method (thread, task->method());
 uint compile_id = task->compile_id();
 bool is_osr = (task->osr_bci() != standard_entry_bci);
 nmethod* code = task->code();
 CompilerCounters* counters = thread->counters();

Mercurial > hg > graal-compiler

comparison src/share/vm/compiler/compileBroker.cpp @ 6725:da91efe96a93