Initial load

hotspot/src/share/vm/runtime/virtualspace.hpp

@@ -0,0 +1,190 @@
+/*
+ * Copyright 1997-2005 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// 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 _alignment;
+  bool   _special;
+
+  // ReservedSpace
+  ReservedSpace(char* base, size_t size, size_t alignment, bool special);
+  void initialize(size_t size, size_t alignment, bool large,
+                  char* requested_address = NULL);
+
+  // Release parts of an already-reserved memory region [addr, addr + len) to
+  // get a new region that has "compound alignment."  Return the start of the
+  // resulting region, or NULL on failure.
+  //
+  // The region is logically divided into a prefix and a suffix.  The prefix
+  // starts at the result address, which is aligned to prefix_align.  The suffix
+  // starts at result address + prefix_size, which is aligned to suffix_align.
+  // The total size of the result region is size prefix_size + suffix_size.
+  char* align_reserved_region(char* addr, const size_t len,
+                              const size_t prefix_size,
+                              const size_t prefix_align,
+                              const size_t suffix_size,
+                              const size_t suffix_align);
+
+  // Reserve memory, call align_reserved_region() to alignment it and return the
+  // result.
+  char* reserve_and_align(const size_t reserve_size,
+                          const size_t prefix_size,
+                          const size_t prefix_align,
+                          const size_t suffix_size,
+                          const size_t suffix_align);
+
+ public:
+  // Constructor
+  ReservedSpace(size_t size);
+  ReservedSpace(size_t size, size_t alignment, bool large,
+                char* requested_address = NULL);
+  ReservedSpace(const size_t prefix_size, const size_t prefix_align,
+                const size_t suffix_size, const size_t suffix_align);
+
+  // Accessors
+  char*  base()      const { return _base;      }
+  size_t size()      const { return _size;      }
+  size_t alignment() const { return _alignment; }
+  bool   special()   const { return _special;   }
+
+  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());
+}
+
+// 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;
+
+  // 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(ReservedSpace rs, size_t committed_byte_size);
+
+  // Destruction
+  ~VirtualSpace();
+
+  // Testers (all sizes are byte sizes)
+  size_t committed_size()   const;
+  size_t reserved_size()    const;
+  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() PRODUCT_RETURN;
+};