src/hotspot/share/gc/g1/dirtyCardQueue.cpp
changeset 49752 93d84f667d12
parent 49333 489f1dd40582
child 52576 367ca5f32505
equal deleted inserted replaced
49751:c3a10df652c0 49752:93d84f667d12
    24 
    24 
    25 #include "precompiled.hpp"
    25 #include "precompiled.hpp"
    26 #include "gc/g1/dirtyCardQueue.hpp"
    26 #include "gc/g1/dirtyCardQueue.hpp"
    27 #include "gc/g1/g1CollectedHeap.inline.hpp"
    27 #include "gc/g1/g1CollectedHeap.inline.hpp"
    28 #include "gc/g1/g1RemSet.hpp"
    28 #include "gc/g1/g1RemSet.hpp"
       
    29 #include "gc/g1/g1ThreadLocalData.hpp"
    29 #include "gc/g1/heapRegionRemSet.hpp"
    30 #include "gc/g1/heapRegionRemSet.hpp"
    30 #include "gc/shared/workgroup.hpp"
    31 #include "gc/shared/workgroup.hpp"
    31 #include "runtime/atomic.hpp"
    32 #include "runtime/atomic.hpp"
    32 #include "runtime/mutexLocker.hpp"
    33 #include "runtime/mutexLocker.hpp"
    33 #include "runtime/safepoint.hpp"
    34 #include "runtime/safepoint.hpp"
   162     _free_ids = new FreeIdSet(num_par_ids(), _cbl_mon);
   163     _free_ids = new FreeIdSet(num_par_ids(), _cbl_mon);
   163   }
   164   }
   164 }
   165 }
   165 
   166 
   166 void DirtyCardQueueSet::handle_zero_index_for_thread(JavaThread* t) {
   167 void DirtyCardQueueSet::handle_zero_index_for_thread(JavaThread* t) {
   167   t->dirty_card_queue().handle_zero_index();
   168   G1ThreadLocalData::dirty_card_queue(t).handle_zero_index();
   168 }
   169 }
   169 
   170 
   170 bool DirtyCardQueueSet::apply_closure_to_buffer(CardTableEntryClosure* cl,
   171 bool DirtyCardQueueSet::apply_closure_to_buffer(CardTableEntryClosure* cl,
   171                                                 BufferNode* node,
   172                                                 BufferNode* node,
   172                                                 bool consume,
   173                                                 bool consume,
   319   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
   320   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
   320   clear();
   321   clear();
   321   // Since abandon is done only at safepoints, we can safely manipulate
   322   // Since abandon is done only at safepoints, we can safely manipulate
   322   // these queues.
   323   // these queues.
   323   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
   324   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
   324     t->dirty_card_queue().reset();
   325     G1ThreadLocalData::dirty_card_queue(t).reset();
   325   }
   326   }
   326   shared_dirty_card_queue()->reset();
   327   shared_dirty_card_queue()->reset();
   327 }
   328 }
   328 
   329 
   329 void DirtyCardQueueSet::concatenate_log(DirtyCardQueue& dcq) {
   330 void DirtyCardQueueSet::concatenate_log(DirtyCardQueue& dcq) {
   338   // of outstanding buffers.
   339   // of outstanding buffers.
   339   int save_max_completed_queue = _max_completed_queue;
   340   int save_max_completed_queue = _max_completed_queue;
   340   _max_completed_queue = max_jint;
   341   _max_completed_queue = max_jint;
   341   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
   342   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
   342   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
   343   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
   343     concatenate_log(t->dirty_card_queue());
   344     concatenate_log(G1ThreadLocalData::dirty_card_queue(t));
   344   }
   345   }
   345   concatenate_log(_shared_dirty_card_queue);
   346   concatenate_log(_shared_dirty_card_queue);
   346   // Restore the completed buffer queue limit.
   347   // Restore the completed buffer queue limit.
   347   _max_completed_queue = save_max_completed_queue;
   348   _max_completed_queue = save_max_completed_queue;
   348 }
   349 }