ysr@777: /*
mikael@6198:  * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
ysr@777:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
ysr@777:  *
ysr@777:  * This code is free software; you can redistribute it and/or modify it
ysr@777:  * under the terms of the GNU General Public License version 2 only, as
ysr@777:  * published by the Free Software Foundation.
ysr@777:  *
ysr@777:  * This code is distributed in the hope that it will be useful, but WITHOUT
ysr@777:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
ysr@777:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
ysr@777:  * version 2 for more details (a copy is included in the LICENSE file that
ysr@777:  * accompanied this code).
ysr@777:  *
ysr@777:  * You should have received a copy of the GNU General Public License version
ysr@777:  * 2 along with this work; if not, write to the Free Software Foundation,
ysr@777:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
ysr@777:  *
trims@1907:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907:  * or visit www.oracle.com if you need additional information or have any
trims@1907:  * questions.
ysr@777:  *
ysr@777:  */
ysr@777: 
stefank@2314: #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
stefank@2314: #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
stefank@2314: 
tschatzl@5773: #include "gc_implementation/g1/g1BiasedArray.hpp"
tschatzl@5773: 
ysr@777: class HeapRegion;
ysr@777: class HeapRegionClosure;
tonyp@2963: class FreeRegionList;
tonyp@2963: 
tschatzl@5773: class G1HeapRegionTable : public G1BiasedMappedArray<HeapRegion*> {
tschatzl@5773:  protected:
tschatzl@5773:    virtual HeapRegion* default_value() const { return NULL; }
tschatzl@5773: };
tschatzl@5773: 
tonyp@2963: // This class keeps track of the region metadata (i.e., HeapRegion
tonyp@2963: // instances). They are kept in the _regions array in address
tonyp@2963: // order. A region's index in the array corresponds to its index in
tonyp@2963: // the heap (i.e., 0 is the region at the bottom of the heap, 1 is
tonyp@2963: // the one after it, etc.). Two regions that are consecutive in the
tonyp@2963: // array should also be adjacent in the address space (i.e.,
tonyp@2963: // region(i).end() == region(i+1).bottom().
tonyp@2963: //
tonyp@2963: // We create a HeapRegion when we commit the region's address space
tonyp@2963: // for the first time. When we uncommit the address space of a
tonyp@2963: // region we retain the HeapRegion to be able to re-use it in the
tonyp@2963: // future (in case we recommit it).
tonyp@2963: //
tonyp@2963: // We keep track of three lengths:
tonyp@2963: //
tschatzl@5773: // * _committed_length (returned by length()) is the number of currently
tonyp@2963: //   committed regions.
tonyp@2963: // * _allocated_length (not exposed outside this class) is the
tonyp@2963: //   number of regions for which we have HeapRegions.
tschatzl@5773: // * max_length() returns the maximum number of regions the heap can have.
tonyp@2963: //
tschatzl@5773: // and maintain that: _committed_length <= _allocated_length <= max_length()
ysr@777: 
zgu@3900: class HeapRegionSeq: public CHeapObj<mtGC> {
tonyp@3168:   friend class VMStructs;
ysr@777: 
tschatzl@5773:   G1HeapRegionTable _regions;
ysr@777: 
tonyp@2963:   // The number of regions committed in the heap.
tschatzl@5773:   uint _committed_length;
tonyp@2963: 
tonyp@2963:   // A hint for which index to start searching from for humongous
tonyp@2963:   // allocations.
tonyp@3713:   uint _next_search_index;
tonyp@2963: 
tonyp@2963:   // The number of regions for which we have allocated HeapRegions for.
tonyp@3713:   uint _allocated_length;
tonyp@2963: 
tonyp@2963:   // Find a contiguous set of empty regions of length num, starting
tonyp@2963:   // from the given index.
tonyp@3713:   uint find_contiguous_from(uint from, uint num);
tonyp@2963: 
brutisso@5074:   void increment_allocated_length() {
tschatzl@5773:     assert(_allocated_length < max_length(), "pre-condition");
brutisso@5074:     _allocated_length++;
tonyp@2963:   }
tonyp@2963: 
brutisso@5074:   void increment_length() {
tschatzl@5773:     assert(length() < max_length(), "pre-condition");
tschatzl@5773:     _committed_length++;
brutisso@5074:   }
brutisso@5074: 
brutisso@5074:   void decrement_length() {
tschatzl@5773:     assert(length() > 0, "pre-condition");
tschatzl@5773:     _committed_length--;
tonyp@2963:   }
ysr@777: 
tschatzl@5773:   HeapWord* heap_bottom() const { return _regions.bottom_address_mapped(); }
tschatzl@5773:   HeapWord* heap_end() const {return _regions.end_address_mapped(); }
tschatzl@5773: 
ysr@777:  public:
tonyp@2963:   // Empty contructor, we'll initialize it with the initialize() method.
tschatzl@5773:   HeapRegionSeq() : _regions(), _committed_length(0), _next_search_index(0), _allocated_length(0) { }
ysr@777: 
tschatzl@5773:   void initialize(HeapWord* bottom, HeapWord* end);
ysr@777: 
tonyp@2963:   // Return the HeapRegion at the given index. Assume that the index
tonyp@2963:   // is valid.
tonyp@3713:   inline HeapRegion* at(uint index) const;
ysr@777: 
tonyp@2963:   // If addr is within the committed space return its corresponding
tonyp@2963:   // HeapRegion, otherwise return NULL.
tonyp@2963:   inline HeapRegion* addr_to_region(HeapWord* addr) const;
ysr@777: 
tonyp@2963:   // Return the HeapRegion that corresponds to the given
tonyp@2963:   // address. Assume the address is valid.
tonyp@2963:   inline HeapRegion* addr_to_region_unsafe(HeapWord* addr) const;
ysr@777: 
tonyp@2963:   // Return the number of regions that have been committed in the heap.
tschatzl@5773:   uint length() const { return _committed_length; }
tonyp@2963: 
tonyp@2963:   // Return the maximum number of regions in the heap.
tschatzl@5773:   uint max_length() const { return (uint)_regions.length(); }
tonyp@2963: 
tonyp@2963:   // Expand the sequence to reflect that the heap has grown from
tonyp@2963:   // old_end to new_end. Either create new HeapRegions, or re-use
tonyp@2963:   // existing ones, and return them in the given list. Returns the
tonyp@2963:   // memory region that covers the newly-created regions. If a
tonyp@2963:   // HeapRegion allocation fails, the result memory region might be
tonyp@2963:   // smaller than the desired one.
tonyp@2963:   MemRegion expand_by(HeapWord* old_end, HeapWord* new_end,
tonyp@2963:                       FreeRegionList* list);
tonyp@2963: 
tonyp@2963:   // Return the number of contiguous regions at the end of the sequence
ysr@777:   // that are available for allocation.
tonyp@3713:   uint free_suffix();
ysr@777: 
tonyp@2643:   // Find a contiguous set of empty regions of length num and return
tonyp@2963:   // the index of the first region or G1_NULL_HRS_INDEX if the
tonyp@2963:   // search was unsuccessful.
tonyp@3713:   uint find_contiguous(uint num);
ysr@777: 
tonyp@2963:   // Apply blk->doHeapRegion() on all committed regions in address order,
tonyp@2963:   // terminating the iteration early if doHeapRegion() returns true.
tonyp@2963:   void iterate(HeapRegionClosure* blk) const;
ysr@777: 
tonyp@2963:   // As above, but start the iteration from hr and loop around. If hr
tonyp@2963:   // is NULL, we start from the first region in the heap.
tonyp@2963:   void iterate_from(HeapRegion* hr, HeapRegionClosure* blk) const;
ysr@777: 
tonyp@2963:   // Tag as uncommitted as many regions that are completely free as
brutisso@5074:   // possible, up to num_regions_to_remove, from the suffix of the committed
brutisso@5074:   // sequence. Return the actual number of removed regions.
brutisso@5074:   uint shrink_by(uint num_regions_to_remove);
ysr@777: 
tonyp@2963:   // Do some sanity checking.
tonyp@2963:   void verify_optional() PRODUCT_RETURN;
ysr@777: };
stefank@2314: 
stefank@2314: #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP