1 /*

     2  * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    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_G1_HEAPREGIONSET_HPP

    26 #define SHARE_VM_GC_G1_HEAPREGIONSET_HPP

    27 

    28 #include "gc/g1/heapRegion.hpp"

    29 

    30 // Large buffer for some cases where the output might be larger than normal.

    31 #define HRS_ERR_MSG_BUFSZ 512

    32 typedef FormatBuffer<HRS_ERR_MSG_BUFSZ> hrs_err_msg;

    33 

    34 // Set verification will be forced either if someone defines

    35 // HEAP_REGION_SET_FORCE_VERIFY to be 1, or in builds in which

    36 // asserts are compiled in.

    37 #ifndef HEAP_REGION_SET_FORCE_VERIFY

    38 #define HEAP_REGION_SET_FORCE_VERIFY defined(ASSERT)

    39 #endif // HEAP_REGION_SET_FORCE_VERIFY

    40 

    41 class hrs_ext_msg;

    42 

    43 class HRSMtSafeChecker : public CHeapObj<mtGC> {

    44 public:

    45   virtual void check() = 0;

    46 };

    47 

    48 class MasterFreeRegionListMtSafeChecker    : public HRSMtSafeChecker { public: void check(); };

    49 class SecondaryFreeRegionListMtSafeChecker : public HRSMtSafeChecker { public: void check(); };

    50 class HumongousRegionSetMtSafeChecker      : public HRSMtSafeChecker { public: void check(); };

    51 class OldRegionSetMtSafeChecker            : public HRSMtSafeChecker { public: void check(); };

    52 

    53 class HeapRegionSetCount VALUE_OBJ_CLASS_SPEC {

    54   friend class VMStructs;

    55   uint   _length;

    56   size_t _capacity;

    57 

    58 public:

    59   HeapRegionSetCount() : _length(0), _capacity(0) { }

    60 

    61   const uint   length()   const { return _length;   }

    62   const size_t capacity() const { return _capacity; }

    63 

    64   void increment(uint length_to_add, size_t capacity_to_add) {

    65     _length += length_to_add;

    66     _capacity += capacity_to_add;

    67   }

    68 

    69   void decrement(const uint length_to_remove, const size_t capacity_to_remove) {

    70     _length -= length_to_remove;

    71     _capacity -= capacity_to_remove;

    72   }

    73 };

    74 

    75 // Base class for all the classes that represent heap region sets. It

    76 // contains the basic attributes that each set needs to maintain

    77 // (e.g., length, region num, used bytes sum) plus any shared

    78 // functionality (e.g., verification).

    79 

    80 class HeapRegionSetBase VALUE_OBJ_CLASS_SPEC {

    81   friend class VMStructs;

    82 private:

    83   bool _is_humongous;

    84   bool _is_free;

    85   HRSMtSafeChecker* _mt_safety_checker;

    86 

    87 protected:

    88   // The number of regions added to the set. If the set contains

    89   // only humongous regions, this reflects only 'starts humongous'

    90   // regions and does not include 'continues humongous' ones.

    91   HeapRegionSetCount _count;

    92 

    93   const char* _name;

    94 

    95   bool _verify_in_progress;

    96 

    97   // verify_region() is used to ensure that the contents of a region

    98   // added to / removed from a set are consistent.

    99   void verify_region(HeapRegion* hr) PRODUCT_RETURN;

   100 

   101   // Indicates whether all regions in the set should be humongous or

   102   // not. Only used during verification.

   103   bool regions_humongous() { return _is_humongous; }

   104 

   105   // Indicates whether all regions in the set should be free or

   106   // not. Only used during verification.

   107   bool regions_free() { return _is_free; }

   108 

   109   void check_mt_safety() {

   110     if (_mt_safety_checker != NULL) {

   111       _mt_safety_checker->check();

   112     }

   113   }

   114 

   115   virtual void fill_in_ext_msg_extra(hrs_ext_msg* msg) { }

   116 

   117   HeapRegionSetBase(const char* name, bool humongous, bool free, HRSMtSafeChecker* mt_safety_checker);

   118 

   119 public:

   120   const char* name() { return _name; }

   121 

   122   uint length() const { return _count.length(); }

   123 

   124   bool is_empty() { return _count.length() == 0; }

   125 

   126   size_t total_capacity_bytes() {

   127     return _count.capacity();

   128   }

   129 

   130   // It updates the fields of the set to reflect hr being added to

   131   // the set and tags the region appropriately.

   132   inline void add(HeapRegion* hr);

   133 

   134   // It updates the fields of the set to reflect hr being removed

   135   // from the set and tags the region appropriately.

   136   inline void remove(HeapRegion* hr);

   137 

   138   // fill_in_ext_msg() writes the the values of the set's attributes

   139   // in the custom err_msg (hrs_ext_msg). fill_in_ext_msg_extra()

   140   // allows subclasses to append further information.

   141   void fill_in_ext_msg(hrs_ext_msg* msg, const char* message);

   142 

   143   virtual void verify();

   144   void verify_start();

   145   void verify_next_region(HeapRegion* hr);

   146   void verify_end();

   147 

   148 #if HEAP_REGION_SET_FORCE_VERIFY

   149   void verify_optional() {

   150     verify();

   151   }

   152 #else // HEAP_REGION_SET_FORCE_VERIFY

   153   void verify_optional() { }

   154 #endif // HEAP_REGION_SET_FORCE_VERIFY

   155 

   156   virtual void print_on(outputStream* out, bool print_contents = false);

   157 };

   158 

   159 // Customized err_msg for heap region sets. Apart from a

   160 // assert/guarantee-specific message it also prints out the values of

   161 // the fields of the associated set. This can be very helpful in

   162 // diagnosing failures.

   163 class hrs_ext_msg : public hrs_err_msg {

   164 public:

   165   hrs_ext_msg(HeapRegionSetBase* set, const char* message) : hrs_err_msg("%s", "") {

   166     set->fill_in_ext_msg(this, message);

   167   }

   168 };

   169 

   170 #define hrs_assert_sets_match(_set1_, _set2_)                                 \

   171   do {                                                                        \

   172     assert(((_set1_)->regions_humongous() ==                                  \

   173                                             (_set2_)->regions_humongous()) && \

   174            ((_set1_)->regions_free() == (_set2_)->regions_free()),            \

   175            hrs_err_msg("the contents of set %s and set %s should match",      \

   176                        (_set1_)->name(), (_set2_)->name()));                  \

   177   } while (0)

   178 

   179 // This class represents heap region sets whose members are not

   180 // explicitly tracked. It's helpful to group regions using such sets

   181 // so that we can reason about all the region groups in the heap using

   182 // the same interface (namely, the HeapRegionSetBase API).

   183 

   184 class HeapRegionSet : public HeapRegionSetBase {

   185 public:

   186   HeapRegionSet(const char* name, bool humongous, HRSMtSafeChecker* mt_safety_checker):

   187     HeapRegionSetBase(name, humongous, false /* free */, mt_safety_checker) { }

   188 

   189   void bulk_remove(const HeapRegionSetCount& removed) {

   190     _count.decrement(removed.length(), removed.capacity());

   191   }

   192 };

   193 

   194 // A set that links all the regions added to it in a doubly-linked

   195 // sorted list. We should try to avoid doing operations that iterate over

   196 // such lists in performance critical paths. Typically we should

   197 // add / remove one region at a time or concatenate two lists.

   198 

   199 class FreeRegionListIterator;

   200 

   201 class FreeRegionList : public HeapRegionSetBase {

   202   friend class FreeRegionListIterator;

   203 

   204 private:

   205   HeapRegion* _head;

   206   HeapRegion* _tail;

   207 

   208   // _last is used to keep track of where we added an element the last

   209   // time. It helps to improve performance when adding several ordered items in a row.

   210   HeapRegion* _last;

   211 

   212   static uint _unrealistically_long_length;

   213 

   214   inline HeapRegion* remove_from_head_impl();

   215   inline HeapRegion* remove_from_tail_impl();

   216 

   217 protected:

   218   virtual void fill_in_ext_msg_extra(hrs_ext_msg* msg);

   219 

   220   // See the comment for HeapRegionSetBase::clear()

   221   virtual void clear();

   222 

   223 public:

   224   FreeRegionList(const char* name, HRSMtSafeChecker* mt_safety_checker = NULL):

   225     HeapRegionSetBase(name, false /* humongous */, true /* empty */, mt_safety_checker) {

   226     clear();

   227   }

   228 

   229   void verify_list();

   230 

   231 #ifdef ASSERT

   232   bool contains(HeapRegion* hr) const {

   233     return hr->containing_set() == this;

   234   }

   235 #endif

   236 

   237   static void set_unrealistically_long_length(uint len);

   238 

   239   // Add hr to the list. The region should not be a member of another set.

   240   // Assumes that the list is ordered and will preserve that order. The order

   241   // is determined by hrm_index.

   242   inline void add_ordered(HeapRegion* hr);

   243 

   244   // Removes from head or tail based on the given argument.

   245   HeapRegion* remove_region(bool from_head);

   246 

   247   // Merge two ordered lists. The result is also ordered. The order is

   248   // determined by hrm_index.

   249   void add_ordered(FreeRegionList* from_list);

   250 

   251   // It empties the list by removing all regions from it.

   252   void remove_all();

   253 

   254   // Remove all (contiguous) regions from first to first + num_regions -1 from

   255   // this list.

   256   // Num_regions must be > 1.

   257   void remove_starting_at(HeapRegion* first, uint num_regions);

   258 

   259   virtual void verify();

   260 

   261   virtual void print_on(outputStream* out, bool print_contents = false);

   262 };

   263 

   264 // Iterator class that provides a convenient way to iterate over the

   265 // regions of a FreeRegionList.

   266 

   267 class FreeRegionListIterator : public StackObj {

   268 private:

   269   FreeRegionList* _list;

   270   HeapRegion*     _curr;

   271 

   272 public:

   273   bool more_available() {

   274     return _curr != NULL;

   275   }

   276 

   277   HeapRegion* get_next() {

   278     assert(more_available(),

   279            "get_next() should be called when more regions are available");

   280 

   281     // If we are going to introduce a count in the iterator we should

   282     // do the "cycle" check.

   283 

   284     HeapRegion* hr = _curr;

   285     _list->verify_region(hr);

   286     _curr = hr->next();

   287     return hr;

   288   }

   289 

   290   FreeRegionListIterator(FreeRegionList* list) : _curr(NULL), _list(list) {

   291     _curr = list->_head;

   292   }

   293 };

   294 

   295 #endif // SHARE_VM_GC_G1_HEAPREGIONSET_HPP