88 // 0 is a "special" value in set_n_threads() which translates to 89 // setting _n_threads to 1. 90 // 91 // Some code uses _n_termination to decide if work should be done in 92 // parallel. The notorious possibly_parallel_oops_do() in threads.cpp 93 // is an example of such code. Look for variable "is_par" for other 94 // examples. 95 // 96 // The active_workers is not reset to 0 after a parallel phase. It's 97 // value may be used in later phases and in one instance at least 98 // (the parallel remark) it has to be used (the parallel remark depends 99 // on the partitioning done in the previous parallel scavenge). 100 101 class SharedHeap : public CollectedHeap { 102 friend class VMStructs; 103 104 friend class VM_GC_Operation; 105 friend class VM_CGC_Operation; 106 107 protected: 108 // There should be only a single instance of "SharedHeap" in a program. 109 // This is enforced with the protected constructor below, which will also 110 // set the static pointer "_sh" to that instance. 111 static SharedHeap* _sh; 112 113 // If we're doing parallel GC, use this gang of threads. 114 FlexibleWorkGang* _workers; 115 116 // Full initialization is done in a concrete subtype's "initialize" 117 // function. 118 SharedHeap(); 119 120 // Returns true if the calling thread holds the heap lock, 121 // or the calling thread is a par gc thread and the heap_lock is held 122 // by the vm thread doing a gc operation. 123 bool heap_lock_held_for_gc(); 124 // True if the heap_lock is held by the a non-gc thread invoking a gc 125 // operation. 126 bool _thread_holds_heap_lock_for_gc; 127 128 public: 129 static SharedHeap* heap() { return _sh; } 130 131 void set_barrier_set(BarrierSet* bs); 132 133 // Does operations required after initialization has been done. 134 virtual void post_initialize(); 135 136 // Initialization of ("weak") reference processing support 137 virtual void ref_processing_init(); 138 139 // Iteration functions. 140 void oop_iterate(ExtendedOopClosure* cl) = 0; 141 142 // Iterate over all spaces in use in the heap, in an undefined order. 143 virtual void space_iterate(SpaceClosure* cl) = 0; 144 145 // A SharedHeap will contain some number of spaces. This finds the 146 // space whose reserved area contains the given address, or else returns 147 // NULL. 148 virtual Space* space_containing(const void* addr) const = 0; 149 150 bool no_gc_in_progress() { return !is_gc_active(); } | 88 // 0 is a "special" value in set_n_threads() which translates to 89 // setting _n_threads to 1. 90 // 91 // Some code uses _n_termination to decide if work should be done in 92 // parallel. The notorious possibly_parallel_oops_do() in threads.cpp 93 // is an example of such code. Look for variable "is_par" for other 94 // examples. 95 // 96 // The active_workers is not reset to 0 after a parallel phase. It's 97 // value may be used in later phases and in one instance at least 98 // (the parallel remark) it has to be used (the parallel remark depends 99 // on the partitioning done in the previous parallel scavenge). 100 101 class SharedHeap : public CollectedHeap { 102 friend class VMStructs; 103 104 friend class VM_GC_Operation; 105 friend class VM_CGC_Operation; 106 107 protected: 108 // If we're doing parallel GC, use this gang of threads. 109 FlexibleWorkGang* _workers; 110 111 // Full initialization is done in a concrete subtype's "initialize" 112 // function. 113 SharedHeap(); 114 115 public: 116 void set_barrier_set(BarrierSet* bs); 117 118 // Does operations required after initialization has been done. 119 virtual void post_initialize(); 120 121 // Initialization of ("weak") reference processing support 122 virtual void ref_processing_init(); 123 124 // Iteration functions. 125 void oop_iterate(ExtendedOopClosure* cl) = 0; 126 127 // Iterate over all spaces in use in the heap, in an undefined order. 128 virtual void space_iterate(SpaceClosure* cl) = 0; 129 130 // A SharedHeap will contain some number of spaces. This finds the 131 // space whose reserved area contains the given address, or else returns 132 // NULL. 133 virtual Space* space_containing(const void* addr) const = 0; 134 135 bool no_gc_in_progress() { return !is_gc_active(); } |