index

src/share/vm/gc/shared/vmGCOperations.hpp

Print this page
rev 8854 : 8065331: Add trace events for failed allocations
Reviewed-by:


   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_SHARED_VMGCOPERATIONS_HPP
  26 #define SHARE_VM_GC_SHARED_VMGCOPERATIONS_HPP
  27 
  28 #include "gc/shared/collectedHeap.hpp"

  29 #include "gc/shared/genCollectedHeap.hpp"
  30 #include "memory/heapInspection.hpp"
  31 #include "prims/jvmtiExport.hpp"
  32 #include "runtime/handles.hpp"
  33 #include "runtime/jniHandles.hpp"
  34 #include "runtime/synchronizer.hpp"
  35 #include "runtime/vm_operations.hpp"
  36 
  37 // The following class hierarchy represents
  38 // a set of operations (VM_Operation) related to GC.
  39 //
  40 //  VM_Operation
  41 //      VM_GC_Operation
  42 //          VM_GC_HeapInspection
  43 //          VM_GenCollectFull
  44 //          VM_GenCollectFullConcurrent
  45 //          VM_ParallelGCSystemGC
  46 //          VM_CollectForAllocation
  47 //              VM_GenCollectForAllocation
  48 //              VM_ParallelGCFailedAllocation


 149   }
 150 
 151   ~VM_GC_HeapInspection() {}
 152   virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; }
 153   virtual bool skip_operation() const;
 154   virtual void doit();
 155   void set_csv_format(bool value) {_csv_format = value;}
 156   void set_print_help(bool value) {_print_help = value;}
 157   void set_print_class_stats(bool value) {_print_class_stats = value;}
 158   void set_columns(const char* value) {_columns = value;}
 159  protected:
 160   bool collect();
 161 };
 162 
 163 class VM_CollectForAllocation : public VM_GC_Operation {
 164  protected:
 165   size_t    _word_size; // Size of object to be allocated (in number of words)
 166   HeapWord* _result;    // Allocation result (NULL if allocation failed)
 167 
 168  public:
 169   VM_CollectForAllocation(size_t word_size, uint gc_count_before, GCCause::Cause cause)
 170     : VM_GC_Operation(gc_count_before, cause), _result(NULL), _word_size(word_size) {}
 171 
 172   HeapWord* result() const {
 173     return _result;
 174   }
 175 };
 176 
 177 class VM_GenCollectForAllocation : public VM_CollectForAllocation {
 178  private:
 179   bool        _tlab;                       // alloc is of a tlab.
 180  public:
 181   VM_GenCollectForAllocation(size_t word_size,
 182                              bool tlab,
 183                              uint gc_count_before)
 184     : VM_CollectForAllocation(word_size, gc_count_before, GCCause::_allocation_failure),
 185       _tlab(tlab) {
 186     assert(word_size != 0, "An allocation should always be requested with this operation.");
 187   }
 188   ~VM_GenCollectForAllocation()  {}
 189   virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; }
 190   virtual void doit();


 201                     GCCause::Cause gc_cause,
 202                     GenCollectedHeap::GenerationType max_generation)
 203     : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */),
 204       _max_generation(max_generation) { }
 205   ~VM_GenCollectFull() {}
 206   virtual VMOp_Type type() const { return VMOp_GenCollectFull; }
 207   virtual void doit();
 208 };
 209 
 210 class VM_CollectForMetadataAllocation: public VM_GC_Operation {
 211  private:
 212   MetaWord*                _result;
 213   size_t                   _size;     // size of object to be allocated
 214   Metaspace::MetadataType  _mdtype;
 215   ClassLoaderData*         _loader_data;
 216  public:
 217   VM_CollectForMetadataAllocation(ClassLoaderData* loader_data,
 218                                   size_t size, Metaspace::MetadataType mdtype,
 219                                   uint gc_count_before,
 220                                   uint full_gc_count_before,
 221                                   GCCause::Cause gc_cause)
 222     : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true),
 223       _loader_data(loader_data), _size(size), _mdtype(mdtype), _result(NULL) {
 224   }
 225   virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; }
 226   virtual void doit();
 227   MetaWord* result() const       { return _result; }
 228 
 229   bool initiate_concurrent_GC();
 230 };
 231 
 232 class SvcGCMarker : public StackObj {
 233  private:
 234   JvmtiGCMarker _jgcm;
 235  public:
 236   typedef enum { MINOR, FULL, OTHER } reason_type;
 237 
 238   SvcGCMarker(reason_type reason ) {
 239     VM_GC_Operation::notify_gc_begin(reason == FULL);
 240   }
 241 
 242   ~SvcGCMarker() {
 243     VM_GC_Operation::notify_gc_end();
 244   }


   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_SHARED_VMGCOPERATIONS_HPP
  26 #define SHARE_VM_GC_SHARED_VMGCOPERATIONS_HPP
  27 
  28 #include "gc/shared/collectedHeap.hpp"
  29 #include "gc/shared/gcId.hpp"
  30 #include "gc/shared/genCollectedHeap.hpp"
  31 #include "memory/heapInspection.hpp"
  32 #include "prims/jvmtiExport.hpp"
  33 #include "runtime/handles.hpp"
  34 #include "runtime/jniHandles.hpp"
  35 #include "runtime/synchronizer.hpp"
  36 #include "runtime/vm_operations.hpp"
  37 
  38 // The following class hierarchy represents
  39 // a set of operations (VM_Operation) related to GC.
  40 //
  41 //  VM_Operation
  42 //      VM_GC_Operation
  43 //          VM_GC_HeapInspection
  44 //          VM_GenCollectFull
  45 //          VM_GenCollectFullConcurrent
  46 //          VM_ParallelGCSystemGC
  47 //          VM_CollectForAllocation
  48 //              VM_GenCollectForAllocation
  49 //              VM_ParallelGCFailedAllocation


 150   }
 151 
 152   ~VM_GC_HeapInspection() {}
 153   virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; }
 154   virtual bool skip_operation() const;
 155   virtual void doit();
 156   void set_csv_format(bool value) {_csv_format = value;}
 157   void set_print_help(bool value) {_print_help = value;}
 158   void set_print_class_stats(bool value) {_print_class_stats = value;}
 159   void set_columns(const char* value) {_columns = value;}
 160  protected:
 161   bool collect();
 162 };
 163 
 164 class VM_CollectForAllocation : public VM_GC_Operation {
 165  protected:
 166   size_t    _word_size; // Size of object to be allocated (in number of words)
 167   HeapWord* _result;    // Allocation result (NULL if allocation failed)
 168 
 169  public:
 170   VM_CollectForAllocation(size_t word_size, uint gc_count_before, GCCause::Cause cause);

 171 
 172   HeapWord* result() const {
 173     return _result;
 174   }
 175 };
 176 
 177 class VM_GenCollectForAllocation : public VM_CollectForAllocation {
 178  private:
 179   bool        _tlab;                       // alloc is of a tlab.
 180  public:
 181   VM_GenCollectForAllocation(size_t word_size,
 182                              bool tlab,
 183                              uint gc_count_before)
 184     : VM_CollectForAllocation(word_size, gc_count_before, GCCause::_allocation_failure),
 185       _tlab(tlab) {
 186     assert(word_size != 0, "An allocation should always be requested with this operation.");
 187   }
 188   ~VM_GenCollectForAllocation()  {}
 189   virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; }
 190   virtual void doit();


 201                     GCCause::Cause gc_cause,
 202                     GenCollectedHeap::GenerationType max_generation)
 203     : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */),
 204       _max_generation(max_generation) { }
 205   ~VM_GenCollectFull() {}
 206   virtual VMOp_Type type() const { return VMOp_GenCollectFull; }
 207   virtual void doit();
 208 };
 209 
 210 class VM_CollectForMetadataAllocation: public VM_GC_Operation {
 211  private:
 212   MetaWord*                _result;
 213   size_t                   _size;     // size of object to be allocated
 214   Metaspace::MetadataType  _mdtype;
 215   ClassLoaderData*         _loader_data;
 216  public:
 217   VM_CollectForMetadataAllocation(ClassLoaderData* loader_data,
 218                                   size_t size, Metaspace::MetadataType mdtype,
 219                                   uint gc_count_before,
 220                                   uint full_gc_count_before,
 221                                   GCCause::Cause gc_cause);



 222   virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; }
 223   virtual void doit();
 224   MetaWord* result() const       { return _result; }
 225 
 226   bool initiate_concurrent_GC();
 227 };
 228 
 229 class SvcGCMarker : public StackObj {
 230  private:
 231   JvmtiGCMarker _jgcm;
 232  public:
 233   typedef enum { MINOR, FULL, OTHER } reason_type;
 234 
 235   SvcGCMarker(reason_type reason ) {
 236     VM_GC_Operation::notify_gc_begin(reason == FULL);
 237   }
 238 
 239   ~SvcGCMarker() {
 240     VM_GC_Operation::notify_gc_end();
 241   }
index