1 /*
   2  * Copyright (c) 1997, 2012, 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_RUNTIME_VIRTUALSPACE_HPP
  26 #define SHARE_VM_RUNTIME_VIRTUALSPACE_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 
  30 // ReservedSpace is a data structure for reserving a contiguous address range.
  31 
  32 class ReservedSpace VALUE_OBJ_CLASS_SPEC {
  33   friend class VMStructs;
  34  private:
  35   char*  _base;
  36   size_t _size;
  37   size_t _noaccess_prefix;
  38   size_t _alignment;
  39   bool   _special;
  40   bool   _executable;
  41 
  42   // ReservedSpace
  43   ReservedSpace(char* base, size_t size, size_t alignment, bool special,
  44                 bool executable);
  45   void initialize(size_t size, size_t alignment, bool large,
  46                   char* requested_address,
  47                   const size_t noaccess_prefix,
  48                   bool executable);
  49 
  50   // Release parts of an already-reserved memory region [addr, addr + len) to
  51   // get a new region that has "compound alignment."  Return the start of the
  52   // resulting region, or NULL on failure.
  53   //
  54   // The region is logically divided into a prefix and a suffix.  The prefix
  55   // starts at the result address, which is aligned to prefix_align.  The suffix
  56   // starts at result address + prefix_size, which is aligned to suffix_align.
  57   // The total size of the result region is size prefix_size + suffix_size.
  58   char* align_reserved_region(char* addr, const size_t len,
  59                               const size_t prefix_size,
  60                               const size_t prefix_align,
  61                               const size_t suffix_size,
  62                               const size_t suffix_align);
  63 
  64   // Reserve memory, call align_reserved_region() to alignment it and return the
  65   // result.
  66   char* reserve_and_align(const size_t reserve_size,
  67                           const size_t prefix_size,
  68                           const size_t prefix_align,
  69                           const size_t suffix_size,
  70                           const size_t suffix_align);
  71 
  72  protected:
  73   // Create protection page at the beginning of the space.
  74   void protect_noaccess_prefix(const size_t size);
  75 
  76  public:
  77   // Constructor
  78   ReservedSpace(size_t size);
  79   ReservedSpace(size_t size, size_t alignment, bool large,
  80                 char* requested_address = NULL,
  81                 const size_t noaccess_prefix = 0);
  82   ReservedSpace(const size_t suffix_size, const size_t suffix_align,
  83                 char* requested_address,
  84                 const size_t noaccess_prefix = 0);
  85   ReservedSpace(size_t size, size_t alignment, bool large, bool executable);
  86 
  87   // Accessors
  88   char*  base()            const { return _base;      }
  89   size_t size()            const { return _size;      }
  90   size_t alignment()       const { return _alignment; }
  91   bool   special()         const { return _special;   }
  92   bool   executable()      const { return _executable;   }
  93   size_t noaccess_prefix() const { return _noaccess_prefix;   }
  94   bool is_reserved()       const { return _base != NULL; }
  95   void release();
  96 
  97   // Splitting
  98   ReservedSpace first_part(size_t partition_size, size_t alignment,
  99                            bool split = false, bool realloc = true);
 100   ReservedSpace last_part (size_t partition_size, size_t alignment);
 101 
 102   // These simply call the above using the default alignment.
 103   inline ReservedSpace first_part(size_t partition_size,
 104                                   bool split = false, bool realloc = true);
 105   inline ReservedSpace last_part (size_t partition_size);
 106 
 107   // Alignment
 108   static size_t page_align_size_up(size_t size);
 109   static size_t page_align_size_down(size_t size);
 110   static size_t allocation_align_size_up(size_t size);
 111   static size_t allocation_align_size_down(size_t size);
 112 };
 113 
 114 ReservedSpace
 115 ReservedSpace::first_part(size_t partition_size, bool split, bool realloc)
 116 {
 117   return first_part(partition_size, alignment(), split, realloc);
 118 }
 119 
 120 ReservedSpace ReservedSpace::last_part(size_t partition_size)
 121 {
 122   return last_part(partition_size, alignment());
 123 }
 124 
 125 // Class encapsulating behavior specific of memory space reserved for Java heap
 126 class ReservedHeapSpace : public ReservedSpace {
 127 public:
 128   // Constructor
 129   ReservedHeapSpace(size_t size, size_t forced_base_alignment,
 130                     bool large, char* requested_address);
 131   ReservedHeapSpace(const size_t prefix_size, const size_t prefix_align,
 132                     char* requested_address);
 133 };
 134 
 135 // Class encapsulating behavior specific memory space for Code
 136 class ReservedCodeSpace : public ReservedSpace {
 137  public:
 138   // Constructor
 139   ReservedCodeSpace(size_t r_size, size_t rs_align, bool large);
 140 };
 141 
 142 // VirtualSpace is data structure for committing a previously reserved address range in smaller chunks.
 143 
 144 class VirtualSpace VALUE_OBJ_CLASS_SPEC {
 145   friend class VMStructs;
 146  private:
 147   // Reserved area
 148   char* _low_boundary;
 149   char* _high_boundary;
 150 
 151   // Committed area
 152   char* _low;
 153   char* _high;
 154 
 155   // The entire space has been committed and pinned in memory, no
 156   // os::commit_memory() or os::uncommit_memory().
 157   bool _special;
 158 
 159   // Need to know if commit should be executable.
 160   bool   _executable;
 161 
 162   // MPSS Support
 163   // Each virtualspace region has a lower, middle, and upper region.
 164   // Each region has an end boundary and a high pointer which is the
 165   // high water mark for the last allocated byte.
 166   // The lower and upper unaligned to LargePageSizeInBytes uses default page.
 167   // size.  The middle region uses large page size.
 168   char* _lower_high;
 169   char* _middle_high;
 170   char* _upper_high;
 171 
 172   char* _lower_high_boundary;
 173   char* _middle_high_boundary;
 174   char* _upper_high_boundary;
 175 
 176   size_t _lower_alignment;
 177   size_t _middle_alignment;
 178   size_t _upper_alignment;
 179 
 180   // MPSS Accessors
 181   char* lower_high() const { return _lower_high; }
 182   char* middle_high() const { return _middle_high; }
 183   char* upper_high() const { return _upper_high; }
 184 
 185   char* lower_high_boundary() const { return _lower_high_boundary; }
 186   char* middle_high_boundary() const { return _middle_high_boundary; }
 187   char* upper_high_boundary() const { return _upper_high_boundary; }
 188 
 189   size_t lower_alignment() const { return _lower_alignment; }
 190   size_t middle_alignment() const { return _middle_alignment; }
 191   size_t upper_alignment() const { return _upper_alignment; }
 192 
 193  public:
 194   // Committed area
 195   char* low()  const { return _low; }
 196   char* high() const { return _high; }
 197 
 198   // Reserved area
 199   char* low_boundary()  const { return _low_boundary; }
 200   char* high_boundary() const { return _high_boundary; }
 201 
 202   bool special() const { return _special; }
 203 
 204  public:
 205   // Initialization
 206   VirtualSpace();
 207   bool initialize(ReservedSpace rs, size_t committed_byte_size);
 208 
 209   // Destruction
 210   ~VirtualSpace();
 211 
 212   // Testers (all sizes are byte sizes)
 213   size_t committed_size()   const;
 214   size_t reserved_size()    const;
 215   size_t uncommitted_size() const;
 216   bool   contains(const void* p)  const;
 217 
 218   // Operations
 219   // returns true on success, false otherwise
 220   bool expand_by(size_t bytes, bool pre_touch = false);
 221   void shrink_by(size_t bytes);
 222   void release();
 223 
 224   void check_for_contiguity() PRODUCT_RETURN;
 225 
 226   // Debugging
 227   void print() PRODUCT_RETURN;
 228 };
 229 
 230 #endif // SHARE_VM_RUNTIME_VIRTUALSPACE_HPP