< prev index next >

src/hotspot/share/compiler/compileBroker.cpp

Print this page

        

@@ -185,11 +185,11 @@
 
 
 
 class CompilationLog : public StringEventLog {
  public:
-  CompilationLog() : StringEventLog("Compilation events", "jit") {
+  CompilationLog() : StringEventLog("Compilation events") {
   }
 
   void log_compile(JavaThread* thread, CompileTask* task) {
     StringLogMessage lm;
     stringStream sstr(lm.buffer(), lm.size());

@@ -1240,11 +1240,11 @@
     bool in_base_library;
     address adr = NativeLookup::lookup(method, in_base_library, THREAD);
     if (HAS_PENDING_EXCEPTION) {
       // In case of an exception looking up the method, we just forget
       // about it. The interpreter will kick-in and throw the exception.
-      method->set_not_compilable("NativeLookup::lookup failed"); // implies is_not_osr_compilable()
+      method->set_not_compilable(); // implies is_not_osr_compilable()
       CLEAR_PENDING_EXCEPTION;
       return NULL;
     }
     assert(method->has_native_function(), "must have native code by now");
   }

@@ -1368,19 +1368,19 @@
   bool is_native = method->is_native();
   // Some compilers may not support the compilation of natives.
   AbstractCompiler *comp = compiler(comp_level);
   if (is_native &&
       (!CICompileNatives || comp == NULL || !comp->supports_native())) {
-    method->set_not_compilable_quietly("native methods not supported", comp_level);
+    method->set_not_compilable_quietly(comp_level);
     return true;
   }
 
   bool is_osr = (osr_bci != standard_entry_bci);
   // Some compilers may not support on stack replacement.
   if (is_osr &&
       (!CICompileOSR || comp == NULL || !comp->supports_osr())) {
-    method->set_not_osr_compilable("OSR not supported", comp_level);
+    method->set_not_osr_compilable(comp_level);
     return true;
   }
 
   // The method may be explicitly excluded by the user.
   double scale;

@@ -1393,11 +1393,11 @@
                  method->is_native() ? "generation of native wrapper" : "compile",
                  (method->is_static() ? " static" : ""));
       method->print_short_name(tty);
       tty->cr();
     }
-    method->set_not_compilable("excluded by CompileCommand", comp_level, !quietly);
+    method->set_not_compilable(comp_level, !quietly, "excluded by CompileCommand");
   }
 
   return false;
 }
 

@@ -1426,11 +1426,11 @@
       return id;
     }
   }
 
   // Method was not in the appropriate compilation range.
-  method->set_not_compilable_quietly("Not in requested compile id range");
+  method->set_not_compilable_quietly();
   return 0;
 #else
   // CICountOSR is a develop flag and set to 'false' by default. In a product built,
   // only _compilation_id is incremented.
   return Atomic::add(1, &_compilation_id);

@@ -2193,19 +2193,19 @@
   }
   // Disable compilation, if required.
   switch (compilable) {
   case ciEnv::MethodCompilable_never:
     if (is_osr)
-      method->set_not_osr_compilable_quietly("MethodCompilable_never");
+      method->set_not_osr_compilable_quietly();
     else
-      method->set_not_compilable_quietly("MethodCompilable_never");
+      method->set_not_compilable_quietly();
     break;
   case ciEnv::MethodCompilable_not_at_tier:
     if (is_osr)
-      method->set_not_osr_compilable_quietly("MethodCompilable_not_at_tier", task_level);
+      method->set_not_osr_compilable_quietly(task_level);
     else
-      method->set_not_compilable_quietly("MethodCompilable_not_at_tier", task_level);
+      method->set_not_compilable_quietly(task_level);
     break;
   }
 
   // Note that the queued_for_compilation bits are cleared without
   // protection of a mutex. [They were set by the requester thread,

@@ -2638,11 +2638,11 @@
 // Note: tty_lock must not be held upon entry to this function.
 //       Print functions called from herein do "micro-locking" on tty_lock.
 //       That's a tradeoff which keeps together important blocks of output.
 //       At the same time, continuous tty_lock hold time is kept in check,
 //       preventing concurrently printing threads from stalling a long time.
-void CompileBroker::print_heapinfo(outputStream* out, const char* function, size_t granularity) {
+void CompileBroker::print_heapinfo(outputStream* out, const char* function, const char* granularity) {
   TimeStamp ts_total;
   TimeStamp ts_global;
   TimeStamp ts;
 
   bool allFun = !strcmp(function, "all");
< prev index next >