12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP
  26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP
  27 
  28 #include "gc_implementation/g1/heapRegionSet.hpp"
  29 
  30 //////////////////// HeapRegionSetBase ////////////////////
  31 
  32 inline void HeapRegionSetBase::update_for_addition(HeapRegion* hr) {
  33   // Assumes the caller has already verified the region.
  34 
  35   _length           += 1;
  36   _region_num       += hr->region_num();
  37   _total_used_bytes += hr->used();
  38 }
  39 
  40 inline void HeapRegionSetBase::add_internal(HeapRegion* hr) {
  41   hrs_assert_region_ok(this, hr, NULL);
  42   assert(hr->next() == NULL, hrs_ext_msg(this, "should not already be linked"));
  43 
  44   update_for_addition(hr);
  45   hr->set_containing_set(this);

  46 }
  47 
  48 inline void HeapRegionSetBase::update_for_removal(HeapRegion* hr) {
  49   // Assumes the caller has already verified the region.
  50   assert(_length > 0, hrs_ext_msg(this, "pre-condition"));
  51   _length -= 1;
  52 
  53   uint region_num_diff = hr->region_num();
  54   assert(region_num_diff <= _region_num,
  55          hrs_err_msg("[%s] region's region num: %u "
  56                      "should be <= region num: %u",
  57                      name(), region_num_diff, _region_num));
  58   _region_num -= region_num_diff;
  59 
  60   size_t used_bytes = hr->used();
  61   assert(used_bytes <= _total_used_bytes,
  62          hrs_err_msg("[%s] region's used bytes: "SIZE_FORMAT" "
  63                      "should be <= used bytes: "SIZE_FORMAT,
  64                      name(), used_bytes, _total_used_bytes));
  65   _total_used_bytes -= used_bytes;
  66 }
  67 
  68 inline void HeapRegionSetBase::remove_internal(HeapRegion* hr) {
  69   hrs_assert_region_ok(this, hr, this);
  70   assert(hr->next() == NULL, hrs_ext_msg(this, "should already be unlinked"));
  71 
  72   hr->set_containing_set(NULL);
  73   update_for_removal(hr);
  74 }
  75 
  76 //////////////////// HeapRegionSet ////////////////////
  77 
  78 inline void HeapRegionSet::add(HeapRegion* hr) {
  79   hrs_assert_mt_safety_ok(this);
  80   // add_internal() will verify the region.
  81   add_internal(hr);
  82 }
  83 
  84 inline void HeapRegionSet::remove(HeapRegion* hr) {
  85   hrs_assert_mt_safety_ok(this);
  86   // remove_internal() will verify the region.
  87   remove_internal(hr);
  88 }
  89 
  90 inline void HeapRegionSet::remove_with_proxy(HeapRegion* hr,
  91                                              HeapRegionSet* proxy_set) {
  92   // No need to fo the MT safety check here given that this method
  93   // does not update the contents of the set but instead accumulates
  94   // the changes in proxy_set which is assumed to be thread-local.
  95   hrs_assert_sets_match(this, proxy_set);
  96   hrs_assert_region_ok(this, hr, this);
  97 
  98   hr->set_containing_set(NULL);
  99   proxy_set->update_for_addition(hr);
 100 }
 101 
 102 //////////////////// HeapRegionLinkedList ////////////////////
 103 
 104 inline void HeapRegionLinkedList::add_as_head(HeapRegion* hr) {
 105   hrs_assert_mt_safety_ok(this);
 106   assert((length() == 0 && _head == NULL && _tail == NULL) ||
 107          (length() >  0 && _head != NULL && _tail != NULL),
 108          hrs_ext_msg(this, "invariant"));
 109   // add_internal() will verify the region.
 110   add_internal(hr);
 111 
 112   // Now link the region.
 113   if (_head != NULL) {
 114     hr->set_next(_head);
 115   } else {
 116     _tail = hr;
 117   }
 118   _head = hr;
 119 }
 120 
 121 inline void HeapRegionLinkedList::add_as_tail(HeapRegion* hr) {
 122   hrs_assert_mt_safety_ok(this);
 123   assert((length() == 0 && _head == NULL && _tail == NULL) ||
 124          (length() >  0 && _head != NULL && _tail != NULL),
 125          hrs_ext_msg(this, "invariant"));
 126   // add_internal() will verify the region.
 127   add_internal(hr);
 128 
 129   // Now link the region.
 130   if (_tail != NULL) {
 131     _tail->set_next(hr);
 132   } else {
 133     _head = hr;
 134   }
 135   _tail = hr;
 136 }
 137 
 138 inline HeapRegion* HeapRegionLinkedList::remove_head() {
 139   hrs_assert_mt_safety_ok(this);
 140   assert(!is_empty(), hrs_ext_msg(this, "the list should not be empty"));
 141   assert(length() > 0 && _head != NULL && _tail != NULL,
 142          hrs_ext_msg(this, "invariant"));
 143 
 144   // We need to unlink it first.
 145   HeapRegion* hr = _head;
 146   _head = hr->next();
 147   if (_head == NULL) {
 148     _tail = NULL;
 149   }
 150   hr->set_next(NULL);
 151 
 152   // remove_internal() will verify the region.
 153   remove_internal(hr);
 154   return hr;
 155 }
 156 
 157 inline HeapRegion* HeapRegionLinkedList::remove_head_or_null() {
 158   hrs_assert_mt_safety_ok(this);
 159 
 160   if (!is_empty()) {
 161     return remove_head();
 162   } else {
 163     return NULL;
 164   }
 165 }
 166 
 167 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP

  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP
  26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP
  27 
  28 #include "gc_implementation/g1/heapRegionSet.hpp"
  29 
  30 //////////////////// HeapRegionSetBase ////////////////////
  31 
  32 inline void HeapRegionSetBase::add(HeapRegion* hr) {
  33   check_mt_safety();
  34   assert(hr->containing_set() == NULL, hrs_ext_msg(this, "should not already have a containing set %u"));







  35   assert(hr->next() == NULL, hrs_ext_msg(this, "should not already be linked"));
  36 
  37   _count.increment(1u, hr->capacity());
  38   hr->set_containing_set(this);
  39   verify_region(hr);
  40 }
  41 
  42 inline void HeapRegionSetBase::remove(HeapRegion* hr) {
  43   check_mt_safety();
  44   verify_region(hr);



















  45   assert(hr->next() == NULL, hrs_ext_msg(this, "should already be unlinked"));
  46 
  47   hr->set_containing_set(NULL);
  48   assert(_count.length() > 0, hrs_ext_msg(this, "pre-condition"));
  49   _count.decrement(1u, hr->capacity());

























  50 }
  51 
  52 //////////////////// HeapRegionLinkedList ////////////////////
  53 
  54 inline void FreeRegionList::add_as_head(HeapRegion* hr) {

  55   assert((length() == 0 && _head == NULL && _tail == NULL) ||
  56          (length() >  0 && _head != NULL && _tail != NULL),
  57          hrs_ext_msg(this, "invariant"));
  58   // add() will verify the region and check mt safety.
  59   add(hr);
  60 
  61   // Now link the region.
  62   if (_head != NULL) {
  63     hr->set_next(_head);
  64   } else {
  65     _tail = hr;
  66   }
  67   _head = hr;
  68 }
  69 
  70 inline void FreeRegionList::add_as_tail(HeapRegion* hr) {
  71   check_mt_safety();
  72   assert((length() == 0 && _head == NULL && _tail == NULL) ||
  73          (length() >  0 && _head != NULL && _tail != NULL),
  74          hrs_ext_msg(this, "invariant"));
  75   // add() will verify the region and check mt safety
  76   add(hr);
  77 
  78   // Now link the region.
  79   if (_tail != NULL) {
  80     _tail->set_next(hr);
  81   } else {
  82     _head = hr;
  83   }
  84   _tail = hr;
  85 }
  86 
  87 inline HeapRegion* FreeRegionList::remove_head() {

  88   assert(!is_empty(), hrs_ext_msg(this, "the list should not be empty"));
  89   assert(length() > 0 && _head != NULL && _tail != NULL,
  90          hrs_ext_msg(this, "invariant"));
  91 
  92   // We need to unlink it first.
  93   HeapRegion* hr = _head;
  94   _head = hr->next();
  95   if (_head == NULL) {
  96     _tail = NULL;
  97   }
  98   hr->set_next(NULL);
  99 
 100   // remove() will verify the region and check mt safety
 101   remove(hr);
 102   return hr;
 103 }
 104 
 105 inline HeapRegion* FreeRegionList::remove_head_or_null() {


 106   if (!is_empty()) {
 107     return remove_head();
 108   } else {
 109     return NULL;
 110   }
 111 }
 112 
 113 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSET_INLINE_HPP