--- old/src/hotspot/share/memory/virtualspace.cpp	2018-06-14 13:48:27.556000000 -0700
+++ new/src/hotspot/share/memory/virtualspace.cpp	2018-06-14 13:48:27.396000000 -0700
@@ -35,13 +35,11 @@
 // ReservedSpace
 
 // Dummy constructor
-ReservedSpace::ReservedSpace() : _base(NULL), _size(0), _noaccess_prefix(0), 
-    _nvdimm_base_nv(NULL), _nvdimm_size(0), _dram_size(0),
+ReservedSpace::ReservedSpace() : _base(NULL), _size(0), _noaccess_prefix(0),
     _alignment(0), _special(false), _executable(false), _fd_for_heap(-1) {
 }
 
-ReservedSpace::ReservedSpace(size_t size, size_t preferred_page_size) : _fd_for_heap(-1), 
-    _nvdimm_base_nv(NULL), _nvdimm_size(0), _dram_size(0) {
+ReservedSpace::ReservedSpace(size_t size, size_t preferred_page_size) : _fd_for_heap(-1) {
   bool has_preferred_page_size = preferred_page_size != 0;
   // Want to use large pages where possible and pad with small pages.
   size_t page_size = has_preferred_page_size ? preferred_page_size : os::page_size_for_region_unaligned(size, 1);
@@ -62,15 +60,13 @@
 
 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
                              bool large,
-                             char* requested_address) : _fd_for_heap(-1), 
-                             _nvdimm_base_nv(NULL), _nvdimm_size(0), _dram_size(0) {
+                             char* requested_address) : _fd_for_heap(-1) {
   initialize(size, alignment, large, requested_address, false);
 }
 
 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
                              bool large,
-                             bool executable) : _fd_for_heap(-1), 
-                             _nvdimm_base_nv(NULL), _nvdimm_size(0), _dram_size(0) {
+                             bool executable) : _fd_for_heap(-1) {
   initialize(size, alignment, large, NULL, executable);
 }
 
@@ -147,7 +143,6 @@
   }
 
   char* base = NULL;
-  char* nvdimm_base = NULL;
 
   if (special) {
 
@@ -172,11 +167,7 @@
       }
     }
   }
-  int fd = -1;
-  if (AllocateOldGenAt == NULL && _fd_for_heap != -1) {
-    // AllocateHeapAt is in use.
-    fd = _fd_for_heap;
-  }
+
   if (base == NULL) {
     // Optimistically assume that the OSes returns an aligned base pointer.
     // When reserving a large address range, most OSes seem to align to at
@@ -187,17 +178,13 @@
     // important.  If available space is not detected, return NULL.
 
     if (requested_address != 0) {
-      base = os::attempt_reserve_memory_at(size, requested_address, fd);
-      if (failed_to_reserve_as_requested(base, requested_address, size, false, fd != -1)) {
+      base = os::attempt_reserve_memory_at(size, requested_address, _fd_for_heap);
+      if (failed_to_reserve_as_requested(base, requested_address, size, false, _fd_for_heap != -1)) {
         // OS ignored requested address. Try different address.
         base = NULL;
       }
     } else {
-      if (_nvdimm_base_nv != NULL && _fd_for_heap != -1) {
-        base = os::reserve_memory(_dram_size, _nvdimm_base_nv, alignment, fd);
-      } else {
-        base = os::reserve_memory(size, NULL, alignment, fd);
-      }
+      base = os::reserve_memory(size, NULL, alignment, _fd_for_heap);
     }
 
     if (base == NULL) return;
@@ -205,14 +192,14 @@
     // Check alignment constraints
     if ((((size_t)base) & (alignment - 1)) != 0) {
       // Base not aligned, retry
-      unmap_or_release_memory(base, size, fd != -1 /*is_file_mapped*/);
+      unmap_or_release_memory(base, size, _fd_for_heap != -1 /*is_file_mapped*/);
 
       // Make sure that size is aligned
       size = align_up(size, alignment);
-      base = os::reserve_memory_aligned(size, alignment, fd);
+      base = os::reserve_memory_aligned(size, alignment, _fd_for_heap);
 
       if (requested_address != 0 &&
-          failed_to_reserve_as_requested(base, requested_address, size, false, fd != -1)) {
+          failed_to_reserve_as_requested(base, requested_address, size, false, _fd_for_heap != -1)) {
         // As a result of the alignment constraints, the allocated base differs
         // from the requested address. Return back to the caller who can
         // take remedial action (like try again without a requested address).
@@ -223,13 +210,10 @@
   }
   // Done
   _base = base;
-  _nvdimm_base = _base-_nvdimm_size;
-  _nvdimm_base_nv = NULL;
-  _dram_size = (size_t)size;
   _size = size;
   _alignment = alignment;
   // If heap is reserved with a backing file, the entire space has been committed. So set the _special flag to true
-  if (fd != -1) {
+  if (_fd_for_heap != -1 && AllocateOldGenAt == NULL) {
     _special = true;
   }
 }
@@ -241,15 +225,13 @@
          "size not allocation aligned");
   _base = base;
   _size = size;
-  _nvdimm_base = NULL; 
-  _nvdimm_base_nv = NULL;
-  _dram_size = (size_t)size;
   _alignment = alignment;
   _noaccess_prefix = 0;
   _special = special;
   _executable = executable;
 }
 
+
 ReservedSpace ReservedSpace::first_part(size_t partition_size, size_t alignment,
                                         bool split, bool realloc) {
   assert(partition_size <= size(), "partition failed");
@@ -295,10 +277,6 @@
   if (is_reserved()) {
     char *real_base = _base - _noaccess_prefix;
     const size_t real_size = _size + _noaccess_prefix;
-    // unmap nvdimm
-    if (_nvdimm_base != NULL) {
-      os::unmap_memory(_nvdimm_base, _nvdimm_size);
-    }
     if (special()) {
       if (_fd_for_heap != -1) {
         os::unmap_memory(real_base, real_size);
@@ -309,10 +287,6 @@
       os::release_memory(real_base, real_size);
     }
     _base = NULL;
-    _nvdimm_base = NULL;
-    _nvdimm_base_nv = NULL;
-    _dram_size = 0;
-    _nvdimm_size = 0;
     _size = 0;
     _noaccess_prefix = 0;
     _alignment = 0;
@@ -347,7 +321,6 @@
       Universe::set_narrow_oop_use_implicit_null_checks(false);
     }
   }
-
   _base += _noaccess_prefix;
   _size -= _noaccess_prefix;
   assert(((uintptr_t)_base % _alignment == 0), "must be exactly of required alignment");
@@ -367,13 +340,6 @@
     release();
   }
 
-  if (_fd_for_heap != -1 && UseG1GC && AllocateOldGenAt != NULL) {
-    char* base_nv = os::reserve_memory(size, requested_address, alignment);
-    initialize_g1gc_nvdimm_dram_sizes(size, alignment);
-    _nvdimm_base_nv = base_nv+_nvdimm_size; // hint for allocation address of DRAM COMPRESSED HEAP.
-  }
-
-  
   // If OS doesn't support demand paging for large page memory, we need
   // to use reserve_memory_special() to reserve and pin the entire region.
   // If there is a backing file directory for this space then whether
@@ -388,7 +354,6 @@
     }
   }
   char* base = NULL;
-  char* nvdimm_base = NULL;
 
   log_trace(gc, heap, coops)("Trying to allocate at address " PTR_FORMAT
                              " heap of size " SIZE_FORMAT_HEX,
@@ -424,33 +389,16 @@
     // important.  If available space is not detected, return NULL.
 
     if (requested_address != 0) {
-      if (_nvdimm_base_nv != NULL && _fd_for_heap != -1 && AllocateOldGenAt != NULL) {
-        // first unmap so that OS does not keep trying.
-        os::unmap_memory(_nvdimm_base_nv, _dram_size);
-        base = os::attempt_reserve_memory_at(_dram_size, _nvdimm_base_nv);
-      } else {
-        base = os::attempt_reserve_memory_at(size, requested_address, _fd_for_heap);
-      }
+      base = os::attempt_reserve_memory_at(size, requested_address, _fd_for_heap);
     } else {
-      if (_nvdimm_base_nv != NULL && _fd_for_heap != -1 && AllocateOldGenAt != NULL) {
-        // first unmap so that OS does not keep trying.
-        os::unmap_memory(_nvdimm_base_nv, _dram_size);
-        base = os::reserve_memory(_dram_size, _nvdimm_base_nv, alignment);
-      } else {
-        base = os::reserve_memory(size, NULL, alignment, _fd_for_heap);
-      }
+      base = os::reserve_memory(size, NULL, alignment, _fd_for_heap);
     }
   }
   if (base == NULL) { return; }
 
   // Done
   _base = base;
-  _nvdimm_base = _base-_nvdimm_size;
-  if (_nvdimm_base_nv != NULL && _fd_for_heap != -1 && AllocateOldGenAt != NULL) {
-    _size = _dram_size;
-  } else {
-    _size = size;
-  }
+  _size = size;
   _alignment = alignment;
 
   // If heap is reserved with a backing file, the entire space has been committed. So set the _special flag to true
@@ -652,24 +600,13 @@
   }
 }
 
-void ReservedHeapSpace::initialize_g1gc_nvdimm_dram_sizes(size_t size, size_t alignment) {
-  _dram_size = (size_t)((size * G1MaxNewSizePercent)/100);
-  size_t page_sz = os::vm_page_size() -1 ;
-  _dram_size = (_dram_size + page_sz) & (~page_sz);
-  // align sizes.
-  _dram_size = align_down(_dram_size, alignment);
-  _nvdimm_size = size - _dram_size;
-  _nvdimm_size = (_nvdimm_size + page_sz) & (~page_sz);
-  _nvdimm_size = align_down(_nvdimm_size, alignment);
-}
-
 ReservedHeapSpace::ReservedHeapSpace(size_t size, size_t alignment, bool large, const char* heap_allocation_directory) : ReservedSpace() {
 
   if (size == 0) {
     return;
   }
 
-  // if AllocateOldGen is used  
+  // Open AllocateOldGenAt file
   if (AllocateOldGenAt != NULL) {
     _fd_for_heap = os::create_file_for_heap(AllocateOldGenAt);
     if (_fd_for_heap== -1) {
@@ -698,18 +635,6 @@
   // Heap size should be aligned to alignment, too.
   guarantee(is_aligned(size, alignment), "set by caller");
 
-  char* base_nv = NULL;
-  _nvdimm_base_nv = NULL;
-  
-  if (_fd_for_heap != -1 && UseG1GC && AllocateOldGenAt != NULL) {
-    if (!UseCompressedOops) {
-      // if compressed oops use requested address.
-      initialize_g1gc_nvdimm_dram_sizes(size, alignment);
-      base_nv = os::reserve_memory(size, NULL, alignment);
-      _nvdimm_base_nv = base_nv+_nvdimm_size; // hint for allocation address of DRAM heap
-    }
-  }
-
   if (UseCompressedOops) {
     initialize_compressed_heap(size, alignment, large);
     if (_size > size) {
@@ -719,11 +644,7 @@
       establish_noaccess_prefix();
     }
   } else {
-    if (_fd_for_heap != -1 && UseG1GC && AllocateOldGenAt != NULL) {
-      initialize(_dram_size, alignment, large, NULL, false);
-    } else {
-      initialize(size, alignment, large, NULL, false);
-    }
+    initialize(size, alignment, large, NULL, false);
   }
 
   assert(markOopDesc::encode_pointer_as_mark(_base)->decode_pointer() == _base,
@@ -733,14 +654,10 @@
 
   if (base() != NULL) {
     MemTracker::record_virtual_memory_type((address)base(), mtJavaHeap);
-    if (_fd_for_heap != -1 && UseG1GC && AllocateOldGenAt != NULL) {
+    if (AllocateOldGenAt != NULL && _fd_for_heap != -1) {
       os::set_nvdimm_present(true);
-      os::set_dram_heapbase((address)_base);
-      os::set_nvdimm_heapbase((address)_nvdimm_base);
+      os::set_nvdimm_heapbase((address)_base);
       os::set_nvdimm_fd(_fd_for_heap);
-      _size += _nvdimm_size;
-      _base = _nvdimm_base;
-      log_info(gc, heap)("Java DRAM Heap at [%p - %p] & NVDIMM Old Gen at [%p - %p] %ld \n", _nvdimm_base+_nvdimm_size, (char*)(_nvdimm_base+_nvdimm_size+_dram_size), _nvdimm_base, (char*)(_nvdimm_base+_nvdimm_size), size);
     }
   }