8282072: G1: Rename CardSetPtr to CardSetContainerPtr

Reviewed-by: ayang, tschatzl

Author: Ivan Walulya

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

@@ -26,10 +26,7 @@
 #define SHARE_GC_G1_G1CARDSET_HPP
 
 #include "memory/allocation.hpp"
-#include "memory/padded.hpp"
-#include "oops/oopsHierarchy.hpp"
 #include "utilities/concurrentHashTable.hpp"
-#include "utilities/lockFreeStack.hpp"
 
 class G1CardSetAllocOptions;
 class G1CardSetHashTable;
@@ -147,10 +144,10 @@ class G1CardSetConfiguration {
 class G1CardSetCoarsenStats {
 public:
   // Number of entries in the statistics tables: since we index with the source
-  // cardset of the coarsening, this is the total number of combinations of
-  // card sets - 1.
+  // container of the coarsening, this is the total number of combinations of
+  // card set containers - 1.
   static constexpr size_t NumCoarsenCategories = 7;
-  // Coarsening statistics for the possible CardSetPtr in the Howl card set
+  // Coarsening statistics for the possible ContainerPtr in the Howl card set
   // start from this offset.
   static constexpr size_t CoarsenHowlOffset = 4;
 
@@ -173,14 +170,14 @@ class G1CardSetCoarsenStats {
   void print_on(outputStream* out);
 };
 
-// Sparse set of card indexes comprising a remembered set on the Java heap. Card
+// Set of card indexes comprising a remembered set on the Java heap. Card
 // size is assumed to be card table card size.
 //
 // Technically it is implemented using a ConcurrentHashTable that stores a card
 // set container for every region containing at least one card.
 //
 // There are in total five different containers, encoded in the ConcurrentHashTable
-// node as CardSetPtr. A CardSetPtr may cover the whole region or just a part of
+// node as ContainerPtr. A ContainerPtr may cover the whole region or just a part of
 // it.
 // See its description below for more information.
 class G1CardSet : public CHeapObj<mtGCCardSet> {
@@ -194,46 +191,46 @@ class G1CardSet : public CHeapObj<mtGCCardSet> {
   static G1CardSetCoarsenStats _coarsen_stats; // Coarsening statistics since VM start.
   static G1CardSetCoarsenStats _last_coarsen_stats; // Coarsening statistics at last GC.
 public:
-  // Two lower bits are used to encode the card storage types
-  static const uintptr_t CardSetPtrHeaderSize = 2;
+  // Two lower bits are used to encode the card set container types
+  static const uintptr_t ContainerPtrHeaderSize = 2;
 
-  // CardSetPtr represents the card storage type of a given covered area. It encodes
-  // a type in the LSBs, in addition to having a few significant values.
+  // ContainerPtr represents the card set container  type of a given covered area.
+  // It encodes a type in the LSBs, in addition to having a few significant values.
   //
   // Possible encodings:
   //
   // 0...00000 free               (Empty, should never happen)
-  // 1...11111 full               All card indexes in the whole area this CardSetPtr covers are part of this container.
-  // X...XXX00 inline-ptr-cards   A handful of card indexes covered by this CardSetPtr are encoded within the CardSetPtr.
+  // 1...11111 full               All card indexes in the whole area this ContainerPtr covers are part of this container.
+  // X...XXX00 inline-ptr-cards   A handful of card indexes covered by this ContainerPtr are encoded within the ContainerPtr.
   // X...XXX01 array of cards     The container is a contiguous array of card indexes.
   // X...XXX10 bitmap             The container uses a bitmap to determine whether a given index is part of this set.
-  // X...XXX11 howl               This is a card set container containing an array of CardSetPtr, with each CardSetPtr
+  // X...XXX11 howl               This is a card set container containing an array of ContainerPtr, with each ContainerPtr
   //                              limited to a sub-range of the original range. Currently only one level of this
   //                              container is supported.
-  typedef void* CardSetPtr;
+  using ContainerPtr = void*;
   // Coarsening happens in the order below:
-  // CardSetInlinePtr -> CardSetArrayOfCards -> CardSetHowl -> Full
-  // Corsening of containers inside the CardSetHowl happens in the order:
-  // CardSetInlinePtr -> CardSetArrayOfCards -> CardSetBitMap -> Full
-  static const uintptr_t CardSetInlinePtr      = 0x0;
-  static const uintptr_t CardSetArrayOfCards   = 0x1;
-  static const uintptr_t CardSetBitMap         = 0x2;
-  static const uintptr_t CardSetHowl           = 0x3;
+  // ContainerInlinePtr -> ContainerArrayOfCards -> ContainerHowl -> Full
+  // Corsening of containers inside the ContainerHowl happens in the order:
+  // ContainerInlinePtr -> ContainerArrayOfCards -> ContainerBitMap -> Full
+  static const uintptr_t ContainerInlinePtr      = 0x0;
+  static const uintptr_t ContainerArrayOfCards   = 0x1;
+  static const uintptr_t ContainerBitMap         = 0x2;
+  static const uintptr_t ContainerHowl           = 0x3;
 
   // The special sentinel values
-  static constexpr CardSetPtr FreeCardSet = nullptr;
-  // Unfortunately we can't make (G1CardSet::CardSetPtr)-1 constexpr because
+  static constexpr ContainerPtr FreeCardSet = nullptr;
+  // Unfortunately we can't make (G1CardSet::ContainerPtr)-1 constexpr because
   // reinterpret_casts are forbidden in constexprs. Use a regular static instead.
-  static CardSetPtr FullCardSet;
+  static ContainerPtr FullCardSet;
 
-  static const uintptr_t CardSetPtrTypeMask    = ((uintptr_t)1 << CardSetPtrHeaderSize) - 1;
+  static const uintptr_t ContainerPtrTypeMask = ((uintptr_t)1 << ContainerPtrHeaderSize) - 1;
 
-  static CardSetPtr strip_card_set_type(CardSetPtr ptr) { return (CardSetPtr)((uintptr_t)ptr & ~CardSetPtrTypeMask); }
+  static ContainerPtr strip_container_type(ContainerPtr ptr) { return (ContainerPtr)((uintptr_t)ptr & ~ContainerPtrTypeMask); }
 
-  static uint card_set_type(CardSetPtr ptr) { return (uintptr_t)ptr & CardSetPtrTypeMask; }
+  static uint container_type(ContainerPtr ptr) { return (uintptr_t)ptr & ContainerPtrTypeMask; }
 
   template <class T>
-  static T* card_set_ptr(CardSetPtr ptr);
+  static T* container_ptr(ContainerPtr ptr);
 
 private:
   G1CardSetMemoryManager* _mm;
@@ -245,42 +242,42 @@ class G1CardSet : public CHeapObj<mtGCCardSet> {
   // be (slightly) more cards in the card set than this value in reality.
   size_t _num_occupied;
 
-  CardSetPtr make_card_set_ptr(void* value, uintptr_t type);
+  ContainerPtr make_container_ptr(void* value, uintptr_t type);
 
-  CardSetPtr acquire_card_set(CardSetPtr volatile* card_set_addr);
-  // Returns true if the card set should be released
-  bool release_card_set(CardSetPtr card_set);
+  ContainerPtr acquire_container(ContainerPtr volatile* container_addr);
+  // Returns true if the card set container should be released
+  bool release_container(ContainerPtr container);
   // Release card set and free if needed.
-  void release_and_maybe_free_card_set(CardSetPtr card_set);
+  void release_and_maybe_free_container(ContainerPtr container);
   // Release card set and free (and it must be freeable).
-  void release_and_must_free_card_set(CardSetPtr card_set);
+  void release_and_must_free_container(ContainerPtr container);
 
-  // Coarsens the CardSet cur_card_set to the next level; tries to replace the
-  // previous CardSet with a new one which includes the given card_in_region.
-  // coarsen_card_set does not transfer cards from cur_card_set
-  // to the new card_set. Transfer is achieved by transfer_cards.
-  // Returns true if this was the thread that coarsened the CardSet (and added the card).
-  bool coarsen_card_set(CardSetPtr volatile* card_set_addr,
-                        CardSetPtr cur_card_set,
-                        uint card_in_region, bool within_howl = false);
+  // Coarsens the card set container cur_container to the next level; tries to replace the
+  // previous ContainerPtr with a new one which includes the given card_in_region.
+  // coarsen_container does not transfer cards from cur_container
+  // to the new container. Transfer is achieved by transfer_cards.
+  // Returns true if this was the thread that coarsened the container (and added the card).
+  bool coarsen_container(ContainerPtr volatile* container_addr,
+                         ContainerPtr cur_container,
+                         uint card_in_region, bool within_howl = false);
 
-  CardSetPtr create_coarsened_array_of_cards(uint card_in_region, bool within_howl);
+  ContainerPtr create_coarsened_array_of_cards(uint card_in_region, bool within_howl);
 
   // Transfer entries from source_card_set to a recently installed coarser storage type
-  // We only need to transfer anything finer than CardSetBitMap. "Full" contains
+  // We only need to transfer anything finer than ContainerBitMap. "Full" contains
   // all elements anyway.
-  void transfer_cards(G1CardSetHashTableValue* table_entry, CardSetPtr source_card_set, uint card_region);
-  void transfer_cards_in_howl(CardSetPtr parent_card_set, CardSetPtr source_card_set, uint card_region);
+  void transfer_cards(G1CardSetHashTableValue* table_entry, ContainerPtr source_container, uint card_region);
+  void transfer_cards_in_howl(ContainerPtr parent_container, ContainerPtr source_container, uint card_region);
 
-  G1AddCardResult add_to_card_set(CardSetPtr volatile* card_set_addr, CardSetPtr card_set, uint card_region, uint card, bool increment_total = true);
+  G1AddCardResult add_to_container(ContainerPtr volatile* container_addr, ContainerPtr container, uint card_region, uint card, bool increment_total = true);
 
-  G1AddCardResult add_to_inline_ptr(CardSetPtr volatile* card_set_addr, CardSetPtr card_set, uint card_in_region);
-  G1AddCardResult add_to_array(CardSetPtr card_set, uint card_in_region);
-  G1AddCardResult add_to_bitmap(CardSetPtr card_set, uint card_in_region);
-  G1AddCardResult add_to_howl(CardSetPtr parent_card_set, uint card_region, uint card_in_region, bool increment_total = true);
+  G1AddCardResult add_to_inline_ptr(ContainerPtr volatile* container_addr, ContainerPtr container, uint card_in_region);
+  G1AddCardResult add_to_array(ContainerPtr container, uint card_in_region);
+  G1AddCardResult add_to_bitmap(ContainerPtr container, uint card_in_region);
+  G1AddCardResult add_to_howl(ContainerPtr parent_container, uint card_region, uint card_in_region, bool increment_total = true);
 
-  G1CardSetHashTableValue* get_or_add_card_set(uint card_region, bool* should_grow_table);
-  G1CardSetHashTableValue* get_card_set(uint card_region);
+  G1CardSetHashTableValue* get_or_add_container(uint card_region, bool* should_grow_table);
+  G1CardSetHashTableValue* get_container(uint card_region);
 
   // Iterate over cards of a card set container during transfer of the cards from
   // one container to another. Executes
@@ -289,11 +286,11 @@ class G1CardSet : public CHeapObj<mtGCCardSet> {
   //
   // on the given class.
   template <class CardVisitor>
-  void iterate_cards_during_transfer(CardSetPtr const card_set, CardVisitor& vl);
+  void iterate_cards_during_transfer(ContainerPtr const container, CardVisitor& vl);
 
-  uint card_set_type_to_mem_object_type(uintptr_t type) const;
+  uint container_type_to_mem_object_type(uintptr_t type) const;
   uint8_t* allocate_mem_object(uintptr_t type);
-  void free_mem_object(CardSetPtr card_set);
+  void free_mem_object(ContainerPtr container);
 
 public:
   G1CardSetConfiguration* config() const { return _config; }
@@ -302,8 +299,8 @@ class G1CardSet : public CHeapObj<mtGCCardSet> {
   G1CardSet(G1CardSetConfiguration* config, G1CardSetMemoryManager* mm);
   virtual ~G1CardSet();
 
-  // Adds the given card to this set, returning an appropriate result. If added,
-  // updates the total count.
+  // Adds the given card to this set, returning an appropriate result.
+  // If incremental_count is true and the card has been added, updates the total count.
   G1AddCardResult add_card(uint card_region, uint card_in_region, bool increment_total = true);
 
   bool contains_card(uint card_region, uint card_in_region);
@@ -351,14 +348,14 @@ class G1CardSet : public CHeapObj<mtGCCardSet> {
   // start_iterate().
   //
   template <class CardOrRangeVisitor>
-  void iterate_cards_or_ranges_in_container(CardSetPtr const card_set, CardOrRangeVisitor& cl);
+  void iterate_cards_or_ranges_in_container(ContainerPtr const container, CardOrRangeVisitor& cl);
 
-  class CardSetPtrClosure {
+  class ContainerPtrClosure {
   public:
-    virtual void do_cardsetptr(uint region_idx, size_t num_occupied, CardSetPtr card_set) = 0;
+    virtual void do_containerptr(uint region_idx, size_t num_occupied, ContainerPtr container) = 0;
   };
 
-  void iterate_containers(CardSetPtrClosure* cl, bool safepoint = false);
+  void iterate_containers(ContainerPtrClosure* cl, bool safepoint = false);
 
   class CardClosure {
   public:
@@ -370,13 +367,13 @@ class G1CardSet : public CHeapObj<mtGCCardSet> {
 
 class G1CardSetHashTableValue {
 public:
-  using CardSetPtr = G1CardSet::CardSetPtr;
+  using ContainerPtr = G1CardSet::ContainerPtr;
 
   const uint _region_idx;
   uint volatile _num_occupied;
-  CardSetPtr volatile _card_set;
+  ContainerPtr volatile _container;
 
-  G1CardSetHashTableValue(uint region_idx, CardSetPtr card_set) : _region_idx(region_idx), _num_occupied(0), _card_set(card_set) { }
+  G1CardSetHashTableValue(uint region_idx, ContainerPtr container) : _region_idx(region_idx), _num_occupied(0), _container(container) { }
 };
 
 class G1CardSetHashTableConfig : public StackObj {
@@ -391,6 +388,6 @@ class G1CardSetHashTableConfig : public StackObj {
   static void free_node(void* context, void* memory, Value const& value);
 };
 
-typedef ConcurrentHashTable<G1CardSetHashTableConfig, mtGCCardSet> CardSetHash;
+using CardSetHash = ConcurrentHashTable<G1CardSetHashTableConfig, mtGCCardSet>;
 
 #endif // SHARE_GC_G1_G1CARDSET_HPP

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

@@ -28,55 +28,54 @@
 #include "gc/g1/g1CardSet.hpp"
 #include "gc/g1/g1CardSetContainers.inline.hpp"
 #include "gc/g1/g1GCPhaseTimes.hpp"
-#include "runtime/atomic.hpp"
 #include "logging/log.hpp"
 
 template <class T>
-inline T* G1CardSet::card_set_ptr(CardSetPtr ptr) {
-  return (T*)strip_card_set_type(ptr);
+inline T* G1CardSet::container_ptr(ContainerPtr ptr) {
+  return (T*)strip_container_type(ptr);
 }
 
-inline G1CardSet::CardSetPtr G1CardSet::make_card_set_ptr(void* value, uintptr_t type) {
-  assert(card_set_type(value) == 0, "Given ptr " PTR_FORMAT " already has type bits set", p2i(value));
-  return (CardSetPtr)((uintptr_t)value | type);
+inline G1CardSet::ContainerPtr G1CardSet::make_container_ptr(void* value, uintptr_t type) {
+  assert(container_type(value) == 0, "Given ptr " PTR_FORMAT " already has type bits set", p2i(value));
+  return (ContainerPtr)((uintptr_t)value | type);
 }
 
 template <class CardOrRangeVisitor>
-inline void G1CardSet::iterate_cards_or_ranges_in_container(CardSetPtr const card_set, CardOrRangeVisitor& cl) {
-  switch (card_set_type(card_set)) {
-    case CardSetInlinePtr: {
+inline void G1CardSet::iterate_cards_or_ranges_in_container(ContainerPtr const container, CardOrRangeVisitor& cl) {
+  switch (container_type(container)) {
+    case ContainerInlinePtr: {
       if (cl.start_iterate(G1GCPhaseTimes::MergeRSMergedInline)) {
-        G1CardSetInlinePtr ptr(card_set);
+        G1CardSetInlinePtr ptr(container);
         ptr.iterate(cl, _config->inline_ptr_bits_per_card());
       }
       return;
     }
-    case CardSetArrayOfCards : {
+    case ContainerArrayOfCards: {
       if (cl.start_iterate(G1GCPhaseTimes::MergeRSMergedArrayOfCards)) {
-        card_set_ptr<G1CardSetArray>(card_set)->iterate(cl);
+        container_ptr<G1CardSetArray>(container)->iterate(cl);
       }
       return;
     }
-    case CardSetBitMap: {
+    case ContainerBitMap: {
       // There is no first-level bitmap spanning the whole area.
       ShouldNotReachHere();
       return;
     }
-    case CardSetHowl: {
-      assert(card_set_type(FullCardSet) == CardSetHowl, "Must be");
-      if (card_set == FullCardSet) {
+    case ContainerHowl: {
+      assert(container_type(FullCardSet) == ContainerHowl, "Must be");
+      if (container == FullCardSet) {
         if (cl.start_iterate(G1GCPhaseTimes::MergeRSMergedFull)) {
           cl(0, _config->max_cards_in_region());
         }
         return;
       }
       if (cl.start_iterate(G1GCPhaseTimes::MergeRSMergedHowl)) {
-        card_set_ptr<G1CardSetHowl>(card_set)->iterate(cl, _config);
+        container_ptr<G1CardSetHowl>(container)->iterate(cl, _config);
       }
       return;
     }
   }
-  log_error(gc)("Unkown card set type %u", card_set_type(card_set));
+  log_error(gc)("Unkown card set container type %u", container_type(container));
   ShouldNotReachHere();
 }
 

src/hotspot/share/gc/g1/g1CardSet.inline.hpp

@@ -31,7 +31,7 @@
 #include "utilities/bitMap.hpp"
 #include "utilities/globalDefinitions.hpp"
 
-// A helper class to encode a few card indexes within a CardSetPtr.
+// A helper class to encode a few card indexes within a ContainerPtr.
 //
 // The pointer value (either 32 or 64 bits) is split into two areas:
 //
@@ -65,26 +65,26 @@
 class G1CardSetInlinePtr : public StackObj {
   friend class G1CardSetContainersTest;
 
-  typedef G1CardSet::CardSetPtr CardSetPtr;
+  using ContainerPtr = G1CardSet::ContainerPtr;
 
-  CardSetPtr volatile * _value_addr;
-  CardSetPtr _value;
+  ContainerPtr volatile * _value_addr;
+  ContainerPtr _value;
 
   static const uint SizeFieldLen = 3;
   static const uint SizeFieldPos = 2;
-  static const uint HeaderSize = G1CardSet::CardSetPtrHeaderSize + SizeFieldLen;
+  static const uint HeaderSize = G1CardSet::ContainerPtrHeaderSize + SizeFieldLen;
 
-  static const uint BitsInValue = sizeof(CardSetPtr) * BitsPerByte;
+  static const uint BitsInValue = sizeof(ContainerPtr) * BitsPerByte;
 
   static const uintptr_t SizeFieldMask = (((uint)1 << SizeFieldLen) - 1) << SizeFieldPos;
 
   static uint8_t card_pos_for(uint const idx, uint const bits_per_card) {
     return (idx * bits_per_card + HeaderSize);
   }
 
-  static CardSetPtr merge(CardSetPtr orig_value, uint card_in_region, uint idx, uint bits_per_card);
+  static ContainerPtr merge(ContainerPtr orig_value, uint card_in_region, uint idx, uint bits_per_card);
 
-  static uint card_at(CardSetPtr value, uint const idx, uint const bits_per_card) {
+  static uint card_at(ContainerPtr value, uint const idx, uint const bits_per_card) {
     uint8_t card_pos = card_pos_for(idx, bits_per_card);
     uint result = ((uintptr_t)value >> card_pos) & (((uintptr_t)1 << bits_per_card) - 1);
     return result;
@@ -93,14 +93,14 @@ class G1CardSetInlinePtr : public StackObj {
   uint find(uint const card_idx, uint const bits_per_card, uint start_at, uint num_cards);
 
 public:
-  G1CardSetInlinePtr() : _value_addr(nullptr), _value((CardSetPtr)G1CardSet::CardSetInlinePtr) { }
+  G1CardSetInlinePtr() : _value_addr(nullptr), _value((ContainerPtr)G1CardSet::ContainerInlinePtr) { }
 
-  G1CardSetInlinePtr(CardSetPtr value) : _value_addr(nullptr), _value(value) {
-    assert(G1CardSet::card_set_type(_value) == G1CardSet::CardSetInlinePtr, "Value " PTR_FORMAT " is not a valid G1CardSetInPtr.", p2i(_value));
+  G1CardSetInlinePtr(ContainerPtr value) : _value_addr(nullptr), _value(value) {
+    assert(G1CardSet::container_type(_value) == G1CardSet::ContainerInlinePtr, "Value " PTR_FORMAT " is not a valid G1CardSetInlinePtr.", p2i(_value));
   }
 
-  G1CardSetInlinePtr(CardSetPtr volatile* value_addr, CardSetPtr value) : _value_addr(value_addr), _value(value) {
-    assert(G1CardSet::card_set_type(_value) == G1CardSet::CardSetInlinePtr, "Value " PTR_FORMAT " is not a valid G1CardSetInPtr.", p2i(_value));
+  G1CardSetInlinePtr(ContainerPtr volatile* value_addr, ContainerPtr value) : _value_addr(value_addr), _value(value) {
+    assert(G1CardSet::container_type(_value) == G1CardSet::ContainerInlinePtr, "Value " PTR_FORMAT " is not a valid G1CardSetInlinePtr.", p2i(_value));
   }
 
   G1AddCardResult add(uint const card_idx, uint const bits_per_card, uint const max_cards_in_inline_ptr);
@@ -110,13 +110,13 @@ class G1CardSetInlinePtr : public StackObj {
   template <class CardVisitor>
   void iterate(CardVisitor& found, uint const bits_per_card);
 
-  operator CardSetPtr () { return _value; }
+  operator ContainerPtr () { return _value; }
 
   static uint max_cards_in_inline_ptr(uint bits_per_card) {
     return (BitsInValue - HeaderSize) / bits_per_card;
   }
 
-  static uint num_cards_in(CardSetPtr value) {
+  static uint num_cards_in(ContainerPtr value) {
     return ((uintptr_t)value & SizeFieldMask) >> SizeFieldPos;
   }
 };
@@ -139,7 +139,7 @@ class G1CardSetInlinePtr : public StackObj {
 // which requires that we increment the reference counts by 2 starting at _ref_count = 3.
 //
 // All but inline pointers are of this kind. For those, card entries are stored
-// directly in the CardSetPtr of the ConcurrentHashTable node.
+// directly in the ContainerPtr of the ConcurrentHashTable node.
 class G1CardSetContainer {
   uintptr_t _ref_count;
 protected:
@@ -163,7 +163,7 @@ class G1CardSetArray : public G1CardSetContainer {
 public:
   typedef uint16_t EntryDataType;
   typedef uint EntryCountType;
-  using CardSetPtr = G1CardSet::CardSetPtr;
+  using ContainerPtr = G1CardSet::ContainerPtr;
 private:
   EntryCountType _size;
   EntryCountType volatile _num_entries;
@@ -217,7 +217,7 @@ class G1CardSetBitMap : public G1CardSetContainer {
   size_t _num_bits_set;
   BitMap::bm_word_t _bits[1];
 
-  using CardSetPtr = G1CardSet::CardSetPtr;
+  using ContainerPtr = G1CardSet::ContainerPtr;
 
   template<typename Derived>
   static size_t header_size_in_bytes_internal() {
@@ -252,43 +252,43 @@ class G1CardSetBitMap : public G1CardSetContainer {
 class G1CardSetHowl : public G1CardSetContainer {
 public:
   typedef uint EntryCountType;
-  using CardSetPtr = G1CardSet::CardSetPtr;
+  using ContainerPtr = G1CardSet::ContainerPtr;
   EntryCountType volatile _num_entries;
 private:
-  CardSetPtr _buckets[2];
+  ContainerPtr _buckets[2];
   // Do not add class member variables beyond this point
 
   template<typename Derived>
   static size_t header_size_in_bytes_internal() {
     return offset_of(Derived, _buckets);
   }
 
-  // Iterates over the given CardSetPtr with at index in this Howl card set,
+  // Iterates over the given ContainerPtr with at index in this Howl card set,
   // applying a CardOrRangeVisitor on it.
   template <class CardOrRangeVisitor>
-  void iterate_cardset(CardSetPtr const card_set, uint index, CardOrRangeVisitor& found, G1CardSetConfiguration* config);
+  void iterate_cardset(ContainerPtr const container, uint index, CardOrRangeVisitor& found, G1CardSetConfiguration* config);
 
 public:
   G1CardSetHowl(EntryCountType card_in_region, G1CardSetConfiguration* config);
 
-  CardSetPtr* get_card_set_addr(EntryCountType index) {
+  ContainerPtr* get_container_addr(EntryCountType index) {
     return &_buckets[index];
   }
 
   bool contains(uint card_idx, G1CardSetConfiguration* config);
 
-  // Iterates over all CardSetPtrs in this Howl card set, applying a CardOrRangeVisitor
+  // Iterates over all ContainerPtrs in this Howl card set, applying a CardOrRangeVisitor
   // on it.
   template <class CardOrRangeVisitor>
   void iterate(CardOrRangeVisitor& found, G1CardSetConfiguration* config);
 
-  // Iterates over all CardSetPtrs in this Howl card set. Calls
+  // Iterates over all ContainerPtrs in this Howl card set. Calls
   //
-  //   void operator ()(CardSetPtr* card_set_addr);
+  //   void operator ()(ContainerPtr* card_set_addr);
   //
   // on all of them.
-  template <class CardSetPtrVisitor>
-  void iterate(CardSetPtrVisitor& found, uint num_card_sets);
+  template <class ContainerPtrVisitor>
+  void iterate(ContainerPtrVisitor& found, uint num_card_sets);
 
   static EntryCountType num_buckets(size_t size_in_bits, size_t num_cards_in_array, size_t max_buckets);
 
@@ -300,7 +300,7 @@ class G1CardSetHowl : public G1CardSetContainer {
   static size_t header_size_in_bytes() { return header_size_in_bytes_internal<G1CardSetHowl>(); }
 
   static size_t size_in_bytes(size_t num_arrays) {
-    return header_size_in_bytes() + sizeof(CardSetPtr) * num_arrays;
+    return header_size_in_bytes() + sizeof(ContainerPtr) * num_arrays;
   }
 };
 

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

@@ -31,7 +31,7 @@
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/spinYield.hpp"
 
-inline G1CardSetInlinePtr::CardSetPtr G1CardSetInlinePtr::merge(CardSetPtr orig_value, uint card_in_region, uint idx, uint bits_per_card) {
+inline G1CardSetInlinePtr::ContainerPtr G1CardSetInlinePtr::merge(ContainerPtr orig_value, uint card_in_region, uint idx, uint bits_per_card) {
   assert((idx & (SizeFieldMask >> SizeFieldPos)) == idx, "Index %u too large to fit into size field", idx);
   assert(card_in_region < ((uint)1 << bits_per_card), "Card %u too large to fit into card value field", card_in_region);
 
@@ -44,7 +44,7 @@ inline G1CardSetInlinePtr::CardSetPtr G1CardSetInlinePtr::merge(CardSetPtr orig_
 
   uintptr_t value = ((uintptr_t)(idx + 1) << SizeFieldPos) | ((uintptr_t)card_in_region << card_pos);
   uintptr_t res = (((uintptr_t)orig_value & ~SizeFieldMask) | value);
-  return (CardSetPtr)res;
+  return (ContainerPtr)res;
 }
 
 inline G1AddCardResult G1CardSetInlinePtr::add(uint card_idx, uint bits_per_card, uint max_cards_in_inline_ptr) {
@@ -64,16 +64,16 @@ inline G1AddCardResult G1CardSetInlinePtr::add(uint card_idx, uint bits_per_card
     if (num_cards >= max_cards_in_inline_ptr) {
       return Overflow;
     }
-    CardSetPtr new_value = merge(_value, card_idx, num_cards, bits_per_card);
-    CardSetPtr old_value = Atomic::cmpxchg(_value_addr, _value, new_value, memory_order_relaxed);
+    ContainerPtr new_value = merge(_value, card_idx, num_cards, bits_per_card);
+    ContainerPtr old_value = Atomic::cmpxchg(_value_addr, _value, new_value, memory_order_relaxed);
     if (_value == old_value) {
       return Added;
     }
     // Update values and retry.
     _value = old_value;
     // The value of the pointer may have changed to something different than
     // an inline card set. Exit then instead of overwriting.
-    if (G1CardSet::card_set_type(_value) != G1CardSet::CardSetInlinePtr) {
+    if (G1CardSet::container_type(_value) != G1CardSet::ContainerInlinePtr) {
       return Overflow;
     }
   }
@@ -268,23 +268,23 @@ inline G1CardSetHowl::G1CardSetHowl(EntryCountType card_in_region, G1CardSetConf
 
 inline bool G1CardSetHowl::contains(uint card_idx, G1CardSetConfiguration* config) {
   EntryCountType bucket = config->howl_bucket_index(card_idx);
-  CardSetPtr* array_entry = get_card_set_addr(bucket);
-  CardSetPtr card_set = Atomic::load_acquire(array_entry);
+  ContainerPtr* array_entry = get_container_addr(bucket);
+  ContainerPtr container = Atomic::load_acquire(array_entry);
 
-  switch (G1CardSet::card_set_type(card_set)) {
-    case G1CardSet::CardSetArrayOfCards : {
-      return G1CardSet::card_set_ptr<G1CardSetArray>(card_set)->contains(card_idx);
+  switch (G1CardSet::container_type(container)) {
+    case G1CardSet::ContainerArrayOfCards: {
+      return G1CardSet::container_ptr<G1CardSetArray>(container)->contains(card_idx);
     }
-    case G1CardSet::CardSetBitMap: {
+    case G1CardSet::ContainerBitMap: {
       uint card_offset = config->howl_bitmap_offset(card_idx);
-      return G1CardSet::card_set_ptr<G1CardSetBitMap>(card_set)->contains(card_offset, config->max_cards_in_howl_bitmap());
+      return G1CardSet::container_ptr<G1CardSetBitMap>(container)->contains(card_offset, config->max_cards_in_howl_bitmap());
     }
-    case G1CardSet::CardSetInlinePtr: {
-      G1CardSetInlinePtr ptr(card_set);
+    case G1CardSet::ContainerInlinePtr: {
+      G1CardSetInlinePtr ptr(container);
       return ptr.contains(card_idx, config->inline_ptr_bits_per_card());
     }
-    case G1CardSet::CardSetHowl: {// Fullcard set entry
-      assert(card_set == G1CardSet::FullCardSet, "Must be");
+    case G1CardSet::ContainerHowl: {// Fullcard set entry
+      assert(container == G1CardSet::FullCardSet, "Must be");
       return true;
     }
   }
@@ -298,38 +298,38 @@ inline void G1CardSetHowl::iterate(CardOrRangeVisitor& found, G1CardSetConfigura
   }
 }
 
-template <class CardSetPtrVisitor>
-inline void G1CardSetHowl::iterate(CardSetPtrVisitor& found, uint num_card_sets) {
+template <class ContainerPtrVisitor>
+inline void G1CardSetHowl::iterate(ContainerPtrVisitor& found, uint num_card_sets) {
   for (uint i = 0; i < num_card_sets; ++i) {
     found(&_buckets[i]);
   }
 }
 
 template <class CardOrRangeVisitor>
-inline void G1CardSetHowl::iterate_cardset(CardSetPtr const card_set, uint index, CardOrRangeVisitor& found, G1CardSetConfiguration* config) {
-  switch (G1CardSet::card_set_type(card_set)) {
-    case G1CardSet::CardSetInlinePtr: {
+inline void G1CardSetHowl::iterate_cardset(ContainerPtr const container, uint index, CardOrRangeVisitor& found, G1CardSetConfiguration* config) {
+  switch (G1CardSet::container_type(container)) {
+    case G1CardSet::ContainerInlinePtr: {
       if (found.start_iterate(G1GCPhaseTimes::MergeRSHowlInline)) {
-        G1CardSetInlinePtr ptr(card_set);
+        G1CardSetInlinePtr ptr(container);
         ptr.iterate(found, config->inline_ptr_bits_per_card());
       }
       return;
     }
-    case G1CardSet::CardSetArrayOfCards : {
+    case G1CardSet::ContainerArrayOfCards: {
       if (found.start_iterate(G1GCPhaseTimes::MergeRSHowlArrayOfCards)) {
-        G1CardSet::card_set_ptr<G1CardSetArray>(card_set)->iterate(found);
+        G1CardSet::container_ptr<G1CardSetArray>(container)->iterate(found);
       }
       return;
     }
-    case G1CardSet::CardSetBitMap: {
+    case G1CardSet::ContainerBitMap: {
       if (found.start_iterate(G1GCPhaseTimes::MergeRSHowlBitmap)) {
         uint offset = index << config->log2_max_cards_in_howl_bitmap();
-        G1CardSet::card_set_ptr<G1CardSetBitMap>(card_set)->iterate(found, config->max_cards_in_howl_bitmap(), offset);
+        G1CardSet::container_ptr<G1CardSetBitMap>(container)->iterate(found, config->max_cards_in_howl_bitmap(), offset);
       }
       return;
     }
-    case G1CardSet::CardSetHowl: { // actually FullCardSet
-      assert(card_set == G1CardSet::FullCardSet, "Must be");
+    case G1CardSet::ContainerHowl: { // actually FullCardSet
+      assert(container == G1CardSet::FullCardSet, "Must be");
       if (found.start_iterate(G1GCPhaseTimes::MergeRSHowlFull)) {
         uint offset = index << config->log2_max_cards_in_howl_bitmap();
         found(offset, config->max_cards_in_howl_bitmap());

src/hotspot/share/gc/g1/g1CardSetContainers.inline.hpp

@@ -78,7 +78,7 @@ class G1ContainerCardsOrRanges {
 };
 
 template <typename Closure, template <typename> class CardOrRanges>
-class G1HeapRegionRemSetMergeCardClosure : public G1CardSet::CardSetPtrClosure {
+class G1HeapRegionRemSetMergeCardClosure : public G1CardSet::ContainerPtrClosure {
   G1CardSet* _card_set;
   Closure& _cl;
   uint _log_card_regions_per_region;
@@ -98,11 +98,11 @@ class G1HeapRegionRemSetMergeCardClosure : public G1CardSet::CardSetPtrClosure {
     _log_card_region_size(log_card_region_size) {
   }
 
-  void do_cardsetptr(uint card_region_idx, size_t num_occupied, G1CardSet::CardSetPtr card_set) override {
+  void do_containerptr(uint card_region_idx, size_t num_occupied, G1CardSet::ContainerPtr container) override {
     CardOrRanges<Closure> cl(_cl,
                              card_region_idx >> _log_card_regions_per_region,
                              (card_region_idx & _card_regions_per_region_mask) << _log_card_region_size);
-    _card_set->iterate_cards_or_ranges_in_container(card_set, cl);
+    _card_set->iterate_cards_or_ranges_in_container(container, cl);
   }
 };
 

src/hotspot/share/gc/g1/heapRegionRemSet.inline.hpp

@@ -165,13 +165,13 @@ void G1CardSetTest::translate_cards(uint cards_per_region, uint region_idx, uint
   }
 }
 
-class G1CountCardsOccupied : public G1CardSet::CardSetPtrClosure {
+class G1CountCardsOccupied : public G1CardSet::ContainerPtrClosure {
   size_t _num_occupied;
 
 public:
   G1CountCardsOccupied() : _num_occupied(0) { }
 
-  void do_cardsetptr(uint region_idx, size_t num_occupied, G1CardSet::CardSetPtr card_set) override {
+  void do_containerptr(uint region_idx, size_t num_occupied, G1CardSet::ContainerPtr container) override {
     _num_occupied += num_occupied;
   }
 

test/hotspot/gtest/gc/g1/test_g1CardSet.cpp

@@ -83,7 +83,7 @@ void G1CardSetContainersTest::cardset_inlineptr_test(uint bits_per_card) {
 
   G1AddCardResult res;
 
-  G1CardSet::CardSetPtr value = G1CardSetInlinePtr();
+  G1CardSet::ContainerPtr value = G1CardSetInlinePtr();
 
   for (uint i = 0; i < CardsPerSet; i++) {
     {