66 
 67   return true;
 68 }
 69 
 70 template <class T> inline void G1FullGCMarker::mark_and_push(T* p) {
 71   T heap_oop = RawAccess<>::oop_load(p);
 72   if (!CompressedOops::is_null(heap_oop)) {
 73     oop obj = CompressedOops::decode_not_null(heap_oop);
 74     if (mark_object(obj)) {
 75       _task_queue.push(ScannerTask(obj));
 76     }
 77     assert(_bitmap->is_marked(obj), "Must be marked");
 78   }
 79 }
 80 
 81 inline bool G1FullGCMarker::is_task_queue_empty() {
 82   return _task_queue.is_empty();
 83 }
 84 
 85 inline void G1FullGCMarker::process_array_chunk(objArrayOop obj, size_t start, size_t end) {

 86   obj->oop_iterate_elements_range(mark_closure(),
 87                                   checked_cast<int>(start),
 88                                   checked_cast<int>(end));
 89 }
 90 
 91 inline void G1FullGCMarker::dispatch_task(const ScannerTask& task, bool stolen) {
 92   if (task.is_partial_array_state()) {
 93     assert(_bitmap->is_marked(task.to_partial_array_state()->source()), "should be marked");
 94     process_partial_array(task.to_partial_array_state(), stolen);
 95   } else {
 96     oop obj = task.to_oop();
 97     assert(_bitmap->is_marked(obj), "should be marked");
 98     if (obj->is_objArray()) {
 99       // Handle object arrays explicitly to allow them to
100       // be split into chunks if needed.
101       start_partial_array_processing((objArrayOop)obj);
102     } else {
103       obj->oop_iterate(mark_closure());
104     }
105   }
106 }
107 
108 inline void G1FullGCMarker::publish_and_drain_oop_tasks() {
109   ScannerTask task;
110   while (_task_queue.pop_overflow(task)) {
111     if (!_task_queue.try_push_to_taskqueue(task)) {
112       dispatch_task(task, false);
113     }
114   }
115   while (_task_queue.pop_local(task)) {
116     dispatch_task(task, false);
117   }
118 }

 66 
 67   return true;
 68 }
 69 
 70 template <class T> inline void G1FullGCMarker::mark_and_push(T* p) {
 71   T heap_oop = RawAccess<>::oop_load(p);
 72   if (!CompressedOops::is_null(heap_oop)) {
 73     oop obj = CompressedOops::decode_not_null(heap_oop);
 74     if (mark_object(obj)) {
 75       _task_queue.push(ScannerTask(obj));
 76     }
 77     assert(_bitmap->is_marked(obj), "Must be marked");
 78   }
 79 }
 80 
 81 inline bool G1FullGCMarker::is_task_queue_empty() {
 82   return _task_queue.is_empty();
 83 }
 84 
 85 inline void G1FullGCMarker::process_array_chunk(objArrayOop obj, size_t start, size_t end) {
 86   precond(obj->is_array_with_oops());
 87   obj->oop_iterate_elements_range(mark_closure(),
 88                                   checked_cast<int>(start),
 89                                   checked_cast<int>(end));
 90 }
 91 
 92 inline void G1FullGCMarker::dispatch_task(const ScannerTask& task, bool stolen) {
 93   if (task.is_partial_array_state()) {
 94     assert(_bitmap->is_marked(task.to_partial_array_state()->source()), "should be marked");
 95     process_partial_array(task.to_partial_array_state(), stolen);
 96   } else {
 97     oop obj = task.to_oop();
 98     assert(_bitmap->is_marked(obj), "should be marked");
 99     if (obj->is_array_with_oops()) {
100       // Handle object arrays explicitly to allow them to
101       // be split into chunks if needed.
102       start_partial_array_processing((objArrayOop)obj);
103     } else {
104       obj->oop_iterate(mark_closure());
105     }
106   }
107 }
108 
109 inline void G1FullGCMarker::publish_and_drain_oop_tasks() {
110   ScannerTask task;
111   while (_task_queue.pop_overflow(task)) {
112     if (!_task_queue.try_push_to_taskqueue(task)) {
113       dispatch_task(task, false);
114     }
115   }
116   while (_task_queue.pop_local(task)) {
117     dispatch_task(task, false);
118   }
119 }