< prev index next >

src/hotspot/share/compiler/compileBroker.cpp

Print this page




 170 int CompileBroker::_total_compile_count            = 0;
 171 int CompileBroker::_total_osr_compile_count        = 0;
 172 int CompileBroker::_total_standard_compile_count   = 0;
 173 int CompileBroker::_total_compiler_stopped_count   = 0;
 174 int CompileBroker::_total_compiler_restarted_count = 0;
 175 
 176 int CompileBroker::_sum_osr_bytes_compiled         = 0;
 177 int CompileBroker::_sum_standard_bytes_compiled    = 0;
 178 int CompileBroker::_sum_nmethod_size               = 0;
 179 int CompileBroker::_sum_nmethod_code_size          = 0;
 180 
 181 long CompileBroker::_peak_compilation_time         = 0;
 182 
 183 CompileQueue* CompileBroker::_c2_compile_queue     = NULL;
 184 CompileQueue* CompileBroker::_c1_compile_queue     = NULL;
 185 
 186 
 187 
 188 class CompilationLog : public StringEventLog {
 189  public:
 190   CompilationLog() : StringEventLog("Compilation events", "jit") {
 191   }
 192 
 193   void log_compile(JavaThread* thread, CompileTask* task) {
 194     StringLogMessage lm;
 195     stringStream sstr(lm.buffer(), lm.size());
 196     // msg.time_stamp().update_to(tty->time_stamp().ticks());
 197     task->print(&sstr, NULL, true, false);
 198     log(thread, "%s", (const char*)lm);
 199   }
 200 
 201   void log_nmethod(JavaThread* thread, nmethod* nm) {
 202     log(thread, "nmethod %d%s " INTPTR_FORMAT " code [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",
 203         nm->compile_id(), nm->is_osr_method() ? "%" : "",
 204         p2i(nm), p2i(nm->code_begin()), p2i(nm->code_end()));
 205   }
 206 
 207   void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) {
 208     StringLogMessage lm;
 209     lm.print("%4d   COMPILE SKIPPED: %s", task->compile_id(), reason);
 210     if (retry_message != NULL) {


1225   // some prerequisites that are compiler specific
1226   if (comp->is_c2()) {
1227     method->constants()->resolve_string_constants(CHECK_AND_CLEAR_NULL);
1228     // Resolve all classes seen in the signature of the method
1229     // we are compiling.
1230     Method::load_signature_classes(method, CHECK_AND_CLEAR_NULL);
1231   }
1232 
1233   // If the method is native, do the lookup in the thread requesting
1234   // the compilation. Native lookups can load code, which is not
1235   // permitted during compilation.
1236   //
1237   // Note: A native method implies non-osr compilation which is
1238   //       checked with an assertion at the entry of this method.
1239   if (method->is_native() && !method->is_method_handle_intrinsic()) {
1240     bool in_base_library;
1241     address adr = NativeLookup::lookup(method, in_base_library, THREAD);
1242     if (HAS_PENDING_EXCEPTION) {
1243       // In case of an exception looking up the method, we just forget
1244       // about it. The interpreter will kick-in and throw the exception.
1245       method->set_not_compilable("NativeLookup::lookup failed"); // implies is_not_osr_compilable()
1246       CLEAR_PENDING_EXCEPTION;
1247       return NULL;
1248     }
1249     assert(method->has_native_function(), "must have native code by now");
1250   }
1251 
1252   // RedefineClasses() has replaced this method; just return
1253   if (method->is_old()) {
1254     return NULL;
1255   }
1256 
1257   // JVMTI -- post_compile_event requires jmethod_id() that may require
1258   // a lock the compiling thread can not acquire. Prefetch it here.
1259   if (JvmtiExport::should_post_compiled_method_load()) {
1260     method->jmethod_id();
1261   }
1262 
1263   // do the compilation
1264   if (method->is_native()) {
1265     if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) {


1353  * for each method.  This means that the check below is overly
1354  * conservative in the sense that an osr compilation in the queue
1355  * will block a normal compilation from entering the queue (and vice
1356  * versa).  This can be remedied by a full queue search to disambiguate
1357  * cases.  If it is deemed profitable, this may be done.
1358  */
1359 bool CompileBroker::compilation_is_in_queue(const methodHandle& method) {
1360   return method->queued_for_compilation();
1361 }
1362 
1363 // ------------------------------------------------------------------
1364 // CompileBroker::compilation_is_prohibited
1365 //
1366 // See if this compilation is not allowed.
1367 bool CompileBroker::compilation_is_prohibited(const methodHandle& method, int osr_bci, int comp_level, bool excluded) {
1368   bool is_native = method->is_native();
1369   // Some compilers may not support the compilation of natives.
1370   AbstractCompiler *comp = compiler(comp_level);
1371   if (is_native &&
1372       (!CICompileNatives || comp == NULL || !comp->supports_native())) {
1373     method->set_not_compilable_quietly("native methods not supported", comp_level);
1374     return true;
1375   }
1376 
1377   bool is_osr = (osr_bci != standard_entry_bci);
1378   // Some compilers may not support on stack replacement.
1379   if (is_osr &&
1380       (!CICompileOSR || comp == NULL || !comp->supports_osr())) {
1381     method->set_not_osr_compilable("OSR not supported", comp_level);
1382     return true;
1383   }
1384 
1385   // The method may be explicitly excluded by the user.
1386   double scale;
1387   if (excluded || (CompilerOracle::has_option_value(method, "CompileThresholdScaling", scale) && scale == 0)) {
1388     bool quietly = CompilerOracle::should_exclude_quietly();
1389     if (PrintCompilation && !quietly) {
1390       // This does not happen quietly...
1391       ResourceMark rm;
1392       tty->print("### Excluding %s:%s",
1393                  method->is_native() ? "generation of native wrapper" : "compile",
1394                  (method->is_static() ? " static" : ""));
1395       method->print_short_name(tty);
1396       tty->cr();
1397     }
1398     method->set_not_compilable("excluded by CompileCommand", comp_level, !quietly);
1399   }
1400 
1401   return false;
1402 }
1403 
1404 /**
1405  * Generate serialized IDs for compilation requests. If certain debugging flags are used
1406  * and the ID is not within the specified range, the method is not compiled and 0 is returned.
1407  * The function also allows to generate separate compilation IDs for OSR compilations.
1408  */
1409 int CompileBroker::assign_compile_id(const methodHandle& method, int osr_bci) {
1410 #ifdef ASSERT
1411   bool is_osr = (osr_bci != standard_entry_bci);
1412   int id;
1413   if (method->is_native()) {
1414     assert(!is_osr, "can't be osr");
1415     // Adapters, native wrappers and method handle intrinsics
1416     // should be generated always.
1417     return Atomic::add(1, &_compilation_id);
1418   } else if (CICountOSR && is_osr) {
1419     id = Atomic::add(1, &_osr_compilation_id);
1420     if (CIStartOSR <= id && id < CIStopOSR) {
1421       return id;
1422     }
1423   } else {
1424     id = Atomic::add(1, &_compilation_id);
1425     if (CIStart <= id && id < CIStop) {
1426       return id;
1427     }
1428   }
1429 
1430   // Method was not in the appropriate compilation range.
1431   method->set_not_compilable_quietly("Not in requested compile id range");
1432   return 0;
1433 #else
1434   // CICountOSR is a develop flag and set to 'false' by default. In a product built,
1435   // only _compilation_id is incremented.
1436   return Atomic::add(1, &_compilation_id);
1437 #endif
1438 }
1439 
1440 // ------------------------------------------------------------------
1441 // CompileBroker::assign_compile_id_unlocked
1442 //
1443 // Public wrapper for assign_compile_id that acquires the needed locks
1444 uint CompileBroker::assign_compile_id_unlocked(Thread* thread, const methodHandle& method, int osr_bci) {
1445   MutexLocker locker(MethodCompileQueue_lock, thread);
1446   return assign_compile_id(method, osr_bci);
1447 }
1448 
1449 // ------------------------------------------------------------------
1450 // CompileBroker::preload_classes
1451 void CompileBroker::preload_classes(const methodHandle& method, TRAPS) {


2178     tty->print("%4d ", compile_id);    // print compilation number
2179     tty->print("%s ", (is_osr ? "%" : " "));
2180     if (task->code() != NULL) {
2181       tty->print("size: %d(%d) ", task->code()->total_size(), task->code()->insts_size());
2182     }
2183     tty->print_cr("time: %d inlined: %d bytes", (int)time.milliseconds(), task->num_inlined_bytecodes());
2184   }
2185 
2186   Log(compilation, codecache) log;
2187   if (log.is_debug()) {
2188     LogStream ls(log.debug());
2189     codecache_print(&ls, /* detailed= */ false);
2190   }
2191   if (PrintCodeCacheOnCompilation) {
2192     codecache_print(/* detailed= */ false);
2193   }
2194   // Disable compilation, if required.
2195   switch (compilable) {
2196   case ciEnv::MethodCompilable_never:
2197     if (is_osr)
2198       method->set_not_osr_compilable_quietly("MethodCompilable_never");
2199     else
2200       method->set_not_compilable_quietly("MethodCompilable_never");
2201     break;
2202   case ciEnv::MethodCompilable_not_at_tier:
2203     if (is_osr)
2204       method->set_not_osr_compilable_quietly("MethodCompilable_not_at_tier", task_level);
2205     else
2206       method->set_not_compilable_quietly("MethodCompilable_not_at_tier", task_level);
2207     break;
2208   }
2209 
2210   // Note that the queued_for_compilation bits are cleared without
2211   // protection of a mutex. [They were set by the requester thread,
2212   // when adding the task to the compile queue -- at which time the
2213   // compile queue lock was held. Subsequently, we acquired the compile
2214   // queue lock to get this task off the compile queue; thus (to belabour
2215   // the point somewhat) our clearing of the bits must be occurring
2216   // only after the setting of the bits. See also 14012000 above.
2217   method->clear_queued_for_compilation();
2218 }
2219 
2220 /**
2221  * The CodeCache is full. Print warning and disable compilation.
2222  * Schedule code cache cleaning so compilation can continue later.
2223  * This function needs to be called only from CodeCache::allocate(),
2224  * since we currently handle a full code cache uniformly.
2225  */
2226 void CompileBroker::handle_full_code_cache(int code_blob_type) {


2623   out->cr();
2624   out->print_cr("         Reserved size : " SIZE_FORMAT_W(7) " KB", CodeCache::max_capacity() / K);
2625   out->print_cr("        Committed size : " SIZE_FORMAT_W(7) " KB", CodeCache::capacity() / K);
2626   out->print_cr("  Unallocated capacity : " SIZE_FORMAT_W(7) " KB", CodeCache::unallocated_capacity() / K);
2627   out->cr();
2628 
2629   out->cr();
2630   out->print_cr("CodeCache cleaning overview");
2631   out->print_cr("--------------------------------------------------------");
2632   out->cr();
2633   NMethodSweeper::print(out);
2634   out->print_cr("--------------------------------------------------------");
2635   out->cr();
2636 }
2637 
2638 // Note: tty_lock must not be held upon entry to this function.
2639 //       Print functions called from herein do "micro-locking" on tty_lock.
2640 //       That's a tradeoff which keeps together important blocks of output.
2641 //       At the same time, continuous tty_lock hold time is kept in check,
2642 //       preventing concurrently printing threads from stalling a long time.
2643 void CompileBroker::print_heapinfo(outputStream* out, const char* function, size_t granularity) {
2644   TimeStamp ts_total;
2645   TimeStamp ts_global;
2646   TimeStamp ts;
2647 
2648   bool allFun = !strcmp(function, "all");
2649   bool aggregate = !strcmp(function, "aggregate") || !strcmp(function, "analyze") || allFun;
2650   bool usedSpace = !strcmp(function, "UsedSpace") || allFun;
2651   bool freeSpace = !strcmp(function, "FreeSpace") || allFun;
2652   bool methodCount = !strcmp(function, "MethodCount") || allFun;
2653   bool methodSpace = !strcmp(function, "MethodSpace") || allFun;
2654   bool methodAge = !strcmp(function, "MethodAge") || allFun;
2655   bool methodNames = !strcmp(function, "MethodNames") || allFun;
2656   bool discard = !strcmp(function, "discard") || allFun;
2657 
2658   if (out == NULL) {
2659     out = tty;
2660   }
2661 
2662   if (!(aggregate || usedSpace || freeSpace || methodCount || methodSpace || methodAge || methodNames || discard)) {
2663     out->print_cr("\n__ CodeHeapStateAnalytics: Function %s is not supported", function);




 170 int CompileBroker::_total_compile_count            = 0;
 171 int CompileBroker::_total_osr_compile_count        = 0;
 172 int CompileBroker::_total_standard_compile_count   = 0;
 173 int CompileBroker::_total_compiler_stopped_count   = 0;
 174 int CompileBroker::_total_compiler_restarted_count = 0;
 175 
 176 int CompileBroker::_sum_osr_bytes_compiled         = 0;
 177 int CompileBroker::_sum_standard_bytes_compiled    = 0;
 178 int CompileBroker::_sum_nmethod_size               = 0;
 179 int CompileBroker::_sum_nmethod_code_size          = 0;
 180 
 181 long CompileBroker::_peak_compilation_time         = 0;
 182 
 183 CompileQueue* CompileBroker::_c2_compile_queue     = NULL;
 184 CompileQueue* CompileBroker::_c1_compile_queue     = NULL;
 185 
 186 
 187 
 188 class CompilationLog : public StringEventLog {
 189  public:
 190   CompilationLog() : StringEventLog("Compilation events") {
 191   }
 192 
 193   void log_compile(JavaThread* thread, CompileTask* task) {
 194     StringLogMessage lm;
 195     stringStream sstr(lm.buffer(), lm.size());
 196     // msg.time_stamp().update_to(tty->time_stamp().ticks());
 197     task->print(&sstr, NULL, true, false);
 198     log(thread, "%s", (const char*)lm);
 199   }
 200 
 201   void log_nmethod(JavaThread* thread, nmethod* nm) {
 202     log(thread, "nmethod %d%s " INTPTR_FORMAT " code [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",
 203         nm->compile_id(), nm->is_osr_method() ? "%" : "",
 204         p2i(nm), p2i(nm->code_begin()), p2i(nm->code_end()));
 205   }
 206 
 207   void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) {
 208     StringLogMessage lm;
 209     lm.print("%4d   COMPILE SKIPPED: %s", task->compile_id(), reason);
 210     if (retry_message != NULL) {


1225   // some prerequisites that are compiler specific
1226   if (comp->is_c2()) {
1227     method->constants()->resolve_string_constants(CHECK_AND_CLEAR_NULL);
1228     // Resolve all classes seen in the signature of the method
1229     // we are compiling.
1230     Method::load_signature_classes(method, CHECK_AND_CLEAR_NULL);
1231   }
1232 
1233   // If the method is native, do the lookup in the thread requesting
1234   // the compilation. Native lookups can load code, which is not
1235   // permitted during compilation.
1236   //
1237   // Note: A native method implies non-osr compilation which is
1238   //       checked with an assertion at the entry of this method.
1239   if (method->is_native() && !method->is_method_handle_intrinsic()) {
1240     bool in_base_library;
1241     address adr = NativeLookup::lookup(method, in_base_library, THREAD);
1242     if (HAS_PENDING_EXCEPTION) {
1243       // In case of an exception looking up the method, we just forget
1244       // about it. The interpreter will kick-in and throw the exception.
1245       method->set_not_compilable(); // implies is_not_osr_compilable()
1246       CLEAR_PENDING_EXCEPTION;
1247       return NULL;
1248     }
1249     assert(method->has_native_function(), "must have native code by now");
1250   }
1251 
1252   // RedefineClasses() has replaced this method; just return
1253   if (method->is_old()) {
1254     return NULL;
1255   }
1256 
1257   // JVMTI -- post_compile_event requires jmethod_id() that may require
1258   // a lock the compiling thread can not acquire. Prefetch it here.
1259   if (JvmtiExport::should_post_compiled_method_load()) {
1260     method->jmethod_id();
1261   }
1262 
1263   // do the compilation
1264   if (method->is_native()) {
1265     if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) {


1353  * for each method.  This means that the check below is overly
1354  * conservative in the sense that an osr compilation in the queue
1355  * will block a normal compilation from entering the queue (and vice
1356  * versa).  This can be remedied by a full queue search to disambiguate
1357  * cases.  If it is deemed profitable, this may be done.
1358  */
1359 bool CompileBroker::compilation_is_in_queue(const methodHandle& method) {
1360   return method->queued_for_compilation();
1361 }
1362 
1363 // ------------------------------------------------------------------
1364 // CompileBroker::compilation_is_prohibited
1365 //
1366 // See if this compilation is not allowed.
1367 bool CompileBroker::compilation_is_prohibited(const methodHandle& method, int osr_bci, int comp_level, bool excluded) {
1368   bool is_native = method->is_native();
1369   // Some compilers may not support the compilation of natives.
1370   AbstractCompiler *comp = compiler(comp_level);
1371   if (is_native &&
1372       (!CICompileNatives || comp == NULL || !comp->supports_native())) {
1373     method->set_not_compilable_quietly(comp_level);
1374     return true;
1375   }
1376 
1377   bool is_osr = (osr_bci != standard_entry_bci);
1378   // Some compilers may not support on stack replacement.
1379   if (is_osr &&
1380       (!CICompileOSR || comp == NULL || !comp->supports_osr())) {
1381     method->set_not_osr_compilable(comp_level);
1382     return true;
1383   }
1384 
1385   // The method may be explicitly excluded by the user.
1386   double scale;
1387   if (excluded || (CompilerOracle::has_option_value(method, "CompileThresholdScaling", scale) && scale == 0)) {
1388     bool quietly = CompilerOracle::should_exclude_quietly();
1389     if (PrintCompilation && !quietly) {
1390       // This does not happen quietly...
1391       ResourceMark rm;
1392       tty->print("### Excluding %s:%s",
1393                  method->is_native() ? "generation of native wrapper" : "compile",
1394                  (method->is_static() ? " static" : ""));
1395       method->print_short_name(tty);
1396       tty->cr();
1397     }
1398     method->set_not_compilable(comp_level, !quietly, "excluded by CompileCommand");
1399   }
1400 
1401   return false;
1402 }
1403 
1404 /**
1405  * Generate serialized IDs for compilation requests. If certain debugging flags are used
1406  * and the ID is not within the specified range, the method is not compiled and 0 is returned.
1407  * The function also allows to generate separate compilation IDs for OSR compilations.
1408  */
1409 int CompileBroker::assign_compile_id(const methodHandle& method, int osr_bci) {
1410 #ifdef ASSERT
1411   bool is_osr = (osr_bci != standard_entry_bci);
1412   int id;
1413   if (method->is_native()) {
1414     assert(!is_osr, "can't be osr");
1415     // Adapters, native wrappers and method handle intrinsics
1416     // should be generated always.
1417     return Atomic::add(1, &_compilation_id);
1418   } else if (CICountOSR && is_osr) {
1419     id = Atomic::add(1, &_osr_compilation_id);
1420     if (CIStartOSR <= id && id < CIStopOSR) {
1421       return id;
1422     }
1423   } else {
1424     id = Atomic::add(1, &_compilation_id);
1425     if (CIStart <= id && id < CIStop) {
1426       return id;
1427     }
1428   }
1429 
1430   // Method was not in the appropriate compilation range.
1431   method->set_not_compilable_quietly();
1432   return 0;
1433 #else
1434   // CICountOSR is a develop flag and set to 'false' by default. In a product built,
1435   // only _compilation_id is incremented.
1436   return Atomic::add(1, &_compilation_id);
1437 #endif
1438 }
1439 
1440 // ------------------------------------------------------------------
1441 // CompileBroker::assign_compile_id_unlocked
1442 //
1443 // Public wrapper for assign_compile_id that acquires the needed locks
1444 uint CompileBroker::assign_compile_id_unlocked(Thread* thread, const methodHandle& method, int osr_bci) {
1445   MutexLocker locker(MethodCompileQueue_lock, thread);
1446   return assign_compile_id(method, osr_bci);
1447 }
1448 
1449 // ------------------------------------------------------------------
1450 // CompileBroker::preload_classes
1451 void CompileBroker::preload_classes(const methodHandle& method, TRAPS) {


2178     tty->print("%4d ", compile_id);    // print compilation number
2179     tty->print("%s ", (is_osr ? "%" : " "));
2180     if (task->code() != NULL) {
2181       tty->print("size: %d(%d) ", task->code()->total_size(), task->code()->insts_size());
2182     }
2183     tty->print_cr("time: %d inlined: %d bytes", (int)time.milliseconds(), task->num_inlined_bytecodes());
2184   }
2185 
2186   Log(compilation, codecache) log;
2187   if (log.is_debug()) {
2188     LogStream ls(log.debug());
2189     codecache_print(&ls, /* detailed= */ false);
2190   }
2191   if (PrintCodeCacheOnCompilation) {
2192     codecache_print(/* detailed= */ false);
2193   }
2194   // Disable compilation, if required.
2195   switch (compilable) {
2196   case ciEnv::MethodCompilable_never:
2197     if (is_osr)
2198       method->set_not_osr_compilable_quietly();
2199     else
2200       method->set_not_compilable_quietly();
2201     break;
2202   case ciEnv::MethodCompilable_not_at_tier:
2203     if (is_osr)
2204       method->set_not_osr_compilable_quietly(task_level);
2205     else
2206       method->set_not_compilable_quietly(task_level);
2207     break;
2208   }
2209 
2210   // Note that the queued_for_compilation bits are cleared without
2211   // protection of a mutex. [They were set by the requester thread,
2212   // when adding the task to the compile queue -- at which time the
2213   // compile queue lock was held. Subsequently, we acquired the compile
2214   // queue lock to get this task off the compile queue; thus (to belabour
2215   // the point somewhat) our clearing of the bits must be occurring
2216   // only after the setting of the bits. See also 14012000 above.
2217   method->clear_queued_for_compilation();
2218 }
2219 
2220 /**
2221  * The CodeCache is full. Print warning and disable compilation.
2222  * Schedule code cache cleaning so compilation can continue later.
2223  * This function needs to be called only from CodeCache::allocate(),
2224  * since we currently handle a full code cache uniformly.
2225  */
2226 void CompileBroker::handle_full_code_cache(int code_blob_type) {


2623   out->cr();
2624   out->print_cr("         Reserved size : " SIZE_FORMAT_W(7) " KB", CodeCache::max_capacity() / K);
2625   out->print_cr("        Committed size : " SIZE_FORMAT_W(7) " KB", CodeCache::capacity() / K);
2626   out->print_cr("  Unallocated capacity : " SIZE_FORMAT_W(7) " KB", CodeCache::unallocated_capacity() / K);
2627   out->cr();
2628 
2629   out->cr();
2630   out->print_cr("CodeCache cleaning overview");
2631   out->print_cr("--------------------------------------------------------");
2632   out->cr();
2633   NMethodSweeper::print(out);
2634   out->print_cr("--------------------------------------------------------");
2635   out->cr();
2636 }
2637 
2638 // Note: tty_lock must not be held upon entry to this function.
2639 //       Print functions called from herein do "micro-locking" on tty_lock.
2640 //       That's a tradeoff which keeps together important blocks of output.
2641 //       At the same time, continuous tty_lock hold time is kept in check,
2642 //       preventing concurrently printing threads from stalling a long time.
2643 void CompileBroker::print_heapinfo(outputStream* out, const char* function, const char* granularity) {
2644   TimeStamp ts_total;
2645   TimeStamp ts_global;
2646   TimeStamp ts;
2647 
2648   bool allFun = !strcmp(function, "all");
2649   bool aggregate = !strcmp(function, "aggregate") || !strcmp(function, "analyze") || allFun;
2650   bool usedSpace = !strcmp(function, "UsedSpace") || allFun;
2651   bool freeSpace = !strcmp(function, "FreeSpace") || allFun;
2652   bool methodCount = !strcmp(function, "MethodCount") || allFun;
2653   bool methodSpace = !strcmp(function, "MethodSpace") || allFun;
2654   bool methodAge = !strcmp(function, "MethodAge") || allFun;
2655   bool methodNames = !strcmp(function, "MethodNames") || allFun;
2656   bool discard = !strcmp(function, "discard") || allFun;
2657 
2658   if (out == NULL) {
2659     out = tty;
2660   }
2661 
2662   if (!(aggregate || usedSpace || freeSpace || methodCount || methodSpace || methodAge || methodNames || discard)) {
2663     out->print_cr("\n__ CodeHeapStateAnalytics: Function %s is not supported", function);


< prev index next >