src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

@@ -69,10 +69,11 @@
  #include "memory/resourceArea.hpp"
  #include "memory/universe.hpp"
  #include "nmt/memTracker.hpp"
  #include "oops/access.inline.hpp"
  #include "oops/oop.inline.hpp"
+ #include "oops/oopCast.inline.hpp"
  #include "runtime/globals_extension.hpp"
  #include "runtime/handles.inline.hpp"
  #include "runtime/java.hpp"
  #include "runtime/orderAccess.hpp"
  #include "runtime/os.hpp"

@@ -2313,36 +2314,54 @@
  }
  
  size_t G1CMTask::start_partial_array_processing(oop obj) {
    assert(should_be_sliced(obj), "Must be an array object %d and large %zu", obj->is_objArray(), obj->size());
  
-   objArrayOop obj_array = objArrayOop(obj);
+   objArrayOop obj_array = oop_cast<objArrayOop>(obj);
    size_t array_length = obj_array->length();
  
    size_t initial_chunk_size = _partial_array_splitter.start(_task_queue, obj_array, nullptr, array_length);
  
    // Mark objArray klass metadata
    if (_cm_oop_closure->do_metadata()) {
      _cm_oop_closure->do_klass(obj_array->klass());
+ 
+     if (obj_array->is_flatArray()) {
+       FlatArrayKlass* faklass = FlatArrayKlass::cast(obj_array->klass());
+       _cm_oop_closure->do_klass(faklass->element_klass());
+     }
    }
  
    process_array_chunk(obj_array, 0, initial_chunk_size);
  
    // Include object header size
-   return objArrayOopDesc::object_size(checked_cast<int>(initial_chunk_size));
+   if (obj_array->is_refArray()) {
+     return refArrayOopDesc::object_size(checked_cast<int>(initial_chunk_size));
+   } else {
+     FlatArrayKlass* faKlass = FlatArrayKlass::cast(obj_array->klass());
+     return flatArrayOopDesc::object_size(faKlass->layout_helper(), checked_cast<int>(initial_chunk_size));
+   }
  }
  
  size_t G1CMTask::process_partial_array(const G1TaskQueueEntry& task, bool stolen) {
    PartialArrayState* state = task.to_partial_array_state();
    // Access state before release by claim().
-   objArrayOop obj = objArrayOop(state->source());
+   objArrayOop obj = oop_cast<objArrayOop>(state->source());
  
    PartialArraySplitter::Claim claim =
      _partial_array_splitter.claim(state, _task_queue, stolen);
  
    process_array_chunk(obj, claim._start, claim._end);
-   return heap_word_size((claim._end - claim._start) * heapOopSize);
+ 
+   if (obj->is_refArray()) {
+     return heap_word_size((claim._end - claim._start) * heapOopSize);
+   } else {
+     assert(obj->is_flatArray(), "Must be!");
+     size_t element_byte_size = FlatArrayKlass::cast(obj->klass())->element_byte_size();
+     size_t nof_elements = claim._end - claim._start;
+     return heap_word_size(nof_elements * element_byte_size);
+   }
  }
  
  void G1CMTask::drain_global_stack(bool partially) {
    if (has_aborted()) {
      return;