compileBroker.cpp 80.4 KB
Newer Older
D
duke 已提交
1
/*
S
sla 已提交
2
 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25 26 27 28 29 30 31 32 33
#include "precompiled.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
#include "code/codeCache.hpp"
#include "compiler/compileBroker.hpp"
#include "compiler/compileLog.hpp"
#include "compiler/compilerOracle.hpp"
#include "interpreter/linkResolver.hpp"
#include "memory/allocation.inline.hpp"
34 35
#include "oops/methodData.hpp"
#include "oops/method.hpp"
36 37 38 39 40 41 42 43 44 45
#include "oops/oop.inline.hpp"
#include "prims/nativeLookup.hpp"
#include "runtime/arguments.hpp"
#include "runtime/compilationPolicy.hpp"
#include "runtime/init.hpp"
#include "runtime/interfaceSupport.hpp"
#include "runtime/javaCalls.hpp"
#include "runtime/os.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/sweeper.hpp"
S
sla 已提交
46
#include "trace/tracing.hpp"
47
#include "utilities/dtrace.hpp"
48
#include "utilities/events.hpp"
49 50 51 52 53 54 55 56 57
#ifdef COMPILER1
#include "c1/c1_Compiler.hpp"
#endif
#ifdef COMPILER2
#include "opto/c2compiler.hpp"
#endif
#ifdef SHARK
#include "shark/sharkCompiler.hpp"
#endif
D
duke 已提交
58 59 60 61 62

#ifdef DTRACE_ENABLED

// Only bother with this argument setup if dtrace is available

D
dcubed 已提交
63
#ifndef USDT2
D
duke 已提交
64 65 66 67 68
HS_DTRACE_PROBE_DECL8(hotspot, method__compile__begin,
  char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t);
HS_DTRACE_PROBE_DECL9(hotspot, method__compile__end,
  char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t, bool);

69
#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name)             \
D
duke 已提交
70
  {                                                                      \
71 72 73
    Symbol* klass_name = (method)->klass_name();                         \
    Symbol* name = (method)->name();                                     \
    Symbol* signature = (method)->signature();                           \
D
duke 已提交
74 75 76 77 78 79 80
    HS_DTRACE_PROBE8(hotspot, method__compile__begin,                    \
      comp_name, strlen(comp_name),                                      \
      klass_name->bytes(), klass_name->utf8_length(),                    \
      name->bytes(), name->utf8_length(),                                \
      signature->bytes(), signature->utf8_length());                     \
  }

81
#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success)      \
D
duke 已提交
82
  {                                                                      \
83 84 85
    Symbol* klass_name = (method)->klass_name();                         \
    Symbol* name = (method)->name();                                     \
    Symbol* signature = (method)->signature();                           \
D
duke 已提交
86 87 88 89 90 91 92
    HS_DTRACE_PROBE9(hotspot, method__compile__end,                      \
      comp_name, strlen(comp_name),                                      \
      klass_name->bytes(), klass_name->utf8_length(),                    \
      name->bytes(), name->utf8_length(),                                \
      signature->bytes(), signature->utf8_length(), (success));          \
  }

D
dcubed 已提交
93 94
#else /* USDT2 */

95
#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name)             \
D
dcubed 已提交
96 97 98 99
  {                                                                      \
    Symbol* klass_name = (method)->klass_name();                         \
    Symbol* name = (method)->name();                                     \
    Symbol* signature = (method)->signature();                           \
100
    HOTSPOT_METHOD_COMPILE_BEGIN(                                        \
D
dcubed 已提交
101
      comp_name, strlen(comp_name),                                      \
102
      (char *) klass_name->bytes(), klass_name->utf8_length(),           \
D
dcubed 已提交
103 104 105 106
      (char *) name->bytes(), name->utf8_length(),                       \
      (char *) signature->bytes(), signature->utf8_length());            \
  }

107
#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success)      \
D
dcubed 已提交
108 109 110 111 112 113 114 115 116 117 118 119
  {                                                                      \
    Symbol* klass_name = (method)->klass_name();                         \
    Symbol* name = (method)->name();                                     \
    Symbol* signature = (method)->signature();                           \
    HOTSPOT_METHOD_COMPILE_END(                                          \
      comp_name, strlen(comp_name),                                      \
      (char *) klass_name->bytes(), klass_name->utf8_length(),           \
      (char *) name->bytes(), name->utf8_length(),                       \
      (char *) signature->bytes(), signature->utf8_length(), (success)); \
  }
#endif /* USDT2 */

D
duke 已提交
120 121
#else //  ndef DTRACE_ENABLED

122 123
#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name)
#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success)
D
duke 已提交
124 125 126 127 128

#endif // ndef DTRACE_ENABLED

bool CompileBroker::_initialized = false;
volatile bool CompileBroker::_should_block = false;
129
volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;
D
duke 已提交
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182

// The installed compiler(s)
AbstractCompiler* CompileBroker::_compilers[2];

// These counters are used for assigning id's to each compilation
uint CompileBroker::_compilation_id        = 0;
uint CompileBroker::_osr_compilation_id    = 0;

// Debugging information
int  CompileBroker::_last_compile_type     = no_compile;
int  CompileBroker::_last_compile_level    = CompLevel_none;
char CompileBroker::_last_method_compiled[CompileBroker::name_buffer_length];

// Performance counters
PerfCounter* CompileBroker::_perf_total_compilation = NULL;
PerfCounter* CompileBroker::_perf_osr_compilation = NULL;
PerfCounter* CompileBroker::_perf_standard_compilation = NULL;

PerfCounter* CompileBroker::_perf_total_bailout_count = NULL;
PerfCounter* CompileBroker::_perf_total_invalidated_count = NULL;
PerfCounter* CompileBroker::_perf_total_compile_count = NULL;
PerfCounter* CompileBroker::_perf_total_osr_compile_count = NULL;
PerfCounter* CompileBroker::_perf_total_standard_compile_count = NULL;

PerfCounter* CompileBroker::_perf_sum_osr_bytes_compiled = NULL;
PerfCounter* CompileBroker::_perf_sum_standard_bytes_compiled = NULL;
PerfCounter* CompileBroker::_perf_sum_nmethod_size = NULL;
PerfCounter* CompileBroker::_perf_sum_nmethod_code_size = NULL;

PerfStringVariable* CompileBroker::_perf_last_method = NULL;
PerfStringVariable* CompileBroker::_perf_last_failed_method = NULL;
PerfStringVariable* CompileBroker::_perf_last_invalidated_method = NULL;
PerfVariable*       CompileBroker::_perf_last_compile_type = NULL;
PerfVariable*       CompileBroker::_perf_last_compile_size = NULL;
PerfVariable*       CompileBroker::_perf_last_failed_type = NULL;
PerfVariable*       CompileBroker::_perf_last_invalidated_type = NULL;

// Timers and counters for generating statistics
elapsedTimer CompileBroker::_t_total_compilation;
elapsedTimer CompileBroker::_t_osr_compilation;
elapsedTimer CompileBroker::_t_standard_compilation;

int CompileBroker::_total_bailout_count          = 0;
int CompileBroker::_total_invalidated_count      = 0;
int CompileBroker::_total_compile_count          = 0;
int CompileBroker::_total_osr_compile_count      = 0;
int CompileBroker::_total_standard_compile_count = 0;

int CompileBroker::_sum_osr_bytes_compiled       = 0;
int CompileBroker::_sum_standard_bytes_compiled  = 0;
int CompileBroker::_sum_nmethod_size             = 0;
int CompileBroker::_sum_nmethod_code_size        = 0;

S
sla 已提交
183 184 185 186 187
long CompileBroker::_peak_compilation_time       = 0;

CompileQueue* CompileBroker::_c2_method_queue    = NULL;
CompileQueue* CompileBroker::_c1_method_queue    = NULL;
CompileTask*  CompileBroker::_task_free_list     = NULL;
D
duke 已提交
188 189 190 191

GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;


192 193 194 195 196 197 198
class CompilationLog : public StringEventLog {
 public:
  CompilationLog() : StringEventLog("Compilation events") {
  }

  void log_compile(JavaThread* thread, CompileTask* task) {
    StringLogMessage lm;
199
    stringStream sstr = lm.stream();
200
    // msg.time_stamp().update_to(tty->time_stamp().ticks());
201
    task->print_compilation(&sstr, NULL, true);
202 203 204 205
    log(thread, "%s", (const char*)lm);
  }

  void log_nmethod(JavaThread* thread, nmethod* nm) {
N
never 已提交
206 207
    log(thread, "nmethod %d%s " INTPTR_FORMAT " code ["INTPTR_FORMAT ", " INTPTR_FORMAT "]",
        nm->compile_id(), nm->is_osr_method() ? "%" : "",
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
        nm, nm->code_begin(), nm->code_end());
  }

  void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) {
    StringLogMessage lm;
    lm.print("%4d   COMPILE SKIPPED: %s", task->compile_id(), reason);
    if (retry_message != NULL) {
      lm.append(" (%s)", retry_message);
    }
    lm.print("\n");
    log(thread, "%s", (const char*)lm);
  }
};

static CompilationLog* _compilation_log = NULL;

void compileBroker_init() {
  if (LogEvents) {
    _compilation_log = new CompilationLog();
  }
}

D
duke 已提交
230 231 232 233 234 235 236 237 238 239 240 241 242 243
CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {
  CompilerThread* thread = CompilerThread::current();
  thread->set_task(task);
  CompileLog*     log  = thread->log();
  if (log != NULL)  task->log_task_start(log);
}

CompileTaskWrapper::~CompileTaskWrapper() {
  CompilerThread* thread = CompilerThread::current();
  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);
244
  thread->set_env(NULL);
D
duke 已提交
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
  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();
  } else {
    task->mark_complete();

    // By convention, the compiling thread is responsible for
    // recycling a non-blocking CompileTask.
    CompileBroker::free_task(task);
  }
}


// ------------------------------------------------------------------
// CompileTask::initialize
void CompileTask::initialize(int compile_id,
                             methodHandle method,
                             int osr_bci,
                             int comp_level,
                             methodHandle hot_method,
                             int hot_count,
                             const char* comment,
                             bool is_blocking) {
  assert(!_lock->is_locked(), "bad locking");

  _compile_id = compile_id;
273
  _method = method();
274
  _method_holder = JNIHandles::make_global(method->method_holder()->klass_holder());
D
duke 已提交
275 276 277 278 279 280 281 282 283 284
  _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;
285
  _hot_method_holder = NULL;
D
duke 已提交
286 287 288 289 290 291 292 293 294 295
  _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 {
296
        _hot_method = hot_method();
297
        // only add loader or mirror if different from _method_holder
298
        _hot_method_holder = JNIHandles::make_global(hot_method->method_holder()->klass_holder());
D
duke 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
      }
    }
  }

  _next = NULL;
}

// ------------------------------------------------------------------
// CompileTask::code/set_code
nmethod* CompileTask::code() const {
  if (_code_handle == NULL)  return NULL;
  return _code_handle->code();
}
void CompileTask::set_code(nmethod* nm) {
  if (_code_handle == NULL && nm == NULL)  return;
  guarantee(_code_handle != NULL, "");
  _code_handle->set_code(nm);
  if (nm == NULL)  _code_handle = NULL;  // drop the handle also
}

// ------------------------------------------------------------------
// CompileTask::free
void CompileTask::free() {
  set_code(NULL);
  assert(!_lock->is_locked(), "Should not be locked when freed");
324 325
  JNIHandles::destroy_global(_method_holder);
  JNIHandles::destroy_global(_hot_method_holder);
D
duke 已提交
326 327 328
}


329 330 331 332 333 334 335 336
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);
  }
}

D
duke 已提交
337 338 339 340 341
// ------------------------------------------------------------------
// CompileTask::print
void CompileTask::print() {
  tty->print("<CompileTask compile_id=%d ", _compile_id);
  tty->print("method=");
342
  _method->print_name(tty);
D
duke 已提交
343 344 345 346 347
  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));
}

I
iveresov 已提交
348

D
duke 已提交
349 350 351 352 353 354 355 356 357 358 359 360
// ------------------------------------------------------------------
// CompileTask::print_line_on_error
//
// This function is called by fatal error handler when the thread
// causing troubles is a compiler thread.
//
// Do not grab any lock, do not allocate memory.
//
// Otherwise it's the same as CompileTask::print_line()
//
void CompileTask::print_line_on_error(outputStream* st, char* buf, int buflen) {
  // print compiler name
361
  st->print("%s:", CompileBroker::compiler_name(comp_level()));
362
  print_compilation(st);
D
duke 已提交
363 364 365 366 367 368 369
}

// ------------------------------------------------------------------
// CompileTask::print_line
void CompileTask::print_line() {
  ttyLocker ttyl;  // keep the following output all in one block
  // print compiler name if requested
370
  if (CIPrintCompilerName) tty->print("%s:", CompileBroker::compiler_name(comp_level()));
371 372 373 374 375 376
  print_compilation();
}


// ------------------------------------------------------------------
// CompileTask::print_compilation_impl
377
void CompileTask::print_compilation_impl(outputStream* st, Method* method, int compile_id, int comp_level,
378 379 380 381 382
                                         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
  }
383 384
  st->print("%4d ", compile_id);    // print compilation number

385 386 387 388 389 390 391 392 393 394 395
  // For unloaded methods the transition to zombie occurs after the
  // method is cleared so it's impossible to report accurate
  // information for that case.
  bool is_synchronized = false;
  bool has_exception_handler = false;
  bool is_native = false;
  if (method != NULL) {
    is_synchronized       = method->is_synchronized();
    has_exception_handler = method->has_exception_handler();
    is_native             = method->is_native();
  }
396 397
  // method attributes
  const char compile_type   = is_osr_method                   ? '%' : ' ';
398 399
  const char sync_char      = is_synchronized                 ? 's' : ' ';
  const char exception_char = has_exception_handler           ? '!' : ' ';
400
  const char blocking_char  = is_blocking                     ? 'b' : ' ';
401
  const char native_char    = is_native                       ? 'n' : ' ';
402 403 404 405 406 407 408 409 410 411

  // print method attributes
  st->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, native_char);

  if (TieredCompilation) {
    if (comp_level != -1)  st->print("%d ", comp_level);
    else                   st->print("- ");
  }
  st->print("     ");  // more indent

412 413 414 415 416 417 418
  if (method == NULL) {
    st->print("(method)");
  } else {
    method->print_short_name(st);
    if (is_osr_method) {
      st->print(" @ %d", osr_bci);
    }
419 420 421 422
    if (method->is_native())
      st->print(" (native)");
    else
      st->print(" (%d bytes)", method->code_size());
423 424 425 426 427
  }

  if (msg != NULL) {
    st->print("   %s", msg);
  }
428 429 430
  if (!short_form) {
    st->cr();
  }
431 432 433 434 435 436 437 438 439 440 441
}

// ------------------------------------------------------------------
// CompileTask::print_inlining
void CompileTask::print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg) {
  //         1234567
  st->print("        ");     // print timestamp
  //         1234
  st->print("     ");        // print compilation number

  // method attributes
442 443 444 445
  if (method->is_loaded()) {
    const char sync_char      = method->is_synchronized()        ? 's' : ' ';
    const char exception_char = method->has_exception_handlers() ? '!' : ' ';
    const char monitors_char  = method->has_monitor_bytecodes()  ? 'm' : ' ';
446

447 448 449 450 451 452
    // print method attributes
    st->print(" %c%c%c  ", sync_char, exception_char, monitors_char);
  } else {
    //         %s!bn
    st->print("      ");     // print method attributes
  }
453 454 455 456 457 458 459 460 461 462 463

  if (TieredCompilation) {
    st->print("  ");
  }
  st->print("     ");        // more indent
  st->print("    ");         // initial inlining indent

  for (int i = 0; i < inline_level; i++)  st->print("  ");

  st->print("@ %d  ", bci);  // print bci
  method->print_short_name(st);
464 465 466 467
  if (method->is_loaded())
    st->print(" (%d bytes)", method->code_size());
  else
    st->print(" (not loaded)");
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489

  if (msg != NULL) {
    st->print("   %s", msg);
  }
  st->cr();
}

// ------------------------------------------------------------------
// CompileTask::print_inline_indent
void CompileTask::print_inline_indent(int inline_level, outputStream* st) {
  //         1234567
  st->print("        ");     // print timestamp
  //         1234
  st->print("     ");        // print compilation number
  //         %s!bn
  st->print("      ");       // print method attributes
  if (TieredCompilation) {
    st->print("  ");
  }
  st->print("     ");        // more indent
  st->print("    ");         // initial inlining indent
  for (int i = 0; i < inline_level; i++)  st->print("  ");
D
duke 已提交
490 491
}

492 493
// ------------------------------------------------------------------
// CompileTask::print_compilation
494
void CompileTask::print_compilation(outputStream* st, const char* msg, bool short_form) {
495
  bool is_osr_method = osr_bci() != InvocationEntryBci;
496
  print_compilation_impl(st, method(), compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), msg, short_form);
497
}
D
duke 已提交
498 499 500 501 502

// ------------------------------------------------------------------
// CompileTask::log_task
void CompileTask::log_task(xmlStream* log) {
  Thread* thread = Thread::current();
503
  methodHandle method(thread, this->method());
D
duke 已提交
504 505 506
  ResourceMark rm(thread);

  // <task id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'>
507
  log->print(" compile_id='%d'", _compile_id);
D
duke 已提交
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
  if (_osr_bci != CompileBroker::standard_entry_bci) {
    log->print(" compile_kind='osr'");  // same as nmethod::compile_kind
  } // else compile_kind='c2c'
  if (!method.is_null())  log->method(method);
  if (_osr_bci != CompileBroker::standard_entry_bci) {
    log->print(" osr_bci='%d'", _osr_bci);
  }
  if (_comp_level != CompLevel_highest_tier) {
    log->print(" level='%d'", _comp_level);
  }
  if (_is_blocking) {
    log->print(" blocking='1'");
  }
  log->stamp();
}


// ------------------------------------------------------------------
// CompileTask::log_task_queued
void CompileTask::log_task_queued() {
  Thread* thread = Thread::current();
  ttyLocker ttyl;
  ResourceMark rm(thread);

  xtty->begin_elem("task_queued");
  log_task(xtty);
  if (_comment != NULL) {
    xtty->print(" comment='%s'", _comment);
  }
  if (_hot_method != NULL) {
538 539
    methodHandle hot(thread, _hot_method);
    methodHandle method(thread, _method);
D
duke 已提交
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
    if (hot() != method()) {
      xtty->method(hot);
    }
  }
  if (_hot_count != 0) {
    xtty->print(" hot_count='%d'", _hot_count);
  }
  xtty->end_elem();
}


// ------------------------------------------------------------------
// CompileTask::log_task_start
void CompileTask::log_task_start(CompileLog* log)   {
  log->begin_head("task");
  log_task(log);
  log->end_head();
}


// ------------------------------------------------------------------
// CompileTask::log_task_done
void CompileTask::log_task_done(CompileLog* log) {
  Thread* thread = Thread::current();
564
  methodHandle method(thread, this->method());
D
duke 已提交
565 566 567 568 569
  ResourceMark rm(thread);

  // <task_done ... stamp='1.234'>  </task>
  nmethod* nm = code();
  log->begin_elem("task_done success='%d' nmsize='%d' count='%d'",
T
twisti 已提交
570
                  _is_success, nm == NULL ? 0 : nm->content_size(),
D
duke 已提交
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
                  method->invocation_count());
  int bec = method->backedge_count();
  if (bec != 0)  log->print(" backedge_count='%d'", bec);
  // Note:  "_is_complete" is about to be set, but is not.
  if (_num_inlined_bytecodes != 0) {
    log->print(" inlined_bytes='%d'", _num_inlined_bytecodes);
  }
  log->stamp();
  log->end_elem();
  log->tail("task");
  log->clear_identities();   // next task will have different CI
  if (log->unflushed_count() > 2000) {
    log->flush();
  }
  log->mark_file_end();
}



// ------------------------------------------------------------------
// CompileQueue::add
//
// Add a CompileTask to a CompileQueue
void CompileQueue::add(CompileTask* task) {
  assert(lock()->owned_by_self(), "must own lock");

  task->set_next(NULL);
I
iveresov 已提交
598
  task->set_prev(NULL);
D
duke 已提交
599 600 601 602 603 604 605 606 607 608

  if (_last == NULL) {
    // The compile queue is empty.
    assert(_first == NULL, "queue is empty");
    _first = task;
    _last = task;
  } else {
    // Append the task to the queue.
    assert(_last->next() == NULL, "not last");
    _last->set_next(task);
I
iveresov 已提交
609
    task->set_prev(_last);
D
duke 已提交
610 611
    _last = task;
  }
I
iveresov 已提交
612
  ++_size;
D
duke 已提交
613 614

  // Mark the method as being in the compile queue.
615
  task->method()->set_queued_for_compilation();
D
duke 已提交
616 617 618 619 620 621 622 623 624 625

  if (CIPrintCompileQueue) {
    print();
  }

  if (LogCompilation && xtty != NULL) {
    task->log_task_queued();
  }

  // Notify CompilerThreads that a task is available.
I
iveresov 已提交
626
  lock()->notify_all();
D
duke 已提交
627 628 629 630 631 632 633
}

// ------------------------------------------------------------------
// CompileQueue::get
//
// Get the next CompileTask from a CompileQueue
CompileTask* CompileQueue::get() {
634 635
  NMethodSweeper::possibly_sweep();

D
duke 已提交
636
  MutexLocker locker(lock());
637 638 639 640 641
  // If _first is NULL we have no more compile jobs. There are two reasons for
  // having no compile jobs: First, we compiled everything we wanted. Second,
  // we ran out of code cache so compilation has been disabled. In the latter
  // case we perform code cache sweeps to free memory such that we can re-enable
  // compilation.
D
duke 已提交
642
  while (_first == NULL) {
643 644 645 646 647 648 649 650 651 652 653 654 655 656
    if (UseCodeCacheFlushing && !CompileBroker::should_compile_new_jobs()) {
      // Wait a certain amount of time to possibly do another sweep.
      // We must wait until stack scanning has happened so that we can
      // transition a method's state from 'not_entrant' to 'zombie'.
      long wait_time = NmethodSweepCheckInterval * 1000;
      if (FLAG_IS_DEFAULT(NmethodSweepCheckInterval)) {
        // Only one thread at a time can do sweeping. Scale the
        // wait time according to the number of compiler threads.
        // As a result, the next sweep is likely to happen every 100ms
        // with an arbitrary number of threads that do sweeping.
        wait_time = 100 * CICompilerCount;
      }
      bool timeout = lock()->wait(!Mutex::_no_safepoint_check_flag, wait_time);
      if (timeout) {
657 658 659 660
        MutexUnlocker ul(lock());
        NMethodSweeper::possibly_sweep();
      }
    } else {
661 662 663 664 665 666
      // If there are no compilation tasks and we can compile new jobs
      // (i.e., there is enough free space in the code cache) there is
      // no need to invoke the sweeper. As a result, the hotness of methods
      // remains unchanged. This behavior is desired, since we want to keep
      // the stable state, i.e., we do not want to evict methods from the
      // code cache if it is unnecessary.
667 668
      lock()->wait();
    }
D
duke 已提交
669
  }
I
iveresov 已提交
670 671 672 673
  CompileTask* task = CompilationPolicy::policy()->select_task(this);
  remove(task);
  return task;
}
D
duke 已提交
674

I
iveresov 已提交
675 676 677 678 679 680 681 682 683
void CompileQueue::remove(CompileTask* task)
{
   assert(lock()->owned_by_self(), "must own lock");
  if (task->prev() != NULL) {
    task->prev()->set_next(task->next());
  } else {
    // max is the first element
    assert(task == _first, "Sanity");
    _first = task->next();
D
duke 已提交
684 685
  }

I
iveresov 已提交
686 687 688 689 690 691 692 693
  if (task->next() != NULL) {
    task->next()->set_prev(task->prev());
  } else {
    // max is the last element
    assert(task == _last, "Sanity");
    _last = task->prev();
  }
  --_size;
D
duke 已提交
694 695
}

696 697 698 699 700 701 702 703 704 705
// 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();
  }
}

D
duke 已提交
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
// ------------------------------------------------------------------
// CompileQueue::print
void CompileQueue::print() {
  tty->print_cr("Contents of %s", name());
  tty->print_cr("----------------------");
  CompileTask* task = _first;
  while (task != NULL) {
    task->print_line();
    task = task->next();
  }
  tty->print_cr("----------------------");
}

CompilerCounters::CompilerCounters(const char* thread_name, int instance, TRAPS) {

  _current_method[0] = '\0';
  _compile_type = CompileBroker::no_compile;

  if (UsePerfData) {
    ResourceMark rm;

    // create the thread instance name space string - don't create an
    // instance subspace if instance is -1 - keeps the adapterThread
    // counters  from having a ".0" namespace.
    const char* thread_i = (instance == -1) ? thread_name :
                      PerfDataManager::name_space(thread_name, instance);


    char* name = PerfDataManager::counter_name(thread_i, "method");
    _perf_current_method =
               PerfDataManager::create_string_variable(SUN_CI, name,
                                                       cmname_buffer_length,
                                                       _current_method, CHECK);

    name = PerfDataManager::counter_name(thread_i, "type");
    _perf_compile_type = PerfDataManager::create_variable(SUN_CI, name,
                                                          PerfData::U_None,
                                                         (jlong)_compile_type,
                                                          CHECK);

    name = PerfDataManager::counter_name(thread_i, "time");
    _perf_time = PerfDataManager::create_counter(SUN_CI, name,
                                                 PerfData::U_Ticks, CHECK);

    name = PerfDataManager::counter_name(thread_i, "compiles");
    _perf_compiles = PerfDataManager::create_counter(SUN_CI, name,
                                                     PerfData::U_Events, CHECK);
  }
}

// ------------------------------------------------------------------
// CompileBroker::compilation_init
//
// Initialize the Compilation object
void CompileBroker::compilation_init() {
  _last_method_compiled[0] = '\0';

T
twisti 已提交
763
#ifndef SHARK
D
duke 已提交
764
  // Set the interface to the current compiler(s).
I
iveresov 已提交
765 766
  int c1_count = CompilationPolicy::policy()->compiler_count(CompLevel_simple);
  int c2_count = CompilationPolicy::policy()->compiler_count(CompLevel_full_optimization);
D
duke 已提交
767
#ifdef COMPILER1
I
iveresov 已提交
768 769 770
  if (c1_count > 0) {
    _compilers[0] = new Compiler();
  }
D
duke 已提交
771 772 773
#endif // COMPILER1

#ifdef COMPILER2
I
iveresov 已提交
774 775 776
  if (c2_count > 0) {
    _compilers[1] = new C2Compiler();
  }
D
duke 已提交
777 778
#endif // COMPILER2

T
twisti 已提交
779 780 781 782 783 784
#else // SHARK
  int c1_count = 0;
  int c2_count = 1;

  _compilers[1] = new SharkCompiler();
#endif // SHARK
785

D
duke 已提交
786 787 788 789
  // Initialize the CompileTask free list
  _task_free_list = NULL;

  // Start the CompilerThreads
I
iveresov 已提交
790
  init_compiler_threads(c1_count, c2_count);
D
duke 已提交
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
  // totalTime performance counter is always created as it is required
  // by the implementation of java.lang.management.CompilationMBean.
  {
    EXCEPTION_MARK;
    _perf_total_compilation =
                 PerfDataManager::create_counter(JAVA_CI, "totalTime",
                                                 PerfData::U_Ticks, CHECK);
  }


  if (UsePerfData) {

    EXCEPTION_MARK;

    // create the jvmstat performance counters
    _perf_osr_compilation =
                 PerfDataManager::create_counter(SUN_CI, "osrTime",
                                                 PerfData::U_Ticks, CHECK);

    _perf_standard_compilation =
                 PerfDataManager::create_counter(SUN_CI, "standardTime",
                                                 PerfData::U_Ticks, CHECK);

    _perf_total_bailout_count =
                 PerfDataManager::create_counter(SUN_CI, "totalBailouts",
                                                 PerfData::U_Events, CHECK);

    _perf_total_invalidated_count =
                 PerfDataManager::create_counter(SUN_CI, "totalInvalidates",
                                                 PerfData::U_Events, CHECK);

    _perf_total_compile_count =
                 PerfDataManager::create_counter(SUN_CI, "totalCompiles",
                                                 PerfData::U_Events, CHECK);
    _perf_total_osr_compile_count =
                 PerfDataManager::create_counter(SUN_CI, "osrCompiles",
                                                 PerfData::U_Events, CHECK);

    _perf_total_standard_compile_count =
                 PerfDataManager::create_counter(SUN_CI, "standardCompiles",
                                                 PerfData::U_Events, CHECK);

    _perf_sum_osr_bytes_compiled =
                 PerfDataManager::create_counter(SUN_CI, "osrBytes",
                                                 PerfData::U_Bytes, CHECK);

    _perf_sum_standard_bytes_compiled =
                 PerfDataManager::create_counter(SUN_CI, "standardBytes",
                                                 PerfData::U_Bytes, CHECK);

    _perf_sum_nmethod_size =
                 PerfDataManager::create_counter(SUN_CI, "nmethodSize",
                                                 PerfData::U_Bytes, CHECK);

    _perf_sum_nmethod_code_size =
                 PerfDataManager::create_counter(SUN_CI, "nmethodCodeSize",
                                                 PerfData::U_Bytes, CHECK);

    _perf_last_method =
                 PerfDataManager::create_string_variable(SUN_CI, "lastMethod",
                                       CompilerCounters::cmname_buffer_length,
                                       "", CHECK);

    _perf_last_failed_method =
            PerfDataManager::create_string_variable(SUN_CI, "lastFailedMethod",
                                       CompilerCounters::cmname_buffer_length,
                                       "", CHECK);

    _perf_last_invalidated_method =
        PerfDataManager::create_string_variable(SUN_CI, "lastInvalidatedMethod",
                                     CompilerCounters::cmname_buffer_length,
                                     "", CHECK);

    _perf_last_compile_type =
             PerfDataManager::create_variable(SUN_CI, "lastType",
                                              PerfData::U_None,
                                              (jlong)CompileBroker::no_compile,
                                              CHECK);

    _perf_last_compile_size =
             PerfDataManager::create_variable(SUN_CI, "lastSize",
                                              PerfData::U_Bytes,
                                              (jlong)CompileBroker::no_compile,
                                              CHECK);


    _perf_last_failed_type =
             PerfDataManager::create_variable(SUN_CI, "lastFailedType",
                                              PerfData::U_None,
                                              (jlong)CompileBroker::no_compile,
                                              CHECK);

    _perf_last_invalidated_type =
         PerfDataManager::create_variable(SUN_CI, "lastInvalidatedType",
                                          PerfData::U_None,
                                          (jlong)CompileBroker::no_compile,
                                          CHECK);
  }

  _initialized = true;
}



// ------------------------------------------------------------------
// CompileBroker::make_compiler_thread
CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) {
  CompilerThread* compiler_thread = NULL;

900
  Klass* k =
901
    SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(),
D
duke 已提交
902 903 904 905 906 907 908 909 910 911
                                      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);

  // Initialize thread_oop to put it into the system threadGroup
  Handle thread_group (THREAD,  Universe::system_thread_group());
  JavaValue result(T_VOID);
  JavaCalls::call_special(&result, thread_oop,
                       klass,
912 913
                       vmSymbols::object_initializer_name(),
                       vmSymbols::threadgroup_string_void_signature(),
D
duke 已提交
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
                       thread_group,
                       string,
                       CHECK_0);

  {
    MutexLocker mu(Threads_lock, THREAD);
    compiler_thread = new CompilerThread(queue, counters);
    // At this point the new CompilerThread data-races with this startup
    // thread (which I believe is the primoridal thread and NOT the VM
    // thread).  This means Java bytecodes being executed at startup can
    // queue compile jobs which will run at whatever default priority the
    // newly created CompilerThread runs at.


    // At this point it may be possible that no osthread was created for the
    // JavaThread due to lack of memory. We would have to throw an exception
    // in that case. However, since this must work and we do not allow
    // exceptions anyway, check and abort if this fails.

    if (compiler_thread == NULL || compiler_thread->osthread() == NULL){
      vm_exit_during_initialization("java.lang.OutOfMemoryError",
                                    "unable to create new native thread");
    }

    java_lang_Thread::set_thread(thread_oop(), compiler_thread);

    // Note that this only sets the JavaThread _priority field, which by
    // definition is limited to Java priorities and not OS priorities.
    // The os-priority is set in the CompilerThread startup code itself
943

D
duke 已提交
944
    java_lang_Thread::set_priority(thread_oop(), NearMaxPriority);
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959

    // Note that we cannot call os::set_priority because it expects Java
    // priorities and we are *explicitly* using OS priorities so that it's
    // possible to set the compiler thread priority higher than any Java
    // thread.

    int native_prio = CompilerThreadPriority;
    if (native_prio == -1) {
      if (UseCriticalCompilerThreadPriority) {
        native_prio = os::java_to_os_priority[CriticalPriority];
      } else {
        native_prio = os::java_to_os_priority[NearMaxPriority];
      }
    }
    os::set_native_priority(compiler_thread, native_prio);
D
duke 已提交
960 961 962 963 964 965 966

    java_lang_Thread::set_daemon(thread_oop());

    compiler_thread->set_threadObj(thread_oop());
    Threads::add(compiler_thread);
    Thread::start(compiler_thread);
  }
967

D
duke 已提交
968 969 970 971 972 973 974 975 976 977 978
  // Let go of Threads_lock before yielding
  os::yield(); // make sure that the compiler thread is started early (especially helpful on SOLARIS)

  return compiler_thread;
}


// ------------------------------------------------------------------
// CompileBroker::init_compiler_threads
//
// Initialize the compilation queue
I
iveresov 已提交
979
void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) {
D
duke 已提交
980
  EXCEPTION_MARK;
T
twisti 已提交
981
#if !defined(ZERO) && !defined(SHARK)
I
iveresov 已提交
982
  assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");
T
twisti 已提交
983
#endif // !ZERO && !SHARK
I
iveresov 已提交
984 985 986 987 988 989 990 991
  if (c2_compiler_count > 0) {
    _c2_method_queue  = new CompileQueue("C2MethodQueue",  MethodCompileQueue_lock);
  }
  if (c1_compiler_count > 0) {
    _c1_method_queue  = new CompileQueue("C1MethodQueue",  MethodCompileQueue_lock);
  }

  int compiler_count = c1_compiler_count + c2_compiler_count;
D
duke 已提交
992 993

  _method_threads =
Z
zgu 已提交
994
    new (ResourceObj::C_HEAP, mtCompiler) GrowableArray<CompilerThread*>(compiler_count, true);
D
duke 已提交
995 996

  char name_buffer[256];
I
iveresov 已提交
997
  for (int i = 0; i < c2_compiler_count; i++) {
D
duke 已提交
998
    // Create a name for our thread.
I
iveresov 已提交
999
    sprintf(name_buffer, "C2 CompilerThread%d", i);
D
duke 已提交
1000
    CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
I
iveresov 已提交
1001 1002 1003
    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, CHECK);
    _method_threads->append(new_thread);
  }
D
duke 已提交
1004

I
iveresov 已提交
1005 1006 1007 1008 1009
  for (int i = c2_compiler_count; i < compiler_count; i++) {
    // Create a name for our thread.
    sprintf(name_buffer, "C1 CompilerThread%d", i);
    CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);
    CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, CHECK);
D
duke 已提交
1010 1011
    _method_threads->append(new_thread);
  }
I
iveresov 已提交
1012

D
duke 已提交
1013 1014 1015 1016 1017 1018
  if (UsePerfData) {
    PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,
                                     compiler_count, CHECK);
  }
}

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030

// 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();
  }
}

D
duke 已提交
1031 1032 1033
// ------------------------------------------------------------------
// CompileBroker::is_idle
bool CompileBroker::is_idle() {
I
iveresov 已提交
1034 1035 1036
  if (_c2_method_queue != NULL && !_c2_method_queue->is_empty()) {
    return false;
  } else if (_c1_method_queue != NULL && !_c1_method_queue->is_empty()) {
D
duke 已提交
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
    return false;
  } else {
    int num_threads = _method_threads->length();
    for (int i=0; i<num_threads; i++) {
      if (_method_threads->at(i)->task() != NULL) {
        return false;
      }
    }

    // No pending or active compilations.
    return true;
  }
}


// ------------------------------------------------------------------
// CompileBroker::compile_method
//
// Request compilation of a method.
void CompileBroker::compile_method_base(methodHandle method,
                                        int osr_bci,
                                        int comp_level,
                                        methodHandle hot_method,
                                        int hot_count,
                                        const char* comment,
1062
                                        Thread* thread) {
D
duke 已提交
1063 1064 1065 1066 1067 1068
  // do nothing if compiler thread(s) is not available
  if (!_initialized ) {
    return;
  }

  guarantee(!method->is_abstract(), "cannot compile abstract methods");
1069
  assert(method->method_holder()->oop_is_instance(),
D
duke 已提交
1070
         "sanity check");
1071
  assert(!method->method_holder()->is_not_initialized(),
D
duke 已提交
1072
         "method holder must be initialized");
1073
  assert(!method->is_method_handle_intrinsic(), "do not enqueue these guys");
D
duke 已提交
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099

  if (CIPrintRequests) {
    tty->print("request: ");
    method->print_short_name(tty);
    if (osr_bci != InvocationEntryBci) {
      tty->print(" osr_bci: %d", osr_bci);
    }
    tty->print(" comment: %s count: %d", comment, hot_count);
    if (!hot_method.is_null()) {
      tty->print(" hot: ");
      if (hot_method() != method()) {
          hot_method->print_short_name(tty);
      } else {
        tty->print("yes");
      }
    }
    tty->cr();
  }

  // A request has been made for compilation.  Before we do any
  // real work, check to see if the method has been compiled
  // in the meantime with a definitive result.
  if (compilation_is_complete(method, osr_bci, comp_level)) {
    return;
  }

1100 1101 1102 1103 1104 1105 1106 1107
#ifndef PRODUCT
  if (osr_bci != -1 && !FLAG_IS_DEFAULT(OSROnlyBCI)) {
    if ((OSROnlyBCI > 0) ? (OSROnlyBCI != osr_bci) : (-OSROnlyBCI == osr_bci)) {
      // Positive OSROnlyBCI means only compile that bci.  Negative means don't compile that BCI.
      return;
    }
  }
#endif
I
iveresov 已提交
1108

D
duke 已提交
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
  // If this method is already in the compile queue, then
  // we do not block the current thread.
  if (compilation_is_in_queue(method, osr_bci)) {
    // We may want to decay our counter a bit here to prevent
    // multiple denied requests for compilation.  This is an
    // open compilation policy issue. Note: The other possibility,
    // in the case that this is a blocking compile request, is to have
    // all subsequent blocking requesters wait for completion of
    // ongoing compiles. Note that in this case we'll need a protocol
    // for freeing the associated compile tasks. [Or we could have
    // a single static monitor on which all these waiters sleep.]
    return;
  }

1123 1124 1125 1126 1127
  // If the requesting thread is holding the pending list lock
  // then we just return. We can't risk blocking while holding
  // the pending list lock or a 3-way deadlock may occur
  // between the reference handler thread, a GC (instigated
  // by a compiler thread), and compiled method registration.
1128
  if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
1129 1130 1131
    return;
  }

D
duke 已提交
1132 1133 1134
  // Outputs from the following MutexLocker block:
  CompileTask* task     = NULL;
  bool         blocking = false;
I
iveresov 已提交
1135
  CompileQueue* queue  = compile_queue(comp_level);
D
duke 已提交
1136 1137 1138

  // Acquire our lock.
  {
1139
    MutexLocker locker(queue->lock(), thread);
D
duke 已提交
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204

    // Make sure the method has not slipped into the queues since
    // last we checked; note that those checks were "fast bail-outs".
    // Here we need to be more careful, see 14012000 below.
    if (compilation_is_in_queue(method, osr_bci)) {
      return;
    }

    // We need to check again to see if the compilation has
    // completed.  A previous compilation may have registered
    // some result.
    if (compilation_is_complete(method, osr_bci, comp_level)) {
      return;
    }

    // We now know that this compilation is not pending, complete,
    // or prohibited.  Assign a compile_id to this compilation
    // and check to see if it is in our [Start..Stop) range.
    uint compile_id = assign_compile_id(method, osr_bci);
    if (compile_id == 0) {
      // The compilation falls outside the allowed range.
      return;
    }

    // Should this thread wait for completion of the compile?
    blocking = is_compile_blocking(method, osr_bci);

    // We will enter the compilation in the queue.
    // 14012000: Note that this sets the queued_for_compile bits in
    // the target method. We can now reason that a method cannot be
    // queued for compilation more than once, as follows:
    // Before a thread queues a task for compilation, it first acquires
    // the compile queue lock, then checks if the method's queued bits
    // are set or it has already been compiled. Thus there can not be two
    // instances of a compilation task for the same method on the
    // compilation queue. Consider now the case where the compilation
    // thread has already removed a task for that method from the queue
    // and is in the midst of compiling it. In this case, the
    // queued_for_compile bits must be set in the method (and these
    // will be visible to the current thread, since the bits were set
    // under protection of the compile queue lock, which we hold now.
    // When the compilation completes, the compiler thread first sets
    // the compilation result and then clears the queued_for_compile
    // bits. Neither of these actions are protected by a barrier (or done
    // under the protection of a lock), so the only guarantee we have
    // (on machines with TSO (Total Store Order)) is that these values
    // will update in that order. As a result, the only combinations of
    // these bits that the current thread will see are, in temporal order:
    // <RESULT, QUEUE> :
    //     <0, 1> : in compile queue, but not yet compiled
    //     <1, 1> : compiled but queue bit not cleared
    //     <1, 0> : compiled and queue bit cleared
    // Because we first check the queue bits then check the result bits,
    // we are assured that we cannot introduce a duplicate task.
    // Note that if we did the tests in the reverse order (i.e. check
    // result then check queued bit), we could get the result bit before
    // the compilation completed, and the queue bit after the compilation
    // completed, and end up introducing a "duplicate" (redundant) task.
    // In that case, the compiler thread should first check if a method
    // has already been compiled before trying to compile it.
    // NOTE: in the event that there are multiple compiler threads and
    // there is de-optimization/recompilation, things will get hairy,
    // and in that case it's best to protect both the testing (here) of
    // these bits, and their updating (here and elsewhere) under a
    // common lock.
I
iveresov 已提交
1205
    task = create_compile_task(queue,
D
duke 已提交
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
                               compile_id, method,
                               osr_bci, comp_level,
                               hot_method, hot_count, comment,
                               blocking);
  }

  if (blocking) {
    wait_for_completion(task);
  }
}


nmethod* CompileBroker::compile_method(methodHandle method, int osr_bci,
I
iveresov 已提交
1219
                                       int comp_level,
D
duke 已提交
1220
                                       methodHandle hot_method, int hot_count,
1221
                                       const char* comment, Thread* THREAD) {
D
duke 已提交
1222
  // make sure arguments make sense
1223
  assert(method->method_holder()->oop_is_instance(), "not an instance method");
D
duke 已提交
1224 1225
  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");
1226
  assert(!method->method_holder()->is_not_initialized(), "method holder must be initialized");
1227 1228
  // allow any levels for WhiteBox
  assert(WhiteBoxAPI || TieredCompilation || comp_level == CompLevel_highest_tier, "only CompLevel_highest_tier must be used in non-tiered");
D
duke 已提交
1229 1230 1231 1232
  // return quickly if possible

  // lock, make sure that the compilation
  // isn't prohibited in a straightforward way.
1233 1234 1235
  AbstractCompiler *comp = CompileBroker::compiler(comp_level);
  if (comp == NULL || !comp->can_compile_method(method) ||
      compilation_is_prohibited(method, osr_bci, comp_level)) {
D
duke 已提交
1236 1237 1238 1239 1240 1241
    return NULL;
  }

  if (osr_bci == InvocationEntryBci) {
    // standard compilation
    nmethod* method_code = method->code();
I
iveresov 已提交
1242 1243 1244 1245
    if (method_code != NULL) {
      if (compilation_is_complete(method, osr_bci, comp_level)) {
        return method_code;
      }
D
duke 已提交
1246
    }
1247 1248
    if (method->is_not_compilable(comp_level)) {
      return NULL;
1249
    }
D
duke 已提交
1250 1251 1252 1253
  } else {
    // osr compilation
#ifndef TIERED
    // seems like an assert of dubious value
I
iveresov 已提交
1254
    assert(comp_level == CompLevel_highest_tier,
D
duke 已提交
1255 1256
           "all OSR compiles are assumed to be at a single compilation lavel");
#endif // TIERED
I
iveresov 已提交
1257 1258
    // We accept a higher level osr method
    nmethod* nm = method->lookup_osr_nmethod_for(osr_bci, comp_level, false);
D
duke 已提交
1259
    if (nm != NULL) return nm;
1260
    if (method->is_not_osr_compilable(comp_level)) return NULL;
D
duke 已提交
1261 1262 1263 1264
  }

  assert(!HAS_PENDING_EXCEPTION, "No exception should be present");
  // some prerequisites that are compiler specific
1265
  if (comp->is_c2() || comp->is_shark()) {
1266
    method->constants()->resolve_string_constants(CHECK_AND_CLEAR_NULL);
D
duke 已提交
1267 1268
    // Resolve all classes seen in the signature of the method
    // we are compiling.
1269
    Method::load_signature_classes(method, CHECK_AND_CLEAR_NULL);
D
duke 已提交
1270 1271 1272 1273 1274 1275 1276 1277
  }

  // 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.
  //
  // Note: A native method implies non-osr compilation which is
  //       checked with an assertion at the entry of this method.
1278
  if (method->is_native() && !method->is_method_handle_intrinsic()) {
D
duke 已提交
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
    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(); // implies is_not_osr_compilable()
      CLEAR_PENDING_EXCEPTION;
      return NULL;
    }
    assert(method->has_native_function(), "must have native code by now");
  }

  // RedefineClasses() has replaced this method; just return
  if (method->is_old()) {
    return NULL;
  }

  // JVMTI -- post_compile_event requires jmethod_id() that may require
  // a lock the compiling thread can not acquire. Prefetch it here.
  if (JvmtiExport::should_post_compiled_method_load()) {
    method->jmethod_id();
  }

1302
  // If the compiler is shut off due to code cache getting full
1303
  // fail out now so blocking compiles dont hang the java thread
1304
  if (!should_compile_new_jobs()) {
I
iveresov 已提交
1305
    CompilationPolicy::policy()->delay_compilation(method());
1306 1307 1308
    return NULL;
  }

D
duke 已提交
1309 1310
  // do the compilation
  if (method->is_native()) {
1311
    if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) {
1312 1313 1314 1315 1316 1317 1318
      // Acquire our lock.
      int compile_id;
      {
        MutexLocker locker(MethodCompileQueue_lock, THREAD);
        compile_id = assign_compile_id(method, standard_entry_bci);
      }
      (void) AdapterHandlerLibrary::create_native_wrapper(method, compile_id);
D
duke 已提交
1319 1320 1321 1322
    } else {
      return NULL;
    }
  } else {
1323
    compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, THREAD);
D
duke 已提交
1324 1325 1326
  }

  // return requested nmethod
I
iveresov 已提交
1327 1328
  // We accept a higher level osr method
  return osr_bci  == InvocationEntryBci ? method->code() : method->lookup_osr_nmethod_for(osr_bci, comp_level, false);
D
duke 已提交
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
}


// ------------------------------------------------------------------
// CompileBroker::compilation_is_complete
//
// See if compilation of this method is already complete.
bool CompileBroker::compilation_is_complete(methodHandle method,
                                            int          osr_bci,
                                            int          comp_level) {
  bool is_osr = (osr_bci != standard_entry_bci);
  if (is_osr) {
1341
    if (method->is_not_osr_compilable(comp_level)) {
D
duke 已提交
1342 1343
      return true;
    } else {
I
iveresov 已提交
1344
      nmethod* result = method->lookup_osr_nmethod_for(osr_bci, comp_level, true);
D
duke 已提交
1345 1346 1347 1348 1349 1350 1351 1352
      return (result != NULL);
    }
  } else {
    if (method->is_not_compilable(comp_level)) {
      return true;
    } else {
      nmethod* result = method->code();
      if (result == NULL) return false;
I
iveresov 已提交
1353
      return comp_level == result->comp_level();
D
duke 已提交
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
    }
  }
}


// ------------------------------------------------------------------
// CompileBroker::compilation_is_in_queue
//
// See if this compilation is already requested.
//
// Implementation note: there is only a single "is in queue" bit
// for each method.  This means that the check below is overly
// conservative in the sense that an osr compilation in the queue
// will block a normal compilation from entering the queue (and vice
// versa).  This can be remedied by a full queue search to disambiguate
// cases.  If it is deemed profitible, this may be done.
bool CompileBroker::compilation_is_in_queue(methodHandle method,
I
iveresov 已提交
1371
                                            int          osr_bci) {
D
duke 已提交
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
  return method->queued_for_compilation();
}

// ------------------------------------------------------------------
// CompileBroker::compilation_is_prohibited
//
// See if this compilation is not allowed.
bool CompileBroker::compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level) {
  bool is_native = method->is_native();
  // Some compilers may not support the compilation of natives.
1382
  AbstractCompiler *comp = compiler(comp_level);
D
duke 已提交
1383
  if (is_native &&
1384
      (!CICompileNatives || comp == NULL || !comp->supports_native())) {
I
iveresov 已提交
1385
    method->set_not_compilable_quietly(comp_level);
D
duke 已提交
1386 1387 1388 1389 1390 1391
    return true;
  }

  bool is_osr = (osr_bci != standard_entry_bci);
  // Some compilers may not support on stack replacement.
  if (is_osr &&
1392
      (!CICompileOSR || comp == NULL || !comp->supports_osr())) {
1393
    method->set_not_osr_compilable(comp_level);
D
duke 已提交
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
    return true;
  }

  // The method may be explicitly excluded by the user.
  bool quietly;
  if (CompilerOracle::should_exclude(method, quietly)) {
    if (!quietly) {
      // This does not happen quietly...
      ResourceMark rm;
      tty->print("### Excluding %s:%s",
                 method->is_native() ? "generation of native wrapper" : "compile",
                 (method->is_static() ? " static" : ""));
      method->print_short_name(tty);
      tty->cr();
    }
1409
    method->set_not_compilable(CompLevel_all, !quietly, "excluded by CompilerOracle");
D
duke 已提交
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
  }

  return false;
}


// ------------------------------------------------------------------
// CompileBroker::assign_compile_id
//
// Assign a serialized id number to this compilation request.  If the
// number falls out of the allowed range, return a 0.  OSR
// compilations may be numbered separately from regular compilations
// if certain debugging flags are used.
uint CompileBroker::assign_compile_id(methodHandle method, int osr_bci) {
I
iveresov 已提交
1424
  assert(MethodCompileQueue_lock->owner() == Thread::current(),
D
duke 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
         "must hold the compilation queue lock");
  bool is_osr = (osr_bci != standard_entry_bci);
  uint id;
  if (CICountOSR && is_osr) {
    id = ++_osr_compilation_id;
    if ((uint)CIStartOSR <= id && id < (uint)CIStopOSR) {
      return id;
    }
  } else {
    id = ++_compilation_id;
    if ((uint)CIStart <= id && id < (uint)CIStop) {
      return id;
    }
  }

  // Method was not in the appropriate compilation range.
1441
  method->set_not_compilable_quietly();
D
duke 已提交
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
  return 0;
}


// ------------------------------------------------------------------
// CompileBroker::is_compile_blocking
//
// Should the current thread be blocked until this compilation request
// has been fulfilled?
bool CompileBroker::is_compile_blocking(methodHandle method, int osr_bci) {
1452
  assert(!InstanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock");
1453
  return !BackgroundCompilation;
D
duke 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
}


// ------------------------------------------------------------------
// CompileBroker::preload_classes
void CompileBroker::preload_classes(methodHandle method, TRAPS) {
  // Move this code over from c1_Compiler.cpp
  ShouldNotReachHere();
}


// ------------------------------------------------------------------
// CompileBroker::create_compile_task
//
// Create a CompileTask object representing the current request for
// compilation.  Add this task to the queue.
CompileTask* CompileBroker::create_compile_task(CompileQueue* queue,
                                              int           compile_id,
                                              methodHandle  method,
                                              int           osr_bci,
                                              int           comp_level,
                                              methodHandle  hot_method,
                                              int           hot_count,
                                              const char*   comment,
                                              bool          blocking) {
  CompileTask* new_task = allocate_task();
  new_task->initialize(compile_id, method, osr_bci, comp_level,
                       hot_method, hot_count, comment,
                       blocking);
  queue->add(new_task);
  return new_task;
}


// ------------------------------------------------------------------
// CompileBroker::allocate_task
//
// Allocate a CompileTask, from the free list if possible.
CompileTask* CompileBroker::allocate_task() {
  MutexLocker locker(CompileTaskAlloc_lock);
  CompileTask* task = NULL;
  if (_task_free_list != NULL) {
    task = _task_free_list;
    _task_free_list = task->next();
    task->set_next(NULL);
  } else {
    task = new CompileTask();
    task->set_next(NULL);
  }
  return task;
}


// ------------------------------------------------------------------
// CompileBroker::free_task
//
// Add a task to the free list.
void CompileBroker::free_task(CompileTask* task) {
  MutexLocker locker(CompileTaskAlloc_lock);
  task->free();
  task->set_next(_task_free_list);
  _task_free_list = task;
}


// ------------------------------------------------------------------
// CompileBroker::wait_for_completion
//
// Wait for the given method CompileTask to complete.
void CompileBroker::wait_for_completion(CompileTask* task) {
  if (CIPrintCompileQueue) {
    tty->print_cr("BLOCKING FOR COMPILE");
  }

  assert(task->is_blocking(), "can only wait on blocking task");

  JavaThread *thread = JavaThread::current();
  thread->set_blocked_on_compilation(true);

1533
  methodHandle method(thread, task->method());
D
duke 已提交
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
  {
    MutexLocker waiter(task->lock(), thread);

    while (!task->is_complete())
      task->lock()->wait();
  }
  // It is harmless to check this status without the lock, because
  // completion is a stable property (until the task object is recycled).
  assert(task->is_complete(), "Compilation should have completed");
  assert(task->code_handle() == NULL, "must be reset");

  thread->set_blocked_on_compilation(false);

  // By convention, the waiter is responsible for recycling a
  // blocking CompileTask. Since there is only one waiter ever
  // waiting on a CompileTask, we know that no one else will
  // be using this CompileTask; we can free it.
  free_task(task);
}

// ------------------------------------------------------------------
// CompileBroker::compiler_thread_loop
//
// The main loop run by a CompilerThread.
void CompileBroker::compiler_thread_loop() {
  CompilerThread* thread = CompilerThread::current();
  CompileQueue* queue = thread->queue();

  // For the thread that initializes the ciObjectFactory
  // this resource mark holds all the shared objects
  ResourceMark rm;

  // First thread to get here will initialize the compiler interface

  if (!ciObjectFactory::is_initialized()) {
    ASSERT_IN_VM;
    MutexLocker only_one (CompileThread_lock, thread);
    if (!ciObjectFactory::is_initialized()) {
      ciObjectFactory::initialize();
    }
  }

  // Open a log.
  if (LogCompilation) {
    init_compiler_thread_log();
  }
  CompileLog* log = thread->log();
  if (log != NULL) {
V
vlivanov 已提交
1582 1583
    log->begin_elem("start_compile_thread name='%s' thread='" UINTX_FORMAT "' process='%d'",
                    thread->name(),
D
duke 已提交
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
                    os::current_thread_id(),
                    os::current_process_id());
    log->stamp();
    log->end_elem();
  }

  while (true) {
    {
      // We need this HandleMark to avoid leaking VM handles.
      HandleMark hm(thread);
1594

1595
      if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
1596 1597
        // the code cache is really full
        handle_full_code_cache();
D
duke 已提交
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
      }

      CompileTask* task = queue->get();

      // Give compiler threads an extra quanta.  They tend to be bursty and
      // this helps the compiler to finish up the job.
      if( CompilerThreadHintNoPreempt )
        os::hint_no_preempt();

      // trace per thread time and compile statistics
      CompilerCounters* counters = ((CompilerThread*)thread)->counters();
      PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter());

      // 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);
1616
      methodHandle method(thread, task->method());
D
duke 已提交
1617 1618 1619 1620

      // Never compile a method if breakpoints are present in it
      if (method()->number_of_breakpoints() == 0) {
        // Compile the method.
1621
        if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
D
duke 已提交
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
#ifdef COMPILER1
          // Allow repeating compilations for the purpose of benchmarking
          // compile speed. This is not useful for customers.
          if (CompilationRepeat != 0) {
            int compile_count = CompilationRepeat;
            while (compile_count > 0) {
              invoke_compiler_on_method(task);
              nmethod* nm = method->code();
              if (nm != NULL) {
                nm->make_zombie();
                method->clear_code();
              }
              compile_count--;
            }
          }
#endif /* COMPILER1 */
          invoke_compiler_on_method(task);
        } else {
          // After compilation is disabled, remove remaining methods from queue
          method->clear_queued_for_compilation();
        }
      }
    }
  }
}


// ------------------------------------------------------------------
// CompileBroker::init_compiler_thread_log
//
// Set up state required by +LogCompilation.
void CompileBroker::init_compiler_thread_log() {
    CompilerThread* thread = CompilerThread::current();
1655
    char  file_name[4*K];
D
duke 已提交
1656 1657 1658 1659
    FILE* fp = NULL;
    intx thread_id = os::current_thread_id();
    for (int try_temp_dir = 1; try_temp_dir >= 0; try_temp_dir--) {
      const char* dir = (try_temp_dir ? os::get_temp_directory() : NULL);
1660
      if (dir == NULL) {
1661
        jio_snprintf(file_name, sizeof(file_name), "hs_c" UINTX_FORMAT "_pid%u.log",
1662 1663
                     thread_id, os::current_process_id());
      } else {
1664
        jio_snprintf(file_name, sizeof(file_name),
1665 1666 1667
                     "%s%shs_c" UINTX_FORMAT "_pid%u.log", dir,
                     os::file_separator(), thread_id, os::current_process_id());
      }
D
duke 已提交
1668

1669 1670 1671 1672 1673 1674 1675
      fp = fopen(file_name, "at");
      if (fp != NULL) {
        if (LogCompilation && Verbose) {
          tty->print_cr("Opening compilation log %s", file_name);
        }
        CompileLog* log = new(ResourceObj::C_HEAP, mtCompiler) CompileLog(file_name, fp, thread_id);
        thread->init_log(log);
D
duke 已提交
1676

1677 1678 1679 1680 1681 1682
        if (xtty != NULL) {
          ttyLocker ttyl;
          // Record any per thread log files
          xtty->elem("thread_logfile thread='%d' filename='%s'", thread_id, file_name);
        }
        return;
D
duke 已提交
1683 1684
      }
    }
1685
    warning("Cannot open log file: %s", file_name);
D
duke 已提交
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
}

// ------------------------------------------------------------------
// CompileBroker::set_should_block
//
// Set _should_block.
// Call this from the VM, with Threads_lock held and a safepoint requested.
void CompileBroker::set_should_block() {
  assert(Threads_lock->owner() == Thread::current(), "must have threads lock");
  assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint already");
#ifndef PRODUCT
  if (PrintCompilation && (Verbose || WizardMode))
    tty->print_cr("notifying compiler thread pool to block");
#endif
  _should_block = true;
}

// ------------------------------------------------------------------
// CompileBroker::maybe_block
//
// Call this from the compiler at convenient points, to poll for _should_block.
void CompileBroker::maybe_block() {
  if (_should_block) {
#ifndef PRODUCT
    if (PrintCompilation && (Verbose || WizardMode))
      tty->print_cr("compiler thread " INTPTR_FORMAT " poll detects block request", Thread::current());
#endif
    ThreadInVMfromNative tivfn(JavaThread::current());
  }
}

1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
// wrapper for CodeCache::print_summary()
static void codecache_print(bool detailed)
{
  ResourceMark rm;
  stringStream s;
  // Dump code cache  into a buffer before locking the tty,
  {
    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
    CodeCache::print_summary(&s, detailed);
  }
  ttyLocker ttyl;
1728
  tty->print(s.as_string());
1729 1730
}

D
duke 已提交
1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
// ------------------------------------------------------------------
// CompileBroker::invoke_compiler_on_method
//
// Compile a method.
//
void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
  if (PrintCompilation) {
    ResourceMark rm;
    task->print_line();
  }
  elapsedTimer time;

  CompilerThread* thread = CompilerThread::current();
  ResourceMark rm(thread);

1746 1747 1748 1749
  if (LogEvents) {
    _compilation_log->log_compile(thread, task);
  }

D
duke 已提交
1750 1751 1752 1753 1754 1755
  // Common flags.
  uint compile_id = task->compile_id();
  int osr_bci = task->osr_bci();
  bool is_osr = (osr_bci != standard_entry_bci);
  bool should_log = (thread->log() != NULL);
  bool should_break = false;
1756
  int task_level = task->comp_level();
D
duke 已提交
1757 1758 1759 1760 1761
  {
    // 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.
1762
    methodHandle method(thread, task->method());
D
duke 已提交
1763 1764 1765 1766 1767 1768 1769
    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");

    // Save information about this method in case of failure.
1770
    set_last_compile(thread, method, is_osr, task_level);
D
duke 已提交
1771

1772
    DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, compiler_name(task_level));
D
duke 已提交
1773 1774 1775 1776
  }

  // Allocate a new set of JNI handles.
  push_jni_handle_block();
1777
  Method* target_handle = task->method();
D
duke 已提交
1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
  int compilable = ciEnv::MethodCompilable;
  {
    int system_dictionary_modification_counter;
    {
      MutexLocker locker(Compile_lock, thread);
      system_dictionary_modification_counter = SystemDictionary::number_of_modifications();
    }

    NoHandleMark  nhm;
    ThreadToNativeFromVM ttn(thread);

    ciEnv ci_env(task, system_dictionary_modification_counter);
    if (should_break) {
      ci_env.set_break_at_compile(true);
    }
    if (should_log) {
      ci_env.set_log(thread->log());
    }
    assert(thread->env() == &ci_env, "set by ci_env");
    // The thread-env() field is cleared in ~CompileTaskWrapper.

1799 1800 1801 1802 1803 1804
    // Cache Jvmti state
    ci_env.cache_jvmti_state();

    // Cache DTrace flags
    ci_env.cache_dtrace_flags();

D
duke 已提交
1805 1806 1807
    ciMethod* target = ci_env.get_method_from_handle(target_handle);

    TraceTime t1("compilation", &time);
S
sla 已提交
1808
    EventCompilation event;
D
duke 已提交
1809

1810 1811 1812 1813 1814 1815
    AbstractCompiler *comp = compiler(task_level);
    if (comp == NULL) {
      ci_env.record_method_not_compilable("no compiler", !TieredCompilation);
    } else {
      comp->compile_method(&ci_env, target, osr_bci);
    }
D
duke 已提交
1816 1817 1818 1819 1820

    if (!ci_env.failing() && task->code() == NULL) {
      //assert(false, "compiler should always document failure");
      // The compiler elected, without comment, not to register a result.
      // Do not attempt further compilations of this method.
1821
      ci_env.record_method_not_compilable("compile failed", !TieredCompilation);
D
duke 已提交
1822 1823
    }

1824 1825 1826
    // Copy this bit to the enclosing block:
    compilable = ci_env.compilable();

D
duke 已提交
1827
    if (ci_env.failing()) {
1828 1829 1830 1831
      const char* retry_message = ci_env.retry_message();
      if (_compilation_log != NULL) {
        _compilation_log->log_failure(thread, task, ci_env.failure_reason(), retry_message);
      }
D
duke 已提交
1832
      if (PrintCompilation) {
1833 1834 1835 1836
        FormatBufferResource msg = retry_message != NULL ?
            err_msg_res("COMPILE SKIPPED: %s (%s)", ci_env.failure_reason(), retry_message) :
            err_msg_res("COMPILE SKIPPED: %s",      ci_env.failure_reason());
        task->print_compilation(tty, msg);
D
duke 已提交
1837 1838 1839 1840
      }
    } else {
      task->mark_success();
      task->set_num_inlined_bytecodes(ci_env.num_inlined_bytecodes());
1841 1842 1843 1844 1845 1846
      if (_compilation_log != NULL) {
        nmethod* code = task->code();
        if (code != NULL) {
          _compilation_log->log_nmethod(thread, code);
        }
      }
D
duke 已提交
1847
    }
1848 1849
    // simulate crash during compilation
    assert(task->compile_id() != CICrashAt, "just as planned");
S
sla 已提交
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859
    if (event.should_commit()) {
      event.set_method(target->get_Method());
      event.set_compileID(compile_id);
      event.set_compileLevel(task->comp_level());
      event.set_succeded(task->is_success());
      event.set_isOsr(is_osr);
      event.set_codeSize((task->code() == NULL) ? 0 : task->code()->total_size());
      event.set_inlinedBytes(task->num_inlined_bytecodes());
      event.commit();
    }
D
duke 已提交
1860 1861 1862
  }
  pop_jni_handle_block();

1863
  methodHandle method(thread, task->method());
D
duke 已提交
1864

1865
  DTRACE_METHOD_COMPILE_END_PROBE(method, compiler_name(task_level), task->is_success());
D
duke 已提交
1866 1867 1868

  collect_statistics(thread, time, task);

1869
  if (PrintCompilation && PrintCompilation2) {
K
kvn 已提交
1870 1871 1872
    tty->print("%7d ", (int) tty->time_stamp().milliseconds());  // print timestamp
    tty->print("%4d ", compile_id);    // print compilation number
    tty->print("%s ", (is_osr ? "%" : " "));
1873 1874 1875 1876
    if (task->code() != NULL) {
      tty->print("size: %d(%d) ", task->code()->total_size(), task->code()->insts_size());
    }
    tty->print_cr("time: %d inlined: %d bytes", (int)time.milliseconds(), task->num_inlined_bytecodes());
K
kvn 已提交
1877 1878
  }

1879 1880 1881
  if (PrintCodeCacheOnCompilation)
    codecache_print(/* detailed= */ false);

1882 1883 1884 1885 1886 1887
  // Disable compilation, if required.
  switch (compilable) {
  case ciEnv::MethodCompilable_never:
    if (is_osr)
      method->set_not_osr_compilable_quietly();
    else
1888
      method->set_not_compilable_quietly();
1889 1890 1891
    break;
  case ciEnv::MethodCompilable_not_at_tier:
    if (is_osr)
1892
      method->set_not_osr_compilable_quietly(task_level);
1893
    else
1894
      method->set_not_compilable_quietly(task_level);
1895
    break;
D
duke 已提交
1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
  }

  // Note that the queued_for_compilation bits are cleared without
  // protection of a mutex. [They were set by the requester thread,
  // when adding the task to the complie queue -- at which time the
  // compile queue lock was held. Subsequently, we acquired the compile
  // queue lock to get this task off the compile queue; thus (to belabour
  // the point somewhat) our clearing of the bits must be occurring
  // only after the setting of the bits. See also 14012000 above.
  method->clear_queued_for_compilation();

#ifdef ASSERT
  if (CollectedHeap::fired_fake_oom()) {
    // The current compile received a fake OOM during compilation so
    // go ahead and exit the VM since the test apparently succeeded
    tty->print_cr("*** Shutting down VM after successful fake OOM");
    vm_exit(0);
  }
#endif
}

1917 1918 1919 1920 1921 1922 1923 1924
// ------------------------------------------------------------------
// CompileBroker::handle_full_code_cache
//
// The CodeCache is full.  Print out warning and disable compilation or
// try code cache cleaning so compilation can continue later.
void CompileBroker::handle_full_code_cache() {
  UseInterpreter = true;
  if (UseCompiler || AlwaysCompileLoopMethods ) {
1925
    if (xtty != NULL) {
1926
      ResourceMark rm;
1927 1928 1929 1930 1931 1932
      stringStream s;
      // Dump code cache state into a buffer before locking the tty,
      // because log_state() will use locks causing lock conflicts.
      CodeCache::log_state(&s);
      // Lock to prevent tearing
      ttyLocker ttyl;
1933
      xtty->begin_elem("code_cache_full");
1934
      xtty->print(s.as_string());
1935 1936
      xtty->stamp();
      xtty->end_elem();
1937
    }
1938 1939
    warning("CodeCache is full. Compiler has been disabled.");
    warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");
S
sla 已提交
1940 1941 1942 1943

    CodeCache::report_codemem_full();


1944
#ifndef PRODUCT
1945
    if (CompileTheWorld || ExitOnFullCodeCache) {
1946
      codecache_print(/* detailed= */ true);
1947 1948 1949 1950
      before_exit(JavaThread::current());
      exit_globals(); // will delete tty
      vm_direct_exit(CompileTheWorld ? 0 : 1);
    }
1951
#endif
1952
    if (UseCodeCacheFlushing) {
1953 1954 1955 1956 1957
      // Since code cache is full, immediately stop new compiles
      if (CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation)) {
        NMethodSweeper::log_sweep("disable_compiler");
        NMethodSweeper::possibly_sweep();
      }
1958 1959 1960 1961 1962
    } else {
      UseCompiler               = false;
      AlwaysCompileLoopMethods  = false;
    }
  }
1963
  codecache_print(/* detailed= */ true);
1964 1965
}

D
duke 已提交
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
// ------------------------------------------------------------------
// CompileBroker::set_last_compile
//
// Record this compilation for debugging purposes.
void CompileBroker::set_last_compile(CompilerThread* thread, methodHandle method, bool is_osr, int comp_level) {
  ResourceMark rm;
  char* method_name = method->name()->as_C_string();
  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) {
1978
    const char* class_name = method->method_holder()->name()->as_C_string();
D
duke 已提交
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071

    size_t s1len = strlen(class_name);
    size_t s2len = strlen(method_name);

    // check if we need to truncate the string
    if (s1len + s2len + 2 > maxLen) {

      // the strategy is to lop off the leading characters of the
      // class name and the trailing characters of the method name.

      if (s2len + 2 > maxLen) {
        // lop of the entire class name string, let snprintf handle
        // truncation of the method name.
        class_name += s1len; // null string
      }
      else {
        // lop off the extra characters from the front of the class name
        class_name += ((s1len + s2len + 2) - maxLen);
      }
    }

    jio_snprintf(current_method, maxLen, "%s %s", class_name, method_name);
  }

  if (CICountOSR && is_osr) {
    _last_compile_type = osr_compile;
  } else {
    _last_compile_type = normal_compile;
  }
  _last_compile_level = comp_level;

  if (UsePerfData) {
    CompilerCounters* counters = thread->counters();
    counters->set_current_method(current_method);
    counters->set_compile_type((jlong)_last_compile_type);
  }
}


// ------------------------------------------------------------------
// CompileBroker::push_jni_handle_block
//
// Push on a new block of JNI handles.
void CompileBroker::push_jni_handle_block() {
  JavaThread* thread = JavaThread::current();

  // Allocate a new block for JNI handles.
  // Inlined code from jni_PushLocalFrame()
  JNIHandleBlock* java_handles = thread->active_handles();
  JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread);
  assert(compile_handles != NULL && java_handles != NULL, "should not be NULL");
  compile_handles->set_pop_frame_link(java_handles);  // make sure java handles get gc'd.
  thread->set_active_handles(compile_handles);
}


// ------------------------------------------------------------------
// CompileBroker::pop_jni_handle_block
//
// Pop off the current block of JNI handles.
void CompileBroker::pop_jni_handle_block() {
  JavaThread* thread = JavaThread::current();

  // Release our JNI handle block
  JNIHandleBlock* compile_handles = thread->active_handles();
  JNIHandleBlock* java_handles = compile_handles->pop_frame_link();
  thread->set_active_handles(java_handles);
  compile_handles->set_pop_frame_link(NULL);
  JNIHandleBlock::release_block(compile_handles, thread); // may block
}


// ------------------------------------------------------------------
// CompileBroker::check_break_at
//
// Should the compilation break at the current compilation.
bool CompileBroker::check_break_at(methodHandle method, int compile_id, bool is_osr) {
  if (CICountOSR && is_osr && (compile_id == CIBreakAtOSR)) {
    return true;
  } else if( CompilerOracle::should_break_at(method) ) { // break when compiling
    return true;
  } else {
    return (compile_id == CIBreakAt);
  }
}

// ------------------------------------------------------------------
// CompileBroker::collect_statistics
//
// Collect statistics about the compilation.

void CompileBroker::collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task) {
  bool success = task->is_success();
2072
  methodHandle method (thread, task->method());
D
duke 已提交
2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
  uint compile_id = task->compile_id();
  bool is_osr = (task->osr_bci() != standard_entry_bci);
  nmethod* code = task->code();
  CompilerCounters* counters = thread->counters();

  assert(code == NULL || code->is_locked_by_vm(), "will survive the MutexLocker");
  MutexLocker locker(CompileStatistics_lock);

  // _perf variables are production performance counters which are
  // updated regardless of the setting of the CITime and CITimeEach flags
  //
  if (!success) {
    _total_bailout_count++;
    if (UsePerfData) {
      _perf_last_failed_method->set_value(counters->current_method());
      _perf_last_failed_type->set_value(counters->compile_type());
      _perf_total_bailout_count->inc();
    }
  } else if (code == NULL) {
    if (UsePerfData) {
      _perf_last_invalidated_method->set_value(counters->current_method());
      _perf_last_invalidated_type->set_value(counters->compile_type());
      _perf_total_invalidated_count->inc();
    }
    _total_invalidated_count++;
  } else {
    // Compilation succeeded

    // update compilation ticks - used by the implementation of
    // java.lang.management.CompilationMBean
    _perf_total_compilation->inc(time.ticks());

S
sla 已提交
2105 2106 2107
    _t_total_compilation.add(time);
    _peak_compilation_time = time.milliseconds() > _peak_compilation_time ? time.milliseconds() : _peak_compilation_time;

D
duke 已提交
2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
    if (CITime) {
      if (is_osr) {
        _t_osr_compilation.add(time);
        _sum_osr_bytes_compiled += method->code_size() + task->num_inlined_bytecodes();
      } else {
        _t_standard_compilation.add(time);
        _sum_standard_bytes_compiled += method->code_size() + task->num_inlined_bytecodes();
      }
    }

    if (UsePerfData) {
      // save the name of the last method compiled
      _perf_last_method->set_value(counters->current_method());
      _perf_last_compile_type->set_value(counters->compile_type());
      _perf_last_compile_size->set_value(method->code_size() +
                                         task->num_inlined_bytecodes());
      if (is_osr) {
        _perf_osr_compilation->inc(time.ticks());
        _perf_sum_osr_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());
      } else {
        _perf_standard_compilation->inc(time.ticks());
        _perf_sum_standard_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());
      }
    }

    if (CITimeEach) {
      float bytes_per_sec = 1.0 * (method->code_size() + task->num_inlined_bytecodes()) / time.seconds();
      tty->print_cr("%3d   seconds: %f bytes/sec : %f (bytes %d + %d inlined)",
                    compile_id, time.seconds(), bytes_per_sec, method->code_size(), task->num_inlined_bytecodes());
    }

    // Collect counts of successful compilations
T
twisti 已提交
2140 2141
    _sum_nmethod_size      += code->total_size();
    _sum_nmethod_code_size += code->insts_size();
D
duke 已提交
2142 2143 2144
    _total_compile_count++;

    if (UsePerfData) {
T
twisti 已提交
2145 2146
      _perf_sum_nmethod_size->inc(     code->total_size());
      _perf_sum_nmethod_code_size->inc(code->insts_size());
D
duke 已提交
2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
      _perf_total_compile_count->inc();
    }

    if (is_osr) {
      if (UsePerfData) _perf_total_osr_compile_count->inc();
      _total_osr_compile_count++;
    } else {
      if (UsePerfData) _perf_total_standard_compile_count->inc();
      _total_standard_compile_count++;
    }
  }
  // set the current method for the thread to null
  if (UsePerfData) counters->set_current_method("");
}

2162 2163 2164 2165 2166 2167 2168 2169
const char* CompileBroker::compiler_name(int comp_level) {
  AbstractCompiler *comp = CompileBroker::compiler(comp_level);
  if (comp == NULL) {
    return "no compiler";
  } else {
    return (comp->name());
  }
}
D
duke 已提交
2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181

void CompileBroker::print_times() {
  tty->cr();
  tty->print_cr("Accumulated compiler times (for compiled methods only)");
  tty->print_cr("------------------------------------------------");
               //0000000000111111111122222222223333333333444444444455555555556666666666
               //0123456789012345678901234567890123456789012345678901234567890123456789
  tty->print_cr("  Total compilation time   : %6.3f s", CompileBroker::_t_total_compilation.seconds());
  tty->print_cr("    Standard compilation   : %6.3f s, Average : %2.3f",
                CompileBroker::_t_standard_compilation.seconds(),
                CompileBroker::_t_standard_compilation.seconds() / CompileBroker::_total_standard_compile_count);
  tty->print_cr("    On stack replacement   : %6.3f s, Average : %2.3f", CompileBroker::_t_osr_compilation.seconds(), CompileBroker::_t_osr_compilation.seconds() / CompileBroker::_total_osr_compile_count);
T
twisti 已提交
2182

2183 2184 2185
  AbstractCompiler *comp = compiler(CompLevel_simple);
  if (comp != NULL) {
    comp->print_timers();
I
iveresov 已提交
2186
  }
2187 2188 2189
  comp = compiler(CompLevel_full_optimization);
  if (comp != NULL) {
    comp->print_timers();
D
duke 已提交
2190 2191
  }
  tty->cr();
2192 2193 2194
  tty->print_cr("  Total compiled methods   : %6d methods", CompileBroker::_total_compile_count);
  tty->print_cr("    Standard compilation   : %6d methods", CompileBroker::_total_standard_compile_count);
  tty->print_cr("    On stack replacement   : %6d methods", CompileBroker::_total_osr_compile_count);
D
duke 已提交
2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
  int tcb = CompileBroker::_sum_osr_bytes_compiled + CompileBroker::_sum_standard_bytes_compiled;
  tty->print_cr("  Total compiled bytecodes : %6d bytes", tcb);
  tty->print_cr("    Standard compilation   : %6d bytes", CompileBroker::_sum_standard_bytes_compiled);
  tty->print_cr("    On stack replacement   : %6d bytes", CompileBroker::_sum_osr_bytes_compiled);
  int bps = (int)(tcb / CompileBroker::_t_total_compilation.seconds());
  tty->print_cr("  Average compilation speed: %6d bytes/s", bps);
  tty->cr();
  tty->print_cr("  nmethod code size        : %6d bytes", CompileBroker::_sum_nmethod_code_size);
  tty->print_cr("  nmethod total size       : %6d bytes", CompileBroker::_sum_nmethod_size);
}

// Debugging output for failure
void CompileBroker::print_last_compile() {
  if ( _last_compile_level != CompLevel_none &&
       compiler(_last_compile_level) != NULL &&
       _last_method_compiled != NULL &&
       _last_compile_type != no_compile) {
    if (_last_compile_type == osr_compile) {
      tty->print_cr("Last parse:  [osr]%d+++(%d) %s",
                    _osr_compilation_id, _last_compile_level, _last_method_compiled);
    } else {
      tty->print_cr("Last parse:  %d+++(%d) %s",
                    _compilation_id, _last_compile_level, _last_method_compiled);
    }
  }
}


void CompileBroker::print_compiler_threads_on(outputStream* st) {
#ifndef PRODUCT
  st->print_cr("Compiler thread printing unimplemented.");
  st->cr();
#endif
}