< prev index next >

src/hotspot/share/gc/z/zCollectedHeap.cpp

Print this page
rev 57511 : [mq]: metaspace-improvement


  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 #include "precompiled.hpp"
  25 #include "gc/shared/gcHeapSummary.hpp"
  26 #include "gc/shared/suspendibleThreadSet.hpp"
  27 #include "gc/z/zCollectedHeap.hpp"
  28 #include "gc/z/zGlobals.hpp"
  29 #include "gc/z/zHeap.inline.hpp"
  30 #include "gc/z/zNMethod.hpp"
  31 #include "gc/z/zServiceability.hpp"
  32 #include "gc/z/zStat.hpp"
  33 #include "gc/z/zUtils.inline.hpp"


  34 #include "memory/universe.hpp"
  35 #include "runtime/mutexLocker.hpp"
  36 
  37 ZCollectedHeap* ZCollectedHeap::heap() {
  38   CollectedHeap* heap = Universe::heap();
  39   assert(heap != NULL, "Uninitialized access to ZCollectedHeap::heap()");
  40   assert(heap->kind() == CollectedHeap::Z, "Invalid name");
  41   return (ZCollectedHeap*)heap;
  42 }
  43 
  44 ZCollectedHeap::ZCollectedHeap() :
  45     _soft_ref_policy(),
  46     _barrier_set(),
  47     _initialize(&_barrier_set),
  48     _heap(),
  49     _director(new ZDirector()),
  50     _driver(new ZDriver()),
  51     _uncommitter(new ZUncommitter()),
  52     _stat(new ZStat()),
  53     _runtime_workers() {}


 117 }
 118 
 119 HeapWord* ZCollectedHeap::allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size) {
 120   const size_t size_in_bytes = ZUtils::words_to_bytes(align_object_size(requested_size));
 121   const uintptr_t addr = _heap.alloc_tlab(size_in_bytes);
 122 
 123   if (addr != 0) {
 124     *actual_size = requested_size;
 125   }
 126 
 127   return (HeapWord*)addr;
 128 }
 129 
 130 HeapWord* ZCollectedHeap::mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded) {
 131   const size_t size_in_bytes = ZUtils::words_to_bytes(align_object_size(size));
 132   return (HeapWord*)_heap.alloc_object(size_in_bytes);
 133 }
 134 
 135 MetaWord* ZCollectedHeap::satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
 136                                                              size_t size,
 137                                                              Metaspace::MetadataType mdtype) {
 138   MetaWord* result;
 139 
 140   // Start asynchronous GC
 141   collect(GCCause::_metadata_GC_threshold);
 142 
 143   // Expand and retry allocation
 144   result = loader_data->metaspace_non_null()->expand_and_allocate(size, mdtype);
 145   if (result != NULL) {
 146     return result;
 147   }
 148 
 149   // Start synchronous GC
 150   collect(GCCause::_metadata_GC_clear_soft_refs);
 151 
 152   // Retry allocation
 153   result = loader_data->metaspace_non_null()->allocate(size, mdtype);
 154   if (result != NULL) {
 155     return result;
 156   }
 157 




  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 #include "precompiled.hpp"
  25 #include "gc/shared/gcHeapSummary.hpp"
  26 #include "gc/shared/suspendibleThreadSet.hpp"
  27 #include "gc/z/zCollectedHeap.hpp"
  28 #include "gc/z/zGlobals.hpp"
  29 #include "gc/z/zHeap.inline.hpp"
  30 #include "gc/z/zNMethod.hpp"
  31 #include "gc/z/zServiceability.hpp"
  32 #include "gc/z/zStat.hpp"
  33 #include "gc/z/zUtils.inline.hpp"
  34 #include "memory/metaspace/classLoaderMetaspace.hpp"
  35 #include "memory/metaspace/metaspaceEnums.hpp"
  36 #include "memory/universe.hpp"
  37 #include "runtime/mutexLocker.hpp"
  38 
  39 ZCollectedHeap* ZCollectedHeap::heap() {
  40   CollectedHeap* heap = Universe::heap();
  41   assert(heap != NULL, "Uninitialized access to ZCollectedHeap::heap()");
  42   assert(heap->kind() == CollectedHeap::Z, "Invalid name");
  43   return (ZCollectedHeap*)heap;
  44 }
  45 
  46 ZCollectedHeap::ZCollectedHeap() :
  47     _soft_ref_policy(),
  48     _barrier_set(),
  49     _initialize(&_barrier_set),
  50     _heap(),
  51     _director(new ZDirector()),
  52     _driver(new ZDriver()),
  53     _uncommitter(new ZUncommitter()),
  54     _stat(new ZStat()),
  55     _runtime_workers() {}


 119 }
 120 
 121 HeapWord* ZCollectedHeap::allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size) {
 122   const size_t size_in_bytes = ZUtils::words_to_bytes(align_object_size(requested_size));
 123   const uintptr_t addr = _heap.alloc_tlab(size_in_bytes);
 124 
 125   if (addr != 0) {
 126     *actual_size = requested_size;
 127   }
 128 
 129   return (HeapWord*)addr;
 130 }
 131 
 132 HeapWord* ZCollectedHeap::mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded) {
 133   const size_t size_in_bytes = ZUtils::words_to_bytes(align_object_size(size));
 134   return (HeapWord*)_heap.alloc_object(size_in_bytes);
 135 }
 136 
 137 MetaWord* ZCollectedHeap::satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
 138                                                              size_t size,
 139                                                              metaspace::MetadataType mdtype) {
 140   MetaWord* result;
 141 
 142   // Start asynchronous GC
 143   collect(GCCause::_metadata_GC_threshold);
 144 
 145   // Expand and retry allocation
 146   result = loader_data->metaspace_non_null()->expand_and_allocate(size, mdtype);
 147   if (result != NULL) {
 148     return result;
 149   }
 150 
 151   // Start synchronous GC
 152   collect(GCCause::_metadata_GC_clear_soft_refs);
 153 
 154   // Retry allocation
 155   result = loader_data->metaspace_non_null()->allocate(size, mdtype);
 156   if (result != NULL) {
 157     return result;
 158   }
 159 


< prev index next >