src/share/vm/prims/whitebox.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/prims

src/share/vm/prims/whitebox.cpp

Print this page
rev 7390 : 8028595: WhiteBox API for stress testing of TieredCompilation
Reviewed-by:


  56 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
  57 #include "gc_implementation/g1/heapRegionRemSet.hpp"
  58 #endif // INCLUDE_ALL_GCS
  59 
  60 #if INCLUDE_NMT
  61 #include "services/mallocSiteTable.hpp"
  62 #include "services/memTracker.hpp"
  63 #include "utilities/nativeCallStack.hpp"
  64 #endif // INCLUDE_NMT
  65 
  66 #include "compiler/compileBroker.hpp"
  67 #include "runtime/compilationPolicy.hpp"
  68 
  69 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
  70 
  71 #define SIZE_T_MAX_VALUE ((size_t) -1)
  72 
  73 bool WhiteBox::_used = false;
  74 volatile bool WhiteBox::compilation_locked = false;
  75 








  76 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
  77   return (jlong)(void*)JNIHandles::resolve(obj);
  78 WB_END
  79 
  80 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
  81   return heapOopSize;
  82 WB_END
  83 
  84 
  85 class WBIsKlassAliveClosure : public KlassClosure {
  86     Symbol* _name;
  87     bool _found;
  88 public:
  89     WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
  90 
  91     void do_klass(Klass* k) {
  92       if (_found) return;
  93       Symbol* ksym = k->name();
  94       if (ksym->fast_compare(_name) == 0) {
  95         _found = true;


 357     // Really can never go up to detail, verify that the code would never do this.
 358     MemTracker::transition_to(NMT_detail);
 359     assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
 360     return MemTracker::tracking_level() == NMT_minimal;
 361   }
 362 WB_END
 363 
 364 WB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o))
 365   int hash_size = MallocSiteTable::hash_buckets();
 366   assert(hash_size > 0, "NMT hash_size should be > 0");
 367   return (jint)hash_size;
 368 WB_END
 369 #endif // INCLUDE_NMT
 370 
 371 static jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) {
 372   assert(method != NULL, "method should not be null");
 373   ThreadToNativeFromVM ttn(thread);
 374   return env->FromReflectedMethod(method);
 375 }
 376 





































 377 WB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o))
 378   MutexLockerEx mu(Compile_lock);
 379   CodeCache::mark_all_nmethods_for_deoptimization();
 380   VM_Deoptimize op;
 381   VMThread::execute(&op);
 382 WB_END
 383 
 384 WB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
 385   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 386   int result = 0;
 387   CHECK_JNI_EXCEPTION_(env, result);
 388   MutexLockerEx mu(Compile_lock);
 389   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 390   if (is_osr) {
 391     result += mh->mark_osr_nmethods();
 392   } else if (mh->code() != NULL) {
 393     mh->code()->mark_for_deoptimization();
 394     ++result;
 395   }
 396   result += CodeCache::mark_for_deoptimization(mh());


 479 WB_END
 480 
 481 WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
 482   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 483   CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
 484   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 485   bool result = mh->force_inline();
 486   mh->set_force_inline(value == JNI_TRUE);
 487   return result;
 488 WB_END
 489 
 490 WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci))
 491   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 492   CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
 493   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 494   nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), "WhiteBox", THREAD);
 495   MutexLockerEx mu(Compile_lock);
 496   return (mh->queued_for_compilation() || nm != NULL);
 497 WB_END
 498 
 499 class VM_WhiteBoxOperation : public VM_Operation {
 500  public:
 501   VM_WhiteBoxOperation()                         { }
 502   VMOp_Type type()                  const        { return VMOp_WhiteBoxOperation; }
 503   bool allow_nested_vm_operations() const        { return true; }
 504 };
 505 
 506 class AlwaysFalseClosure : public BoolObjectClosure {
 507  public:
 508   bool do_object_b(oop p) { return false; }
 509 };
 510 
 511 static AlwaysFalseClosure always_false;
 512 
 513 WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method))
 514   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 515   CHECK_JNI_EXCEPTION(env);
 516   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 517   MutexLockerEx mu(Compile_lock);
 518   MethodData* mdo = mh->method_data();
 519   MethodCounters* mcs = mh->method_counters();
 520 
 521   if (mdo != NULL) {
 522     mdo->init();
 523     ResourceMark rm;
 524     int arg_count = mdo->method()->size_of_parameters();
 525     for (int i = 0; i < arg_count; i++) {


 714   SetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAtPut);
 715 WB_END
 716 
 717 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
 718   ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI
 719   const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);
 720   ccstr ccstrResult = ccstrValue;
 721   bool needFree;
 722   {
 723     ThreadInVMfromNative ttvfn(thread); // back to VM
 724     needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);
 725   }
 726   if (value != NULL) {
 727     env->ReleaseStringUTFChars(value, ccstrValue);
 728   }
 729   if (needFree) {
 730     FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);
 731   }
 732 WB_END
 733 
 734 
 735 WB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout))
 736   WhiteBox::compilation_locked = true;
 737 WB_END
 738 
 739 WB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o))
 740   MonitorLockerEx mo(Compilation_lock, Mutex::_no_safepoint_check_flag);
 741   WhiteBox::compilation_locked = false;
 742   mo.notify_all();
 743 WB_END
 744 
 745 void WhiteBox::force_sweep() {
 746   guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
 747   {
 748     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 749     NMethodSweeper::_should_sweep = true;
 750   }
 751   NMethodSweeper::possibly_sweep();
 752 }
 753 
 754 WB_ENTRY(void, WB_ForceNMethodSweep(JNIEnv* env, jobject o))


1119   {CC"readFromNoaccessArea",CC"()V",                  (void*)&WB_ReadFromNoaccessArea},
1120   {CC"stressVirtualSpaceResize",CC"(JJJ)I",           (void*)&WB_StressVirtualSpaceResize},
1121 #if INCLUDE_ALL_GCS
1122   {CC"g1InConcurrentMark", CC"()Z",                   (void*)&WB_G1InConcurrentMark},
1123   {CC"g1IsHumongous",      CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous     },
1124   {CC"g1NumFreeRegions",   CC"()J",                   (void*)&WB_G1NumFreeRegions  },
1125   {CC"g1RegionSize",       CC"()I",                   (void*)&WB_G1RegionSize      },
1126 #endif // INCLUDE_ALL_GCS
1127 #if INCLUDE_NMT
1128   {CC"NMTMalloc",           CC"(J)J",                 (void*)&WB_NMTMalloc          },
1129   {CC"NMTMallocWithPseudoStack", CC"(JI)J",           (void*)&WB_NMTMallocWithPseudoStack},
1130   {CC"NMTFree",             CC"(J)V",                 (void*)&WB_NMTFree            },
1131   {CC"NMTReserveMemory",    CC"(J)J",                 (void*)&WB_NMTReserveMemory   },
1132   {CC"NMTCommitMemory",     CC"(JJ)V",                (void*)&WB_NMTCommitMemory    },
1133   {CC"NMTUncommitMemory",   CC"(JJ)V",                (void*)&WB_NMTUncommitMemory  },
1134   {CC"NMTReleaseMemory",    CC"(JJ)V",                (void*)&WB_NMTReleaseMemory   },
1135   {CC"NMTIsDetailSupported",CC"()Z",                  (void*)&WB_NMTIsDetailSupported},
1136   {CC"NMTChangeTrackingLevel", CC"()Z",               (void*)&WB_NMTChangeTrackingLevel},
1137   {CC"NMTGetHashSize",      CC"()I",                  (void*)&WB_NMTGetHashSize     },
1138 #endif // INCLUDE_NMT

1139   {CC"deoptimizeAll",      CC"()V",                   (void*)&WB_DeoptimizeAll     },
1140   {CC"deoptimizeMethod",   CC"(Ljava/lang/reflect/Executable;Z)I",
1141                                                       (void*)&WB_DeoptimizeMethod  },
1142   {CC"isMethodCompiled",   CC"(Ljava/lang/reflect/Executable;Z)Z",
1143                                                       (void*)&WB_IsMethodCompiled  },
1144   {CC"isMethodCompilable", CC"(Ljava/lang/reflect/Executable;IZ)Z",
1145                                                       (void*)&WB_IsMethodCompilable},
1146   {CC"isMethodQueuedForCompilation",
1147       CC"(Ljava/lang/reflect/Executable;)Z",          (void*)&WB_IsMethodQueuedForCompilation},
1148   {CC"makeMethodNotCompilable",
1149       CC"(Ljava/lang/reflect/Executable;IZ)V",        (void*)&WB_MakeMethodNotCompilable},
1150   {CC"testSetDontInlineMethod",
1151       CC"(Ljava/lang/reflect/Executable;Z)Z",         (void*)&WB_TestSetDontInlineMethod},
1152   {CC"getMethodCompilationLevel",
1153       CC"(Ljava/lang/reflect/Executable;Z)I",         (void*)&WB_GetMethodCompilationLevel},
1154   {CC"getMethodEntryBci",
1155       CC"(Ljava/lang/reflect/Executable;)I",          (void*)&WB_GetMethodEntryBci},
1156   {CC"getCompileQueueSize",
1157       CC"(I)I",                                       (void*)&WB_GetCompileQueueSize},
1158   {CC"testSetForceInlineMethod",




  56 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
  57 #include "gc_implementation/g1/heapRegionRemSet.hpp"
  58 #endif // INCLUDE_ALL_GCS
  59 
  60 #if INCLUDE_NMT
  61 #include "services/mallocSiteTable.hpp"
  62 #include "services/memTracker.hpp"
  63 #include "utilities/nativeCallStack.hpp"
  64 #endif // INCLUDE_NMT
  65 
  66 #include "compiler/compileBroker.hpp"
  67 #include "runtime/compilationPolicy.hpp"
  68 
  69 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
  70 
  71 #define SIZE_T_MAX_VALUE ((size_t) -1)
  72 
  73 bool WhiteBox::_used = false;
  74 volatile bool WhiteBox::compilation_locked = false;
  75 
  76 class VM_WhiteBoxOperation : public VM_Operation {
  77  public:
  78   VM_WhiteBoxOperation()                         { }
  79   VMOp_Type type()                  const        { return VMOp_WhiteBoxOperation; }
  80   bool allow_nested_vm_operations() const        { return true; }
  81 };
  82 
  83 
  84 WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj))
  85   return (jlong)(void*)JNIHandles::resolve(obj);
  86 WB_END
  87 
  88 WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o))
  89   return heapOopSize;
  90 WB_END
  91 
  92 
  93 class WBIsKlassAliveClosure : public KlassClosure {
  94     Symbol* _name;
  95     bool _found;
  96 public:
  97     WBIsKlassAliveClosure(Symbol* name) : _name(name), _found(false) {}
  98 
  99     void do_klass(Klass* k) {
 100       if (_found) return;
 101       Symbol* ksym = k->name();
 102       if (ksym->fast_compare(_name) == 0) {
 103         _found = true;


 365     // Really can never go up to detail, verify that the code would never do this.
 366     MemTracker::transition_to(NMT_detail);
 367     assert(MemTracker::tracking_level() == NMT_minimal, "Should still be minimal now");
 368     return MemTracker::tracking_level() == NMT_minimal;
 369   }
 370 WB_END
 371 
 372 WB_ENTRY(jint, WB_NMTGetHashSize(JNIEnv* env, jobject o))
 373   int hash_size = MallocSiteTable::hash_buckets();
 374   assert(hash_size > 0, "NMT hash_size should be > 0");
 375   return (jint)hash_size;
 376 WB_END
 377 #endif // INCLUDE_NMT
 378 
 379 static jmethodID reflected_method_to_jmid(JavaThread* thread, JNIEnv* env, jobject method) {
 380   assert(method != NULL, "method should not be null");
 381   ThreadToNativeFromVM ttn(thread);
 382   return env->FromReflectedMethod(method);
 383 }
 384 
 385 // Deoptimizes all compiled frames and makes nmethods not entrant if it's requested
 386 class VM_WhiteBoxDeoptimizeFrames : public VM_WhiteBoxOperation {
 387  private:
 388   int _result;
 389   const bool _make_not_entrant;
 390  public:
 391   VM_WhiteBoxDeoptimizeFrames(bool make_not_entrant) :
 392         _result(0), _make_not_entrant(make_not_entrant) { }
 393   int  result() const { return _result; }
 394 
 395   void doit() {
 396     for (JavaThread* t = Threads::first(); t != NULL; t = t->next()) {
 397       if (t->has_last_Java_frame()) {
 398         for (StackFrameStream fst(t, UseBiasedLocking); !fst.is_done(); fst.next()) {
 399           frame* f = fst.current();
 400           if (f->can_be_deoptimized() && !f->is_deoptimized_frame()) {
 401             RegisterMap* reg_map = fst.register_map();
 402             Deoptimization::deoptimize(t, *f, reg_map);
 403             if (_make_not_entrant) {
 404                 nmethod* nm = CodeCache::find_nmethod(f->pc());
 405                 assert(nm != NULL, "sanity check");
 406                 nm->make_not_entrant();
 407             }
 408             ++_result;
 409           }
 410         }
 411       }
 412     }
 413   }
 414 };
 415 
 416 WB_ENTRY(jint, WB_DeoptimizeFrames(JNIEnv* env, jobject o, jboolean make_not_entrant))
 417   VM_WhiteBoxDeoptimizeFrames op(make_not_entrant);
 418   VMThread::execute(&op);
 419   return op.result();
 420 WB_END
 421 
 422 WB_ENTRY(void, WB_DeoptimizeAll(JNIEnv* env, jobject o))
 423   MutexLockerEx mu(Compile_lock);
 424   CodeCache::mark_all_nmethods_for_deoptimization();
 425   VM_Deoptimize op;
 426   VMThread::execute(&op);
 427 WB_END
 428 
 429 WB_ENTRY(jint, WB_DeoptimizeMethod(JNIEnv* env, jobject o, jobject method, jboolean is_osr))
 430   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 431   int result = 0;
 432   CHECK_JNI_EXCEPTION_(env, result);
 433   MutexLockerEx mu(Compile_lock);
 434   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 435   if (is_osr) {
 436     result += mh->mark_osr_nmethods();
 437   } else if (mh->code() != NULL) {
 438     mh->code()->mark_for_deoptimization();
 439     ++result;
 440   }
 441   result += CodeCache::mark_for_deoptimization(mh());


 524 WB_END
 525 
 526 WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
 527   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 528   CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
 529   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 530   bool result = mh->force_inline();
 531   mh->set_force_inline(value == JNI_TRUE);
 532   return result;
 533 WB_END
 534 
 535 WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level, jint bci))
 536   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 537   CHECK_JNI_EXCEPTION_(env, JNI_FALSE);
 538   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 539   nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), "WhiteBox", THREAD);
 540   MutexLockerEx mu(Compile_lock);
 541   return (mh->queued_for_compilation() || nm != NULL);
 542 WB_END
 543 







 544 class AlwaysFalseClosure : public BoolObjectClosure {
 545  public:
 546   bool do_object_b(oop p) { return false; }
 547 };
 548 
 549 static AlwaysFalseClosure always_false;
 550 
 551 WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method))
 552   jmethodID jmid = reflected_method_to_jmid(thread, env, method);
 553   CHECK_JNI_EXCEPTION(env);
 554   methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
 555   MutexLockerEx mu(Compile_lock);
 556   MethodData* mdo = mh->method_data();
 557   MethodCounters* mcs = mh->method_counters();
 558 
 559   if (mdo != NULL) {
 560     mdo->init();
 561     ResourceMark rm;
 562     int arg_count = mdo->method()->size_of_parameters();
 563     for (int i = 0; i < arg_count; i++) {


 752   SetVMFlag <double> (thread, env, name, &result, &CommandLineFlags::doubleAtPut);
 753 WB_END
 754 
 755 WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
 756   ThreadToNativeFromVM ttnfv(thread);   // can't be in VM when we call JNI
 757   const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);
 758   ccstr ccstrResult = ccstrValue;
 759   bool needFree;
 760   {
 761     ThreadInVMfromNative ttvfn(thread); // back to VM
 762     needFree = SetVMFlag <ccstr> (thread, env, name, &ccstrResult, &CommandLineFlags::ccstrAtPut);
 763   }
 764   if (value != NULL) {
 765     env->ReleaseStringUTFChars(value, ccstrValue);
 766   }
 767   if (needFree) {
 768     FREE_C_HEAP_ARRAY(char, ccstrResult, mtInternal);
 769   }
 770 WB_END
 771 

 772 WB_ENTRY(void, WB_LockCompilation(JNIEnv* env, jobject o, jlong timeout))
 773   WhiteBox::compilation_locked = true;
 774 WB_END
 775 
 776 WB_ENTRY(void, WB_UnlockCompilation(JNIEnv* env, jobject o))
 777   MonitorLockerEx mo(Compilation_lock, Mutex::_no_safepoint_check_flag);
 778   WhiteBox::compilation_locked = false;
 779   mo.notify_all();
 780 WB_END
 781 
 782 void WhiteBox::force_sweep() {
 783   guarantee(WhiteBoxAPI, "internal testing API :: WhiteBox has to enabled");
 784   {
 785     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
 786     NMethodSweeper::_should_sweep = true;
 787   }
 788   NMethodSweeper::possibly_sweep();
 789 }
 790 
 791 WB_ENTRY(void, WB_ForceNMethodSweep(JNIEnv* env, jobject o))


1156   {CC"readFromNoaccessArea",CC"()V",                  (void*)&WB_ReadFromNoaccessArea},
1157   {CC"stressVirtualSpaceResize",CC"(JJJ)I",           (void*)&WB_StressVirtualSpaceResize},
1158 #if INCLUDE_ALL_GCS
1159   {CC"g1InConcurrentMark", CC"()Z",                   (void*)&WB_G1InConcurrentMark},
1160   {CC"g1IsHumongous",      CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous     },
1161   {CC"g1NumFreeRegions",   CC"()J",                   (void*)&WB_G1NumFreeRegions  },
1162   {CC"g1RegionSize",       CC"()I",                   (void*)&WB_G1RegionSize      },
1163 #endif // INCLUDE_ALL_GCS
1164 #if INCLUDE_NMT
1165   {CC"NMTMalloc",           CC"(J)J",                 (void*)&WB_NMTMalloc          },
1166   {CC"NMTMallocWithPseudoStack", CC"(JI)J",           (void*)&WB_NMTMallocWithPseudoStack},
1167   {CC"NMTFree",             CC"(J)V",                 (void*)&WB_NMTFree            },
1168   {CC"NMTReserveMemory",    CC"(J)J",                 (void*)&WB_NMTReserveMemory   },
1169   {CC"NMTCommitMemory",     CC"(JJ)V",                (void*)&WB_NMTCommitMemory    },
1170   {CC"NMTUncommitMemory",   CC"(JJ)V",                (void*)&WB_NMTUncommitMemory  },
1171   {CC"NMTReleaseMemory",    CC"(JJ)V",                (void*)&WB_NMTReleaseMemory   },
1172   {CC"NMTIsDetailSupported",CC"()Z",                  (void*)&WB_NMTIsDetailSupported},
1173   {CC"NMTChangeTrackingLevel", CC"()Z",               (void*)&WB_NMTChangeTrackingLevel},
1174   {CC"NMTGetHashSize",      CC"()I",                  (void*)&WB_NMTGetHashSize     },
1175 #endif // INCLUDE_NMT
1176   {CC"deoptimizeFrames",   CC"(Z)I",                  (void*)&WB_DeoptimizeFrames  },
1177   {CC"deoptimizeAll",      CC"()V",                   (void*)&WB_DeoptimizeAll     },
1178   {CC"deoptimizeMethod",   CC"(Ljava/lang/reflect/Executable;Z)I",
1179                                                       (void*)&WB_DeoptimizeMethod  },
1180   {CC"isMethodCompiled",   CC"(Ljava/lang/reflect/Executable;Z)Z",
1181                                                       (void*)&WB_IsMethodCompiled  },
1182   {CC"isMethodCompilable", CC"(Ljava/lang/reflect/Executable;IZ)Z",
1183                                                       (void*)&WB_IsMethodCompilable},
1184   {CC"isMethodQueuedForCompilation",
1185       CC"(Ljava/lang/reflect/Executable;)Z",          (void*)&WB_IsMethodQueuedForCompilation},
1186   {CC"makeMethodNotCompilable",
1187       CC"(Ljava/lang/reflect/Executable;IZ)V",        (void*)&WB_MakeMethodNotCompilable},
1188   {CC"testSetDontInlineMethod",
1189       CC"(Ljava/lang/reflect/Executable;Z)Z",         (void*)&WB_TestSetDontInlineMethod},
1190   {CC"getMethodCompilationLevel",
1191       CC"(Ljava/lang/reflect/Executable;Z)I",         (void*)&WB_GetMethodCompilationLevel},
1192   {CC"getMethodEntryBci",
1193       CC"(Ljava/lang/reflect/Executable;)I",          (void*)&WB_GetMethodEntryBci},
1194   {CC"getCompileQueueSize",
1195       CC"(I)I",                                       (void*)&WB_GetCompileQueueSize},
1196   {CC"testSetForceInlineMethod",


src/share/vm/prims/whitebox.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File