src/share/vm/gc/g1/dirtyCardQueue.hpp

rev 13241 : imported patch 8183128-erikd-review

*** 66,78 ****
  };
  
  
  
  class DirtyCardQueueSet: public PtrQueueSet {
-   // The closure used in mut_process_buffer().
-   CardTableEntryClosure* _mut_process_closure;
- 
    DirtyCardQueue _shared_dirty_card_queue;
  
    // Apply the closure to the elements of "node" from it's index to
    // buffer_size.  If all closure applications return true, then
    // returns true.  Stops processing after the first closure
--- 66,75 ----
*** 83,92 ****
--- 80,106 ----
    bool apply_closure_to_buffer(CardTableEntryClosure* cl,
                                 BufferNode* node,
                                 bool consume,
                                 uint worker_i = 0);
  
+   // If there are more than stop_at completed buffers, pop one, apply
+   // the specified closure to its active elements, and return true.
+   // Otherwise return false.
+   //
+   // A completely processed buffer is freed.  However, if a closure
+   // invocation returns false, processing is stopped and the partially
+   // processed buffer (with its index updated to exclude the processed
+   // elements, e.g. up to the element for which the closure returned
+   // false) is returned to the completed buffer set.
+   //
+   // If during_pause is true, stop_at must be zero, and the closure
+   // must never return false.
+   bool apply_closure_to_completed_buffer(CardTableEntryClosure* cl,
+                                          uint worker_i,
+                                          size_t stop_at,
+                                          bool during_pause);
+ 
    bool mut_process_buffer(BufferNode* node);
  
    // Protected by the _cbl_mon.
    FreeIdSet* _free_ids;
  
*** 101,112 ****
    void concatenate_log(DirtyCardQueue& dcq);
  
  public:
    DirtyCardQueueSet(bool notify_when_complete = true);
  
!   void initialize(CardTableEntryClosure* cl,
!                   Monitor* cbl_mon,
                    Mutex* fl_lock,
                    int process_completed_threshold,
                    int max_completed_queue,
                    Mutex* lock,
                    DirtyCardQueueSet* fl_owner,
--- 115,125 ----
    void concatenate_log(DirtyCardQueue& dcq);
  
  public:
    DirtyCardQueueSet(bool notify_when_complete = true);
  
!   void initialize(Monitor* cbl_mon,
                    Mutex* fl_lock,
                    int process_completed_threshold,
                    int max_completed_queue,
                    Mutex* lock,
                    DirtyCardQueueSet* fl_owner,
*** 116,141 ****
    // mutator threads to do card-processing work.
    static uint num_par_ids();
  
    static void handle_zero_index_for_thread(JavaThread* t);
  
!   // If there are more than stop_at completed buffers, pop one, apply
!   // the specified closure to its active elements, and return true.
!   // Otherwise return false.
!   //
!   // A completely processed buffer is freed.  However, if a closure
!   // invocation returns false, processing is stopped and the partially
!   // processed buffer (with its index updated to exclude the processed
!   // elements, e.g. up to the element for which the closure returned
!   // false) is returned to the completed buffer set.
!   //
!   // If during_pause is true, stop_at must be zero, and the closure
!   // must never return false.
!   bool apply_closure_to_completed_buffer(CardTableEntryClosure* cl,
!                                          uint worker_i,
!                                          size_t stop_at,
!                                          bool during_pause);
  
    BufferNode* get_completed_buffer(size_t stop_at);
  
    void reset_for_par_iteration() { _cur_par_buffer_node = _completed_buffers_head; }
    // Applies the current closure to all completed buffers, non-consumptively.
--- 129,145 ----
    // mutator threads to do card-processing work.
    static uint num_par_ids();
  
    static void handle_zero_index_for_thread(JavaThread* t);
  
!   // Apply G1RefineCardConcurrentlyClosure to completed buffers until there are stop_at
!   // completed buffers remaining.
!   bool refine_completed_buffer_concurrently(uint worker_i, size_t stop_at);
! 
!   // Apply the given closure to all completed buffers. The given closure's do_card_ptr
!   // must never return false. Must only be called during GC.
!   bool apply_closure_during_gc(CardTableEntryClosure* cl, uint worker_i);
  
    BufferNode* get_completed_buffer(size_t stop_at);
  
    void reset_for_par_iteration() { _cur_par_buffer_node = _completed_buffers_head; }
    // Applies the current closure to all completed buffers, non-consumptively.