1 /*

     2  * Copyright (c) 1997, 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_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  protected:

    35   char*  _base;

    36   size_t _size;

    37   size_t _noaccess_prefix;

    38   size_t _alignment;

    39   bool   _special;

    40  private:

    41   bool   _executable;

    42 

    43   // ReservedSpace

    44   ReservedSpace(char* base, size_t size, size_t alignment, bool special,

    45                 bool executable);

    46  protected:

    47   void initialize(size_t size, size_t alignment, bool large,

    48                   char* requested_address,

    49                   bool executable);

    50 

    51  public:

    52   // Constructor

    53   ReservedSpace();

    54   ReservedSpace(size_t size);

    55   ReservedSpace(size_t size, size_t alignment, bool large,

    56                 char* requested_address = NULL);

    57   ReservedSpace(size_t size, size_t alignment, bool large, bool executable);

    58 

    59   // Accessors

    60   char*  base()            const { return _base;      }

    61   size_t size()            const { return _size;      }

    62   size_t alignment()       const { return _alignment; }

    63   bool   special()         const { return _special;   }

    64   bool   executable()      const { return _executable;   }

    65   size_t noaccess_prefix() const { return _noaccess_prefix;   }

    66   bool is_reserved()       const { return _base != NULL; }

    67   void release();

    68 

    69   // Splitting

    70   ReservedSpace first_part(size_t partition_size, size_t alignment,

    71                            bool split = false, bool realloc = true);

    72   ReservedSpace last_part (size_t partition_size, size_t alignment);

    73 

    74   // These simply call the above using the default alignment.

    75   inline ReservedSpace first_part(size_t partition_size,

    76                                   bool split = false, bool realloc = true);

    77   inline ReservedSpace last_part (size_t partition_size);

    78 

    79   // Alignment

    80   static size_t page_align_size_up(size_t size);

    81   static size_t page_align_size_down(size_t size);

    82   static size_t allocation_align_size_up(size_t size);

    83   static size_t allocation_align_size_down(size_t size);

    84 };

    85 

    86 ReservedSpace

    87 ReservedSpace::first_part(size_t partition_size, bool split, bool realloc)

    88 {

    89   return first_part(partition_size, alignment(), split, realloc);

    90 }

    91 

    92 ReservedSpace ReservedSpace::last_part(size_t partition_size)

    93 {

    94   return last_part(partition_size, alignment());

    95 }

    96 

    97 // Class encapsulating behavior specific of memory space reserved for Java heap.

    98 class ReservedHeapSpace : public ReservedSpace {

    99  private:

   100   void try_reserve_heap(size_t size, size_t alignment, bool large,

   101                         char *requested_address);

   102   void try_reserve_range(char *highest_start, char *lowest_start,

   103                          size_t attach_point_alignment, char *aligned_HBMA,

   104                          char *upper_bound, size_t size, size_t alignment, bool large);

   105   void initialize_compressed_heap(const size_t size, size_t alignment, bool large);

   106   // Create protection page at the beginning of the space.

   107   void establish_noaccess_prefix();

   108  public:

   109   // Constructor. Tries to find a heap that is good for compressed oops.

   110   ReservedHeapSpace(size_t size, size_t forced_base_alignment, bool large);

   111   // Returns the base to be used for compression, i.e. so that null can be

   112   // encoded safely and implicit null checks can work.

   113   char *compressed_oop_base() { return _base - _noaccess_prefix; }

   114 };

   115 

   116 // Class encapsulating behavior specific memory space for Code

   117 class ReservedCodeSpace : public ReservedSpace {

   118  public:

   119   // Constructor

   120   ReservedCodeSpace(size_t r_size, size_t rs_align, bool large);

   121 };

   122 

   123 // VirtualSpace is data structure for committing a previously reserved address range in smaller chunks.

   124 

   125 class VirtualSpace VALUE_OBJ_CLASS_SPEC {

   126   friend class VMStructs;

   127  private:

   128   // Reserved area

   129   char* _low_boundary;

   130   char* _high_boundary;

   131 

   132   // Committed area

   133   char* _low;

   134   char* _high;

   135 

   136   // The entire space has been committed and pinned in memory, no

   137   // os::commit_memory() or os::uncommit_memory().

   138   bool _special;

   139 

   140   // Need to know if commit should be executable.

   141   bool   _executable;

   142 

   143   // MPSS Support

   144   // Each virtualspace region has a lower, middle, and upper region.

   145   // Each region has an end boundary and a high pointer which is the

   146   // high water mark for the last allocated byte.

   147   // The lower and upper unaligned to LargePageSizeInBytes uses default page.

   148   // size.  The middle region uses large page size.

   149   char* _lower_high;

   150   char* _middle_high;

   151   char* _upper_high;

   152 

   153   char* _lower_high_boundary;

   154   char* _middle_high_boundary;

   155   char* _upper_high_boundary;

   156 

   157   size_t _lower_alignment;

   158   size_t _middle_alignment;

   159   size_t _upper_alignment;

   160 

   161   // MPSS Accessors

   162   char* lower_high() const { return _lower_high; }

   163   char* middle_high() const { return _middle_high; }

   164   char* upper_high() const { return _upper_high; }

   165 

   166   char* lower_high_boundary() const { return _lower_high_boundary; }

   167   char* middle_high_boundary() const { return _middle_high_boundary; }

   168   char* upper_high_boundary() const { return _upper_high_boundary; }

   169 

   170   size_t lower_alignment() const { return _lower_alignment; }

   171   size_t middle_alignment() const { return _middle_alignment; }

   172   size_t upper_alignment() const { return _upper_alignment; }

   173 

   174  public:

   175   // Committed area

   176   char* low()  const { return _low; }

   177   char* high() const { return _high; }

   178 

   179   // Reserved area

   180   char* low_boundary()  const { return _low_boundary; }

   181   char* high_boundary() const { return _high_boundary; }

   182 

   183   bool special() const { return _special; }

   184 

   185  public:

   186   // Initialization

   187   VirtualSpace();

   188   bool initialize_with_granularity(ReservedSpace rs, size_t committed_byte_size, size_t max_commit_ganularity);

   189   bool initialize(ReservedSpace rs, size_t committed_byte_size);

   190 

   191   // Destruction

   192   ~VirtualSpace();

   193 

   194   // Reserved memory

   195   size_t reserved_size() const;

   196   // Actually committed OS memory

   197   size_t actual_committed_size() const;

   198   // Memory used/expanded in this virtual space

   199   size_t committed_size() const;

   200   // Memory left to use/expand in this virtual space

   201   size_t uncommitted_size() const;

   202 

   203   bool   contains(const void* p) const;

   204 

   205   // Operations

   206   // returns true on success, false otherwise

   207   bool expand_by(size_t bytes, bool pre_touch = false);

   208   void shrink_by(size_t bytes);

   209   void release();

   210 

   211   void check_for_contiguity() PRODUCT_RETURN;

   212 

   213   // Debugging

   214   void print_on(outputStream* out) PRODUCT_RETURN;

   215   void print();

   216 };

   217 

   218 #endif // SHARE_VM_RUNTIME_VIRTUALSPACE_HPP