40   _result(NULL)

    40   _result(NULL)

    41 {

    41 {

    42 }

    42 }

    43 

    43 

    44 void VM_ParallelGCFailedAllocation::doit() {

    44 void VM_ParallelGCFailedAllocation::doit() {

    47 

    46 

    48   ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

    47   ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

    49   assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "must be a ParallelScavengeHeap");

    48   assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "must be a ParallelScavengeHeap");

    50 

    49 

    51   GCCauseSetter gccs(heap, _gc_cause);

    50   GCCauseSetter gccs(heap, _gc_cause);

    52   _result = heap->failed_mem_allocate(_size, _is_tlab);

    51   _result = heap->failed_mem_allocate(_size, _is_tlab);

    53 

    52 

    54   if (_result == NULL && GC_locker::is_active_and_needs_gc()) {

    53   if (_result == NULL && GC_locker::is_active_and_needs_gc()) {

    55     set_gc_locked();

    54     set_gc_locked();

    56   }

    55   }

    59 }

    56 }

    60 

    57 

    61 VM_ParallelGCFailedPermanentAllocation::VM_ParallelGCFailedPermanentAllocation(size_t size,

    58 VM_ParallelGCFailedPermanentAllocation::VM_ParallelGCFailedPermanentAllocation(size_t size,

    62   unsigned int gc_count, unsigned int full_gc_count) :

    59   unsigned int gc_count, unsigned int full_gc_count) :

    63   VM_GC_Operation(gc_count, full_gc_count, true /* full */),

    60   VM_GC_Operation(gc_count, full_gc_count, true /* full */),

    65   _result(NULL)

    62   _result(NULL)

    66 {

    63 {

    67 }

    64 }

    68 

    65 

    69 void VM_ParallelGCFailedPermanentAllocation::doit() {

    66 void VM_ParallelGCFailedPermanentAllocation::doit() {

    72 

    68 

    73   ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

    69   ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

    74   assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "must be a ParallelScavengeHeap");

    70   assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "must be a ParallelScavengeHeap");

    75 

    71 

    76   GCCauseSetter gccs(heap, _gc_cause);

    72   GCCauseSetter gccs(heap, _gc_cause);

    77   _result = heap->failed_permanent_mem_allocate(_size);

    73   _result = heap->failed_permanent_mem_allocate(_size);

    78   if (_result == NULL && GC_locker::is_active_and_needs_gc()) {

    74   if (_result == NULL && GC_locker::is_active_and_needs_gc()) {

    79     set_gc_locked();

    75     set_gc_locked();

    80   }

    76   }

    82 }

    77 }

    83 

    78 

    84 // Only used for System.gc() calls

    79 // Only used for System.gc() calls

    85 VM_ParallelGCSystemGC::VM_ParallelGCSystemGC(unsigned int gc_count,

    80 VM_ParallelGCSystemGC::VM_ParallelGCSystemGC(unsigned int gc_count,

    86                                              unsigned int full_gc_count,

    81                                              unsigned int full_gc_count,

    89 {

    84 {

    90   _gc_cause = gc_cause;

    85   _gc_cause = gc_cause;

    91 }

    86 }

    92 

    87 

    93 void VM_ParallelGCSystemGC::doit() {

    88 void VM_ParallelGCSystemGC::doit() {

    96 

    90 

    97   ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

    91   ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

    98   assert(heap->kind() == CollectedHeap::ParallelScavengeHeap,

    92   assert(heap->kind() == CollectedHeap::ParallelScavengeHeap,

    99     "must be a ParallelScavengeHeap");

    93     "must be a ParallelScavengeHeap");

   100 

    94 

   104     // If (and only if) the scavenge fails, this will invoke a full gc.

    98     // If (and only if) the scavenge fails, this will invoke a full gc.

   105     heap->invoke_scavenge();

    99     heap->invoke_scavenge();

   106   } else {

   100   } else {

   107     heap->invoke_full_gc(false);

   101     heap->invoke_full_gc(false);

   108   }

   102   }

   110 }

   103 }