< prev index next >

src/hotspot/share/gc/g1/g1DirtyCardQueue.hpp

Print this page
rev 53581 : [mq]: move_files
rev 53582 : imported patch rename

@@ -20,68 +20,68 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 
-#ifndef SHARE_GC_G1_DIRTYCARDQUEUE_HPP
-#define SHARE_GC_G1_DIRTYCARDQUEUE_HPP
+#ifndef SHARE_GC_G1_G1DIRTYCARDQUEUE_HPP
+#define SHARE_GC_G1_G1DIRTYCARDQUEUE_HPP
 
 #include "gc/shared/ptrQueue.hpp"
 #include "memory/allocation.hpp"
 
-class DirtyCardQueueSet;
+class G1DirtyCardQueueSet;
 class G1FreeIdSet;
 class JavaThread;
 class Monitor;
 
 // A closure class for processing card table entries.  Note that we don't
 // require these closure objects to be stack-allocated.
-class CardTableEntryClosure: public CHeapObj<mtGC> {
+class G1CardTableEntryClosure: public CHeapObj<mtGC> {
 public:
   // Process the card whose card table entry is "card_ptr".  If returns
   // "false", terminate the iteration early.
   virtual bool do_card_ptr(jbyte* card_ptr, uint worker_i) = 0;
 };
 
 // A ptrQueue whose elements are "oops", pointers to object heads.
-class DirtyCardQueue: public PtrQueue {
+class G1DirtyCardQueue: public PtrQueue {
 public:
-  DirtyCardQueue(DirtyCardQueueSet* qset, bool permanent = false);
+  G1DirtyCardQueue(G1DirtyCardQueueSet* qset, bool permanent = false);
 
   // Flush before destroying; queue may be used to capture pending work while
   // doing something else, with auto-flush on completion.
-  ~DirtyCardQueue();
+  ~G1DirtyCardQueue();
 
   // Process queue entries and release resources.
   void flush() { flush_impl(); }
 
   // Compiler support.
   static ByteSize byte_offset_of_index() {
-    return PtrQueue::byte_offset_of_index<DirtyCardQueue>();
+    return PtrQueue::byte_offset_of_index<G1DirtyCardQueue>();
   }
   using PtrQueue::byte_width_of_index;
 
   static ByteSize byte_offset_of_buf() {
-    return PtrQueue::byte_offset_of_buf<DirtyCardQueue>();
+    return PtrQueue::byte_offset_of_buf<G1DirtyCardQueue>();
   }
   using PtrQueue::byte_width_of_buf;
 
 };
 
 
 
-class DirtyCardQueueSet: public PtrQueueSet {
-  DirtyCardQueue _shared_dirty_card_queue;
+class G1DirtyCardQueueSet: public PtrQueueSet {
+  G1DirtyCardQueue _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
   // application that returns false, and returns false from this
   // function.  If "consume" is true, the node's index is updated to
   // exclude the processed elements, e.g. up to the element for which
   // the closure returned false.
-  bool apply_closure_to_buffer(CardTableEntryClosure* cl,
+  bool apply_closure_to_buffer(G1CardTableEntryClosure* cl,
                                BufferNode* node,
                                bool consume,
                                uint worker_i = 0);
 
   // If there are more than stop_at completed buffers, pop one, apply

@@ -94,11 +94,11 @@
   // 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,
+  bool apply_closure_to_completed_buffer(G1CardTableEntryClosure* cl,
                                          uint worker_i,
                                          size_t stop_at,
                                          bool during_pause);
 
   bool mut_process_buffer(BufferNode* node);

@@ -111,15 +111,15 @@
   jint _processed_buffers_rs_thread;
 
   // Current buffer node used for parallel iteration.
   BufferNode* volatile _cur_par_buffer_node;
 
-  void concatenate_log(DirtyCardQueue& dcq);
+  void concatenate_log(G1DirtyCardQueue& dcq);
 
 public:
-  DirtyCardQueueSet(bool notify_when_complete = true);
-  ~DirtyCardQueueSet();
+  G1DirtyCardQueueSet(bool notify_when_complete = true);
+  ~G1DirtyCardQueueSet();
 
   void initialize(Monitor* cbl_mon,
                   BufferNode::Allocator* allocator,
                   Mutex* lock,
                   bool init_free_ids = false);

@@ -134,19 +134,19 @@
   // 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);
+  bool apply_closure_during_gc(G1CardTableEntryClosure* cl, uint worker_i);
 
   void reset_for_par_iteration() { _cur_par_buffer_node = completed_buffers_head(); }
   // Applies the current closure to all completed buffers, non-consumptively.
   // Can be used in parallel, all callers using the iteration state initialized
   // by reset_for_par_iteration.
-  void par_apply_closure_to_all_completed_buffers(CardTableEntryClosure* cl);
+  void par_apply_closure_to_all_completed_buffers(G1CardTableEntryClosure* cl);
 
-  DirtyCardQueue* shared_dirty_card_queue() {
+  G1DirtyCardQueue* shared_dirty_card_queue() {
     return &_shared_dirty_card_queue;
   }
 
   // If a full collection is happening, reset partial logs, and ignore
   // completed ones: the full collection will make them all irrelevant.

@@ -162,6 +162,6 @@
     return _processed_buffers_rs_thread;
   }
 
 };
 
-#endif // SHARE_GC_G1_DIRTYCARDQUEUE_HPP
+#endif // SHARE_GC_G1_G1DIRTYCARDQUEUE_HPP
< prev index next >