src/share/vm/runtime/vm_operations.hpp

Print this page
rev 1083 : code cache unloading for webrev 091214


  24 
  25 // The following classes are used for operations
  26 // initiated by a Java thread but that must
  27 // take place in the VMThread.
  28 
  29 #define VM_OP_ENUM(type)   VMOp_##type,
  30 
  31 // Note: When new VM_XXX comes up, add 'XXX' to the template table.
  32 #define VM_OPS_DO(template)                       \
  33   template(Dummy)                                 \
  34   template(ThreadStop)                            \
  35   template(ThreadDump)                            \
  36   template(PrintThreads)                          \
  37   template(FindDeadlocks)                         \
  38   template(ForceSafepoint)                        \
  39   template(ForceAsyncSafepoint)                   \
  40   template(Deoptimize)                            \
  41   template(DeoptimizeFrame)                       \
  42   template(DeoptimizeAll)                         \
  43   template(ZombieAll)                             \

  44   template(Verify)                                \
  45   template(PrintJNI)                              \
  46   template(HeapDumper)                            \
  47   template(DeoptimizeTheWorld)                    \
  48   template(GC_HeapInspection)                     \
  49   template(GenCollectFull)                        \
  50   template(GenCollectFullConcurrent)              \
  51   template(GenCollectForAllocation)               \
  52   template(GenCollectForPermanentAllocation)      \
  53   template(ParallelGCFailedAllocation)            \
  54   template(ParallelGCFailedPermanentAllocation)   \
  55   template(ParallelGCSystemGC)                    \
  56   template(CGC_Operation)                         \
  57   template(CMS_Initial_Mark)                      \
  58   template(CMS_Final_Remark)                      \
  59   template(G1CollectFull)                         \
  60   template(G1CollectForAllocation)                \
  61   template(G1IncCollectionPause)                  \
  62   template(EnableBiasedLocking)                   \
  63   template(RevokeBias)                            \


 224 
 225 class VM_Deoptimize: public VM_Operation {
 226  public:
 227   VM_Deoptimize() {}
 228   VMOp_Type type() const                        { return VMOp_Deoptimize; }
 229   void doit();
 230   bool allow_nested_vm_operations() const        { return true; }
 231 };
 232 
 233 class VM_DeoptimizeFrame: public VM_Operation {
 234  private:
 235   JavaThread* _thread;
 236   intptr_t*   _id;
 237  public:
 238   VM_DeoptimizeFrame(JavaThread* thread, intptr_t* id);
 239   VMOp_Type type() const                         { return VMOp_DeoptimizeFrame; }
 240   void doit();
 241   bool allow_nested_vm_operations() const        { return true;  }
 242 };
 243 










 244 #ifndef PRODUCT
 245 class VM_DeoptimizeAll: public VM_Operation {
 246  private:
 247   KlassHandle _dependee;
 248  public:
 249   VM_DeoptimizeAll() {}
 250   VMOp_Type type() const                         { return VMOp_DeoptimizeAll; }
 251   void doit();
 252   bool allow_nested_vm_operations() const        { return true; }
 253 };
 254 
 255 
 256 class VM_ZombieAll: public VM_Operation {
 257  public:
 258   VM_ZombieAll() {}
 259   VMOp_Type type() const                         { return VMOp_ZombieAll; }
 260   void doit();
 261   bool allow_nested_vm_operations() const        { return true; }
 262 };
 263 #endif // PRODUCT




  24 
  25 // The following classes are used for operations
  26 // initiated by a Java thread but that must
  27 // take place in the VMThread.
  28 
  29 #define VM_OP_ENUM(type)   VMOp_##type,
  30 
  31 // Note: When new VM_XXX comes up, add 'XXX' to the template table.
  32 #define VM_OPS_DO(template)                       \
  33   template(Dummy)                                 \
  34   template(ThreadStop)                            \
  35   template(ThreadDump)                            \
  36   template(PrintThreads)                          \
  37   template(FindDeadlocks)                         \
  38   template(ForceSafepoint)                        \
  39   template(ForceAsyncSafepoint)                   \
  40   template(Deoptimize)                            \
  41   template(DeoptimizeFrame)                       \
  42   template(DeoptimizeAll)                         \
  43   template(ZombieAll)                             \
  44   template(HandleFullCodeCache)                   \
  45   template(Verify)                                \
  46   template(PrintJNI)                              \
  47   template(HeapDumper)                            \
  48   template(DeoptimizeTheWorld)                    \
  49   template(GC_HeapInspection)                     \
  50   template(GenCollectFull)                        \
  51   template(GenCollectFullConcurrent)              \
  52   template(GenCollectForAllocation)               \
  53   template(GenCollectForPermanentAllocation)      \
  54   template(ParallelGCFailedAllocation)            \
  55   template(ParallelGCFailedPermanentAllocation)   \
  56   template(ParallelGCSystemGC)                    \
  57   template(CGC_Operation)                         \
  58   template(CMS_Initial_Mark)                      \
  59   template(CMS_Final_Remark)                      \
  60   template(G1CollectFull)                         \
  61   template(G1CollectForAllocation)                \
  62   template(G1IncCollectionPause)                  \
  63   template(EnableBiasedLocking)                   \
  64   template(RevokeBias)                            \


 225 
 226 class VM_Deoptimize: public VM_Operation {
 227  public:
 228   VM_Deoptimize() {}
 229   VMOp_Type type() const                        { return VMOp_Deoptimize; }
 230   void doit();
 231   bool allow_nested_vm_operations() const        { return true; }
 232 };
 233 
 234 class VM_DeoptimizeFrame: public VM_Operation {
 235  private:
 236   JavaThread* _thread;
 237   intptr_t*   _id;
 238  public:
 239   VM_DeoptimizeFrame(JavaThread* thread, intptr_t* id);
 240   VMOp_Type type() const                         { return VMOp_DeoptimizeFrame; }
 241   void doit();
 242   bool allow_nested_vm_operations() const        { return true;  }
 243 };
 244 
 245 class VM_HandleFullCodeCache: public VM_Operation {
 246  private:
 247   bool  _is_full;
 248  public:
 249   VM_HandleFullCodeCache(bool is_full)           { _is_full = is_full; }
 250   VMOp_Type type() const                         { return VMOp_HandleFullCodeCache; }
 251   void doit();
 252   bool allow_nested_vm_operations() const        { return true; }
 253 };
 254 
 255 #ifndef PRODUCT
 256 class VM_DeoptimizeAll: public VM_Operation {
 257  private:
 258   KlassHandle _dependee;
 259  public:
 260   VM_DeoptimizeAll() {}
 261   VMOp_Type type() const                         { return VMOp_DeoptimizeAll; }
 262   void doit();
 263   bool allow_nested_vm_operations() const        { return true; }
 264 };
 265 
 266 
 267 class VM_ZombieAll: public VM_Operation {
 268  public:
 269   VM_ZombieAll() {}
 270   VMOp_Type type() const                         { return VMOp_ZombieAll; }
 271   void doit();
 272   bool allow_nested_vm_operations() const        { return true; }
 273 };
 274 #endif // PRODUCT