1 /* 2 * Copyright (c) 2017, 2018, Red Hat, Inc. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 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_GC_EPSILON_EPSILONHEAP_HPP 26 #define SHARE_GC_EPSILON_EPSILONHEAP_HPP 27 28 #include "gc/shared/collectedHeap.hpp" 29 #include "gc/shared/softRefPolicy.hpp" 30 #include "gc/shared/space.hpp" 31 #include "gc/epsilon/epsilonMonitoringSupport.hpp" 32 #include "gc/epsilon/epsilonBarrierSet.hpp" 33 #include "services/memoryManager.hpp" 34 35 class EpsilonHeap : public CollectedHeap { 36 friend class VMStructs; 37 private: 38 SoftRefPolicy _soft_ref_policy; 39 EpsilonMonitoringSupport* _monitoring_support; 40 MemoryPool* _pool; 41 GCMemoryManager _memory_manager; 42 ContiguousSpace* _space; 43 VirtualSpace _virtual_space; 44 size_t _max_tlab_size; 45 size_t _step_counter_update; 46 size_t _step_heap_print; 47 int64_t _decay_time_ns; 48 volatile size_t _last_counter_update; 49 volatile size_t _last_heap_print; 50 51 public: 52 static EpsilonHeap* heap(); 53 EpsilonHeap()54 EpsilonHeap() : 55 _memory_manager("Epsilon Heap", ""), 56 _space(NULL) {}; 57 kind() const58 virtual Name kind() const { 59 return CollectedHeap::Epsilon; 60 } 61 name() const62 virtual const char* name() const { 63 return "Epsilon"; 64 } 65 soft_ref_policy()66 virtual SoftRefPolicy* soft_ref_policy() { 67 return &_soft_ref_policy; 68 } 69 70 virtual jint initialize(); 71 virtual void post_initialize(); 72 virtual void initialize_serviceability(); 73 74 virtual GrowableArray<GCMemoryManager*> memory_managers(); 75 virtual GrowableArray<MemoryPool*> memory_pools(); 76 max_capacity() const77 virtual size_t max_capacity() const { return _virtual_space.reserved_size(); } capacity() const78 virtual size_t capacity() const { return _virtual_space.committed_size(); } used() const79 virtual size_t used() const { return _space->used(); } 80 is_in(const void * p) const81 virtual bool is_in(const void* p) const { 82 return _space->is_in(p); 83 } 84 is_maximal_no_gc() const85 virtual bool is_maximal_no_gc() const { 86 // No GC is going to happen. Return "we are at max", when we are about to fail. 87 return used() == capacity(); 88 } 89 90 // Allocation 91 HeapWord* allocate_work(size_t size); 92 virtual HeapWord* mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded); 93 virtual HeapWord* allocate_new_tlab(size_t min_size, 94 size_t requested_size, 95 size_t* actual_size); 96 97 // TLAB allocation tlab_capacity(Thread * thr) const98 virtual size_t tlab_capacity(Thread* thr) const { return capacity(); } tlab_used(Thread * thr) const99 virtual size_t tlab_used(Thread* thr) const { return used(); } max_tlab_size() const100 virtual size_t max_tlab_size() const { return _max_tlab_size; } 101 virtual size_t unsafe_max_tlab_alloc(Thread* thr) const; 102 103 virtual void collect(GCCause::Cause cause); 104 virtual void do_full_collection(bool clear_all_soft_refs); 105 106 // Heap walking support 107 virtual void object_iterate(ObjectClosure* cl); 108 109 // Object pinning support: every object is implicitly pinned supports_object_pinning() const110 virtual bool supports_object_pinning() const { return true; } pin_object(JavaThread * thread,oop obj)111 virtual oop pin_object(JavaThread* thread, oop obj) { return obj; } unpin_object(JavaThread * thread,oop obj)112 virtual void unpin_object(JavaThread* thread, oop obj) { } 113 114 // No support for block parsing. block_start(const void * addr) const115 HeapWord* block_start(const void* addr) const { return NULL; } block_is_obj(const HeapWord * addr) const116 bool block_is_obj(const HeapWord* addr) const { return false; } 117 118 // No GC threads gc_threads_do(ThreadClosure * tc) const119 virtual void gc_threads_do(ThreadClosure* tc) const {} 120 121 // No nmethod handling register_nmethod(nmethod * nm)122 virtual void register_nmethod(nmethod* nm) {} unregister_nmethod(nmethod * nm)123 virtual void unregister_nmethod(nmethod* nm) {} flush_nmethod(nmethod * nm)124 virtual void flush_nmethod(nmethod* nm) {} verify_nmethod(nmethod * nm)125 virtual void verify_nmethod(nmethod* nm) {} 126 127 // No heap verification prepare_for_verify()128 virtual void prepare_for_verify() {} verify(VerifyOption option)129 virtual void verify(VerifyOption option) {} 130 reserved_region() const131 MemRegion reserved_region() const { return _reserved; } is_in_reserved(const void * addr) const132 bool is_in_reserved(const void* addr) const { return _reserved.contains(addr); } 133 134 virtual void print_on(outputStream* st) const; 135 virtual void print_tracing_info() const; 136 virtual bool print_location(outputStream* st, void* addr) const; 137 138 private: 139 void print_heap_info(size_t used) const; 140 void print_metaspace_info() const; 141 142 }; 143 144 #endif // SHARE_GC_EPSILON_EPSILONHEAP_HPP 145