87 guarantee(_region_array != NULL, "Could not allocate region_array");
88
89 // Create and register the ParCompactionManager(s) for the worker threads.
90 for(uint i=0; i<parallel_gc_threads; i++) {
91 _manager_array[i] = new ParCompactionManager();
92 guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
93 stack_array()->register_queue(i, _manager_array[i]->marking_stack());
94 _objarray_queues->register_queue(i, &_manager_array[i]->_objarray_stack);
95 region_array()->register_queue(i, _manager_array[i]->region_stack());
96 }
97
98 // The VMThread gets its own ParCompactionManager, which is not available
99 // for work stealing.
100 _manager_array[parallel_gc_threads] = new ParCompactionManager();
101 guarantee(_manager_array[parallel_gc_threads] != NULL,
102 "Could not create ParCompactionManager");
103 assert(ParallelScavengeHeap::heap()->workers().total_workers() != 0,
104 "Not initialized?");
105
106 _shadow_region_array = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<size_t >(10, true);
107 guarantee(_shadow_region_array != NULL, "Could not allocate shadow_region_array");
108
109 _shadow_region_monitor = new Monitor(Mutex::barrier, "CompactionManager monitor",
110 Mutex::_allow_vm_block_flag, Monitor::_safepoint_check_never);
111 guarantee(_shadow_region_monitor != NULL, "Could not allocate shadow_region_monitor");
112 }
113
114 void ParCompactionManager::reset_all_bitmap_query_caches() {
115 uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().total_workers();
116 for (uint i=0; i<=parallel_gc_threads; i++) {
117 _manager_array[i]->reset_bitmap_query_cache();
118 }
119 }
120
121 bool ParCompactionManager::should_update() {
122 assert(action() != NotValid, "Action is not set");
123 return (action() == ParCompactionManager::Update) ||
124 (action() == ParCompactionManager::CopyAndUpdate) ||
125 (action() == ParCompactionManager::UpdateAndCopy);
126 }
127
128 bool ParCompactionManager::should_copy() {
129 assert(action() != NotValid, "Action is not set");
130 return (action() == ParCompactionManager::Copy) ||
131 (action() == ParCompactionManager::CopyAndUpdate) ||
178 while (true) {
179 MutexLocker ml(_shadow_region_monitor, Mutex::_no_safepoint_check_flag);
180 if (_shadow_region_array->is_empty()) {
181 // The corresponding heap region may be available now,
182 // so we don't need to acquire a shadow region anymore,
183 // and we return 0 to indicate this case
184 if (region_ptr->claimed()) {
185 return 0;
186 }
187 } else {
188 return _shadow_region_array->pop();
189 }
190 }
191 }
192
193 void ParCompactionManager::release_shadow_region(size_t shadow_region) {
194 MutexLocker ml(_shadow_region_monitor, Mutex::_no_safepoint_check_flag);
195 _shadow_region_array->append(shadow_region);
196 }
197
198 void ParCompactionManager::enqueue_shadow_region(size_t shadow_region) {
199 _shadow_region_array->append(shadow_region);
200 }
201
202 void ParCompactionManager::dequeue_shadow_region() {
203 _shadow_region_array->clear();
204 }
|
87 guarantee(_region_array != NULL, "Could not allocate region_array");
88
89 // Create and register the ParCompactionManager(s) for the worker threads.
90 for(uint i=0; i<parallel_gc_threads; i++) {
91 _manager_array[i] = new ParCompactionManager();
92 guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
93 stack_array()->register_queue(i, _manager_array[i]->marking_stack());
94 _objarray_queues->register_queue(i, &_manager_array[i]->_objarray_stack);
95 region_array()->register_queue(i, _manager_array[i]->region_stack());
96 }
97
98 // The VMThread gets its own ParCompactionManager, which is not available
99 // for work stealing.
100 _manager_array[parallel_gc_threads] = new ParCompactionManager();
101 guarantee(_manager_array[parallel_gc_threads] != NULL,
102 "Could not create ParCompactionManager");
103 assert(ParallelScavengeHeap::heap()->workers().total_workers() != 0,
104 "Not initialized?");
105
106 _shadow_region_array = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<size_t >(10, true);
107 _shadow_region_monitor = new Monitor(Mutex::barrier, "CompactionManager monitor",
108 Mutex::_allow_vm_block_flag, Monitor::_safepoint_check_never);
109 }
110
111 void ParCompactionManager::reset_all_bitmap_query_caches() {
112 uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().total_workers();
113 for (uint i=0; i<=parallel_gc_threads; i++) {
114 _manager_array[i]->reset_bitmap_query_cache();
115 }
116 }
117
118 bool ParCompactionManager::should_update() {
119 assert(action() != NotValid, "Action is not set");
120 return (action() == ParCompactionManager::Update) ||
121 (action() == ParCompactionManager::CopyAndUpdate) ||
122 (action() == ParCompactionManager::UpdateAndCopy);
123 }
124
125 bool ParCompactionManager::should_copy() {
126 assert(action() != NotValid, "Action is not set");
127 return (action() == ParCompactionManager::Copy) ||
128 (action() == ParCompactionManager::CopyAndUpdate) ||
175 while (true) {
176 MutexLocker ml(_shadow_region_monitor, Mutex::_no_safepoint_check_flag);
177 if (_shadow_region_array->is_empty()) {
178 // The corresponding heap region may be available now,
179 // so we don't need to acquire a shadow region anymore,
180 // and we return 0 to indicate this case
181 if (region_ptr->claimed()) {
182 return 0;
183 }
184 } else {
185 return _shadow_region_array->pop();
186 }
187 }
188 }
189
190 void ParCompactionManager::release_shadow_region(size_t shadow_region) {
191 MutexLocker ml(_shadow_region_monitor, Mutex::_no_safepoint_check_flag);
192 _shadow_region_array->append(shadow_region);
193 }
194
195 void ParCompactionManager::add_shadow_region(size_t shadow_region) {
196 _shadow_region_array->append(shadow_region);
197 }
198
199 void ParCompactionManager::remove_all_shadow_regions() {
200 _shadow_region_array->clear();
201 }
|