< prev index next >

src/hotspot/share/memory/virtualspace.hpp

Print this page




  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   // Initialize the reserved space with the given size. If preferred_page_size
  55   // is set, use this as minimum page size/alignment. This may waste some space
  56   // if the given size is not aligned to that value, as the reservation will be
  57   // aligned up to the final alignment in this case.
  58   ReservedSpace(size_t size, size_t preferred_page_size = 0);
  59   ReservedSpace(size_t size, size_t alignment, bool large,


  98 }
  99 
 100 ReservedSpace ReservedSpace::last_part(size_t partition_size)
 101 {
 102   return last_part(partition_size, alignment());
 103 }
 104 
 105 // Class encapsulating behavior specific of memory space reserved for Java heap.
 106 class ReservedHeapSpace : public ReservedSpace {
 107  private:
 108   void try_reserve_heap(size_t size, size_t alignment, bool large,
 109                         char *requested_address);
 110   void try_reserve_range(char *highest_start, char *lowest_start,
 111                          size_t attach_point_alignment, char *aligned_HBMA,
 112                          char *upper_bound, size_t size, size_t alignment, bool large);
 113   void initialize_compressed_heap(const size_t size, size_t alignment, bool large);
 114   // Create protection page at the beginning of the space.
 115   void establish_noaccess_prefix();
 116  public:
 117   // Constructor. Tries to find a heap that is good for compressed oops.
 118   ReservedHeapSpace(size_t size, size_t forced_base_alignment, bool large);


 119   // Returns the base to be used for compression, i.e. so that null can be
 120   // encoded safely and implicit null checks can work.
 121   char *compressed_oop_base() { return _base - _noaccess_prefix; }
 122 };
 123 
 124 // Class encapsulating behavior specific memory space for Code
 125 class ReservedCodeSpace : public ReservedSpace {
 126  public:
 127   // Constructor
 128   ReservedCodeSpace(size_t r_size, size_t rs_align, bool large);
 129 };
 130 
 131 // VirtualSpace is data structure for committing a previously reserved address range in smaller chunks.
 132 
 133 class VirtualSpace VALUE_OBJ_CLASS_SPEC {
 134   friend class VMStructs;
 135  private:
 136   // Reserved area
 137   char* _low_boundary;
 138   char* _high_boundary;




  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   int    _fd_for_heap;
  41  private:
  42   bool   _executable;
  43 
  44   // ReservedSpace
  45   ReservedSpace(char* base, size_t size, size_t alignment, bool special,
  46                 bool executable);
  47  protected:
  48   void initialize(size_t size, size_t alignment, bool large,
  49                   char* requested_address,
  50                   bool executable);
  51 
  52  public:
  53   // Constructor
  54   ReservedSpace();
  55   // Initialize the reserved space with the given size. If preferred_page_size
  56   // is set, use this as minimum page size/alignment. This may waste some space
  57   // if the given size is not aligned to that value, as the reservation will be
  58   // aligned up to the final alignment in this case.
  59   ReservedSpace(size_t size, size_t preferred_page_size = 0);
  60   ReservedSpace(size_t size, size_t alignment, bool large,


  99 }
 100 
 101 ReservedSpace ReservedSpace::last_part(size_t partition_size)
 102 {
 103   return last_part(partition_size, alignment());
 104 }
 105 
 106 // Class encapsulating behavior specific of memory space reserved for Java heap.
 107 class ReservedHeapSpace : public ReservedSpace {
 108  private:
 109   void try_reserve_heap(size_t size, size_t alignment, bool large,
 110                         char *requested_address);
 111   void try_reserve_range(char *highest_start, char *lowest_start,
 112                          size_t attach_point_alignment, char *aligned_HBMA,
 113                          char *upper_bound, size_t size, size_t alignment, bool large);
 114   void initialize_compressed_heap(const size_t size, size_t alignment, bool large);
 115   // Create protection page at the beginning of the space.
 116   void establish_noaccess_prefix();
 117  public:
 118   // Constructor. Tries to find a heap that is good for compressed oops.
 119   // heap_allocation_directory is the path to the backing memory for Java heap. When set, Java heap will be allocated
 120   // on the device which is managed by the file system where the directory resides.
 121   ReservedHeapSpace(size_t size, size_t forced_base_alignment, bool large, const char* heap_allocation_directory = NULL);
 122   // Returns the base to be used for compression, i.e. so that null can be
 123   // encoded safely and implicit null checks can work.
 124   char *compressed_oop_base() { return _base - _noaccess_prefix; }
 125 };
 126 
 127 // Class encapsulating behavior specific memory space for Code
 128 class ReservedCodeSpace : public ReservedSpace {
 129  public:
 130   // Constructor
 131   ReservedCodeSpace(size_t r_size, size_t rs_align, bool large);
 132 };
 133 
 134 // VirtualSpace is data structure for committing a previously reserved address range in smaller chunks.
 135 
 136 class VirtualSpace VALUE_OBJ_CLASS_SPEC {
 137   friend class VMStructs;
 138  private:
 139   // Reserved area
 140   char* _low_boundary;
 141   char* _high_boundary;


< prev index next >