< prev index next >

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

Print this page
rev 11972 : [mq]: 8157952-sangheon-review
   1 /*
   2  * Copyright (c) 2001, 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_HEAPREGIONMANAGER_HPP
  26 #define SHARE_VM_GC_G1_HEAPREGIONMANAGER_HPP
  27 
  28 #include "gc/g1/g1BiasedArray.hpp"
  29 #include "gc/g1/g1RegionToSpaceMapper.hpp"
  30 #include "gc/g1/heapRegionSet.hpp"
  31 #include "services/memoryUsage.hpp"
  32 
  33 class HeapRegion;
  34 class HeapRegionClosure;
  35 class HeapRegionClaimer;
  36 class FreeRegionList;

  37 
  38 class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
  39  protected:
  40   virtual HeapRegion* default_value() const { return NULL; }
  41 };
  42 
  43 // This class keeps track of the actual heap memory, auxiliary data
  44 // and its metadata (i.e., HeapRegion instances) and the list of free regions.
  45 //
  46 // This allows maximum flexibility for deciding what to commit or uncommit given
  47 // a request from outside.
  48 //
  49 // HeapRegions are kept in the _regions array in address order. A region's
  50 // index in the array corresponds to its index in the heap (i.e., 0 is the
  51 // region at the bottom of the heap, 1 is the one after it, etc.). Two
  52 // regions that are consecutive in the array should also be adjacent in the
  53 // address space (i.e., region(i).end() == region(i+1).bottom().
  54 //
  55 // We create a HeapRegion when we commit the region's address space
  56 // for the first time. When we uncommit the address space of a


  77   G1RegionToSpaceMapper* _next_bitmap_mapper;
  78   G1RegionToSpaceMapper* _bot_mapper;
  79   G1RegionToSpaceMapper* _cardtable_mapper;
  80   G1RegionToSpaceMapper* _card_counts_mapper;
  81 
  82   FreeRegionList _free_list;
  83 
  84   // Each bit in this bitmap indicates that the corresponding region is available
  85   // for allocation.
  86   CHeapBitMap _available_map;
  87 
  88    // The number of regions committed in the heap.
  89   uint _num_committed;
  90 
  91   // Internal only. The highest heap region +1 we allocated a HeapRegion instance for.
  92   uint _allocated_heapregions_length;
  93 
  94   HeapWord* heap_bottom() const { return _regions.bottom_address_mapped(); }
  95   HeapWord* heap_end() const {return _regions.end_address_mapped(); }
  96 
  97   void make_regions_available(uint index, uint num_regions = 1);
  98 
  99   // Pass down commit calls to the VirtualSpace.
 100   void commit_regions(uint index, size_t num_regions = 1);
 101   void uncommit_regions(uint index, size_t num_regions = 1);
 102 
 103   // Notify other data structures about change in the heap layout.
 104   void update_committed_space(HeapWord* old_end, HeapWord* new_end);
 105 
 106   // Find a contiguous set of empty or uncommitted regions of length num and return
 107   // the index of the first region or G1_NO_HRM_INDEX if the search was unsuccessful.
 108   // If only_empty is true, only empty regions are considered.
 109   // Searches from bottom to top of the heap, doing a first-fit.
 110   uint find_contiguous(size_t num, bool only_empty);
 111   // Finds the next sequence of unavailable regions starting from start_idx. Returns the
 112   // length of the sequence found. If this result is zero, no such sequence could be found,
 113   // otherwise res_idx indicates the start index of these regions.
 114   uint find_unavailable_from_idx(uint start_idx, uint* res_idx) const;
 115   // Finds the next sequence of empty regions starting from start_idx, going backwards in
 116   // the heap. Returns the length of the sequence found. If this value is zero, no
 117   // sequence could be found, otherwise res_idx contains the start index of this range.
 118   uint find_empty_from_idx_reverse(uint start_idx, uint* res_idx) const;
 119   // Allocate a new HeapRegion for the given index.
 120   HeapRegion* new_heap_region(uint hrm_index);


 192     return num_free_regions() * HeapRegion::GrainBytes;
 193   }
 194 
 195   // Return the number of available (uncommitted) regions.
 196   uint available() const { return max_length() - length(); }
 197 
 198   // Return the number of regions that have been committed in the heap.
 199   uint length() const { return _num_committed; }
 200 
 201   // Return the maximum number of regions in the heap.
 202   uint max_length() const { return (uint)_regions.length(); }
 203 
 204   MemoryUsage get_auxiliary_data_memory_usage() const;
 205 
 206   MemRegion reserved() const { return MemRegion(heap_bottom(), heap_end()); }
 207 
 208   // Expand the sequence to reflect that the heap has grown. Either create new
 209   // HeapRegions, or re-use existing ones. Returns the number of regions the
 210   // sequence was expanded by. If a HeapRegion allocation fails, the resulting
 211   // number of regions might be smaller than what's desired.
 212   uint expand_by(uint num_regions);
 213 
 214   // Makes sure that the regions from start to start+num_regions-1 are available
 215   // for allocation. Returns the number of regions that were committed to achieve
 216   // this.
 217   uint expand_at(uint start, uint num_regions);
 218 
 219   // Find a contiguous set of empty regions of length num. Returns the start index of
 220   // that set, or G1_NO_HRM_INDEX.
 221   uint find_contiguous_only_empty(size_t num) { return find_contiguous(num, true); }
 222   // Find a contiguous set of empty or unavailable regions of length num. Returns the
 223   // start index of that set, or G1_NO_HRM_INDEX.
 224   uint find_contiguous_empty_or_unavailable(size_t num) { return find_contiguous(num, false); }
 225 
 226   HeapRegion* next_region_in_heap(const HeapRegion* r) const;
 227 
 228   // Find the highest free or uncommitted region in the reserved heap,
 229   // and if uncommitted, commit it. If none are available, return G1_NO_HRM_INDEX.
 230   // Set the 'expanded' boolean true if a new region was committed.
 231   uint find_highest_free(bool* expanded);
 232 
 233   // Allocate the regions that contain the address range specified, committing the
 234   // regions if necessary. Return false if any of the regions is already committed
 235   // and not free, and return the number of regions newly committed in commit_count.
 236   bool allocate_containing_regions(MemRegion range, size_t* commit_count);
 237 


   1 /*
   2  * Copyright (c) 2001, 2016, 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_HEAPREGIONMANAGER_HPP
  26 #define SHARE_VM_GC_G1_HEAPREGIONMANAGER_HPP
  27 
  28 #include "gc/g1/g1BiasedArray.hpp"
  29 #include "gc/g1/g1RegionToSpaceMapper.hpp"
  30 #include "gc/g1/heapRegionSet.hpp"
  31 #include "services/memoryUsage.hpp"
  32 
  33 class HeapRegion;
  34 class HeapRegionClosure;
  35 class HeapRegionClaimer;
  36 class FreeRegionList;
  37 class WorkGang;
  38 
  39 class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
  40  protected:
  41   virtual HeapRegion* default_value() const { return NULL; }
  42 };
  43 
  44 // This class keeps track of the actual heap memory, auxiliary data
  45 // and its metadata (i.e., HeapRegion instances) and the list of free regions.
  46 //
  47 // This allows maximum flexibility for deciding what to commit or uncommit given
  48 // a request from outside.
  49 //
  50 // HeapRegions are kept in the _regions array in address order. A region's
  51 // index in the array corresponds to its index in the heap (i.e., 0 is the
  52 // region at the bottom of the heap, 1 is the one after it, etc.). Two
  53 // regions that are consecutive in the array should also be adjacent in the
  54 // address space (i.e., region(i).end() == region(i+1).bottom().
  55 //
  56 // We create a HeapRegion when we commit the region's address space
  57 // for the first time. When we uncommit the address space of a


  78   G1RegionToSpaceMapper* _next_bitmap_mapper;
  79   G1RegionToSpaceMapper* _bot_mapper;
  80   G1RegionToSpaceMapper* _cardtable_mapper;
  81   G1RegionToSpaceMapper* _card_counts_mapper;
  82 
  83   FreeRegionList _free_list;
  84 
  85   // Each bit in this bitmap indicates that the corresponding region is available
  86   // for allocation.
  87   CHeapBitMap _available_map;
  88 
  89    // The number of regions committed in the heap.
  90   uint _num_committed;
  91 
  92   // Internal only. The highest heap region +1 we allocated a HeapRegion instance for.
  93   uint _allocated_heapregions_length;
  94 
  95   HeapWord* heap_bottom() const { return _regions.bottom_address_mapped(); }
  96   HeapWord* heap_end() const {return _regions.end_address_mapped(); }
  97 
  98   void make_regions_available(uint index, uint num_regions = 1, WorkGang* pretouch_gang = NULL);
  99 
 100   // Pass down commit calls to the VirtualSpace.
 101   void commit_regions(uint index, size_t num_regions = 1, WorkGang* pretouch_gang = NULL);
 102   void uncommit_regions(uint index, size_t num_regions = 1);
 103 
 104   // Notify other data structures about change in the heap layout.
 105   void update_committed_space(HeapWord* old_end, HeapWord* new_end);
 106 
 107   // Find a contiguous set of empty or uncommitted regions of length num and return
 108   // the index of the first region or G1_NO_HRM_INDEX if the search was unsuccessful.
 109   // If only_empty is true, only empty regions are considered.
 110   // Searches from bottom to top of the heap, doing a first-fit.
 111   uint find_contiguous(size_t num, bool only_empty);
 112   // Finds the next sequence of unavailable regions starting from start_idx. Returns the
 113   // length of the sequence found. If this result is zero, no such sequence could be found,
 114   // otherwise res_idx indicates the start index of these regions.
 115   uint find_unavailable_from_idx(uint start_idx, uint* res_idx) const;
 116   // Finds the next sequence of empty regions starting from start_idx, going backwards in
 117   // the heap. Returns the length of the sequence found. If this value is zero, no
 118   // sequence could be found, otherwise res_idx contains the start index of this range.
 119   uint find_empty_from_idx_reverse(uint start_idx, uint* res_idx) const;
 120   // Allocate a new HeapRegion for the given index.
 121   HeapRegion* new_heap_region(uint hrm_index);


 193     return num_free_regions() * HeapRegion::GrainBytes;
 194   }
 195 
 196   // Return the number of available (uncommitted) regions.
 197   uint available() const { return max_length() - length(); }
 198 
 199   // Return the number of regions that have been committed in the heap.
 200   uint length() const { return _num_committed; }
 201 
 202   // Return the maximum number of regions in the heap.
 203   uint max_length() const { return (uint)_regions.length(); }
 204 
 205   MemoryUsage get_auxiliary_data_memory_usage() const;
 206 
 207   MemRegion reserved() const { return MemRegion(heap_bottom(), heap_end()); }
 208 
 209   // Expand the sequence to reflect that the heap has grown. Either create new
 210   // HeapRegions, or re-use existing ones. Returns the number of regions the
 211   // sequence was expanded by. If a HeapRegion allocation fails, the resulting
 212   // number of regions might be smaller than what's desired.
 213   uint expand_by(uint num_regions, WorkGang* pretouch_workers = NULL);
 214 
 215   // Makes sure that the regions from start to start+num_regions-1 are available
 216   // for allocation. Returns the number of regions that were committed to achieve
 217   // this.
 218   uint expand_at(uint start, uint num_regions, WorkGang* pretouch_workers = NULL);
 219 
 220   // Find a contiguous set of empty regions of length num. Returns the start index of
 221   // that set, or G1_NO_HRM_INDEX.
 222   uint find_contiguous_only_empty(size_t num) { return find_contiguous(num, true); }
 223   // Find a contiguous set of empty or unavailable regions of length num. Returns the
 224   // start index of that set, or G1_NO_HRM_INDEX.
 225   uint find_contiguous_empty_or_unavailable(size_t num) { return find_contiguous(num, false); }
 226 
 227   HeapRegion* next_region_in_heap(const HeapRegion* r) const;
 228 
 229   // Find the highest free or uncommitted region in the reserved heap,
 230   // and if uncommitted, commit it. If none are available, return G1_NO_HRM_INDEX.
 231   // Set the 'expanded' boolean true if a new region was committed.
 232   uint find_highest_free(bool* expanded);
 233 
 234   // Allocate the regions that contain the address range specified, committing the
 235   // regions if necessary. Return false if any of the regions is already committed
 236   // and not free, and return the number of regions newly committed in commit_count.
 237   bool allocate_containing_regions(MemRegion range, size_t* commit_count);
 238 


< prev index next >