Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 #ifndef SHARE_VM_RUNTIME_VIRTUALSPACE_HPP

 #define SHARE_VM_RUNTIME_VIRTUALSPACE_HPP

 #include "memory/allocation.hpp"

 // ReservedSpace is a data structure for reserving a contiguous address range.

 class ReservedSpace VALUE_OBJ_CLASS_SPEC {

   friend class VMStructs;

  private:

   char*  _base;

   size_t _size;

   size_t _noaccess_prefix;

   size_t _alignment;

   bool   _special;

   bool   _executable;

   // ReservedSpace

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

                 bool executable);

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

                   char* requested_address,

                   const size_t noaccess_prefix,

                   bool executable);

  protected:

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

   void protect_noaccess_prefix(const size_t size);

  public:

   // Constructor

   ReservedSpace();

   // Initialize the reserved space with the given size. If preferred_page_size

   // is set, use this as minimum page size/alignment. This may waste some space

   // if the given size is not aligned to that value, as the reservation will be

   // aligned up to the final alignment in this case.

   ReservedSpace(size_t size, size_t preferred_page_size = 0);

   ReservedSpace(size_t size, size_t alignment, bool large,

                 char* requested_address = NULL,

                 const size_t noaccess_prefix = 0);

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

   // Accessors

   char*  base()            const { return _base;      }

   size_t size()            const { return _size;      }

   size_t alignment()       const { return _alignment; }

   bool   special()         const { return _special;   }

   bool   executable()      const { return _executable;   }

   size_t noaccess_prefix() const { return _noaccess_prefix;   }

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

   void release();

   // Splitting

   ReservedSpace first_part(size_t partition_size, size_t alignment,

                            bool split = false, bool realloc = true);

   ReservedSpace last_part (size_t partition_size, size_t alignment);

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

   inline ReservedSpace first_part(size_t partition_size,

                                   bool split = false, bool realloc = true);

   inline ReservedSpace last_part (size_t partition_size);

   // Alignment

   static size_t page_align_size_up(size_t size);

   static size_t page_align_size_down(size_t size);

   static size_t allocation_align_size_up(size_t size);

   static size_t allocation_align_size_down(size_t size);

 };

 ReservedSpace

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

 {

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

 }

 ReservedSpace ReservedSpace::last_part(size_t partition_size)

 {

   return last_part(partition_size, alignment());

 }

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

 class ReservedHeapSpace : public ReservedSpace {

 public:

   // Constructor

   ReservedHeapSpace(size_t size, size_t forced_base_alignment,

                     bool large, char* requested_address);

 };

 // Class encapsulating behavior specific memory space for Code

 class ReservedCodeSpace : public ReservedSpace {

  public:

   // Constructor

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

 };

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

 class VirtualSpace VALUE_OBJ_CLASS_SPEC {

   friend class VMStructs;

  private:

   // Reserved area

   char* _low_boundary;

   char* _high_boundary;

   // Committed area

   char* _low;

   char* _high;

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

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

   bool _special;

   // Need to know if commit should be executable.

   bool   _executable;

   // MPSS Support

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

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

   // high water mark for the last allocated byte.

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

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

   char* _lower_high;

   char* _middle_high;

   char* _upper_high;

   char* _lower_high_boundary;

   char* _middle_high_boundary;

   char* _upper_high_boundary;

   size_t _lower_alignment;

   size_t _middle_alignment;

   size_t _upper_alignment;

   // MPSS Accessors

   char* lower_high() const { return _lower_high; }

   char* middle_high() const { return _middle_high; }

   char* upper_high() const { return _upper_high; }

   char* lower_high_boundary() const { return _lower_high_boundary; }

   char* middle_high_boundary() const { return _middle_high_boundary; }

   char* upper_high_boundary() const { return _upper_high_boundary; }

   size_t lower_alignment() const { return _lower_alignment; }

   size_t middle_alignment() const { return _middle_alignment; }

   size_t upper_alignment() const { return _upper_alignment; }

  public:

   // Committed area

   char* low()  const { return _low; }

   char* high() const { return _high; }

   // Reserved area

   char* low_boundary()  const { return _low_boundary; }

   char* high_boundary() const { return _high_boundary; }

   bool special() const { return _special; }

  public:

   // Initialization

   VirtualSpace();

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

   bool initialize(ReservedSpace rs, size_t committed_byte_size);

   // Destruction

   ~VirtualSpace();

   // Reserved memory

   size_t reserved_size() const;

   // Actually committed OS memory

   size_t actual_committed_size() const;

   // Memory used/expanded in this virtual space

   size_t committed_size() const;

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

   size_t uncommitted_size() const;

   bool   contains(const void* p) const;

   // Operations

   // returns true on success, false otherwise

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

   void shrink_by(size_t bytes);

   void release();

   void check_for_contiguity() PRODUCT_RETURN;

   // Debugging

   void print_on(outputStream* out) PRODUCT_RETURN;

   void print();

 };

 #endif // SHARE_VM_RUNTIME_VIRTUALSPACE_HPP