--- /dev/null	2019-09-30 10:03:02.736928411 -0700
+++ new/src/hotspot/share/gc/g1/g1NUMA.cpp	2019-09-30 17:13:30.828028714 -0700
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2019, 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.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc/g1/g1CollectedHeap.inline.hpp"
+#include "gc/g1/g1NUMA.inline.hpp"
+#include "runtime/os.hpp"
+
+G1NUMA* G1NUMA::_inst = NULL;
+
+void G1NUMA::init_numa_id_to_index_map(const int* numa_ids, uint num_numa_ids) {
+  int max_numa_id = 0;
+  for (uint i = 0; i < num_numa_ids; i++) {
+    if (numa_ids[i] > max_numa_id) {
+      max_numa_id = numa_ids[i];
+    }
+  }
+
+  _len_numa_id_to_index_map = max_numa_id + 1;
+  _numa_id_to_index_map = NEW_C_HEAP_ARRAY(uint, _len_numa_id_to_index_map, mtGC);
+  // Set all indices with invalid numa id.
+  for (int i = 0; i < _len_numa_id_to_index_map; i++) {
+    _numa_id_to_index_map[i] = G1MemoryNodeManager::InvalidNodeIndex;
+  }
+
+  // Set the indices for the actually retrieved numa ids.
+  for (uint i = 0; i < num_numa_ids; i++) {
+    int numa_id = numa_ids[i];
+    guarantee(is_valid_numa_id(numa_id), "must be representable in map, numa id(%d)", numa_id);
+    _numa_id_to_index_map[numa_id] = i;
+  }
+}
+
+// Request the given memory to locate on preferred node.
+// There are 2 things to consider.
+// First, size comparison for G1HeapRegionSize and page size.
+// Second, the memory is assumed to be evenly split. As the preferred id will be
+// decided in round-robin manner, we can know the numa id from address or even
+// from HeapRegion index. 
+//
+// Examples of 4 numa ids with non-preferred numa id.
+//   1. G1HeapRegionSize is larger than or equal to page size.
+//      * Page size:             |-0--||-1--||-2--||-3--||-4--||-5--||-6--||-7--||-8--||-9--||-10-||-11-||-12-||-13-||-14-||-15-|
+//      * G1HeapRegionSize:      |----#0----||----#1----||----#2----||----#3----||----#4----||----#5----||----#6----||----#7----|
+//   2. G1HeapRegionSize is smaller than page size.
+//      Memory will be touched one page at a time because G1RegionToSpaceMapper commits
+//      pages one by one.
+//      * Page size:             |-----0----||-----1----||-----2----||-----3----||-----4----||-----5----||-----6----||-----7----|
+//      * G1HeapRegionSize:      |-#0-||-#1-||-#2-||-#3-||-#4-||-#5-||-#6-||-#7-||-#8-||-#9-||#10-||#11-||#12-||#13-||#14-||#15-|
+void G1NUMA::request_memory_on_node(address aligned_address, size_t size_in_bytes) {
+  assert(is_aligned(aligned_address, _page_size), "Given address (" PTR_FORMAT ") should be aligned.", p2i(aligned_address));
+  assert(is_aligned(size_in_bytes, _page_size), "Given size (" SIZE_FORMAT ") should be aligned.", size_in_bytes);
+
+  if (size_in_bytes == 0) {
+    return;
+  }
+
+  // If we don't have preferred numa id, touch the given area with round-robin manner.
+  size_t chunk_size;
+  if (HeapRegion::GrainBytes >= _page_size) {
+    chunk_size = HeapRegion::GrainBytes;
+  } else {
+    chunk_size = _page_size;
+  }
+
+  assert(is_aligned(size_in_bytes, chunk_size), "Size to touch " SIZE_FORMAT " should be aligned to " SIZE_FORMAT,
+         size_in_bytes, chunk_size);
+
+  address start_addr = aligned_address;
+  address end_addr = aligned_address + size_in_bytes;
+
+  log_debug(gc, heap, numa)("Request memory [" PTR_FORMAT ", " PTR_FORMAT
+                            "), chunk_size=" SIZE_FORMAT "KB with round-robin manner.",
+                            p2i(start_addr), p2i(end_addr), chunk_size / K);
+
+  do {
+    // Numa id of each HeapRegion is decided.
+    uint numa_index = preferred_index_for_address((HeapWord*)start_addr);
+
+    log_trace(gc, heap, numa)("Request memory [" PTR_FORMAT ", " PTR_FORMAT ") to be numa id (%d).",
+                             p2i(start_addr), p2i(start_addr + chunk_size), _numa_ids[numa_index]);
+    os::numa_make_local((char*)start_addr, chunk_size, _numa_ids[numa_index]);
+
+    start_addr += chunk_size;
+  } while (start_addr < end_addr);
+}
+
+bool G1NUMA::initialize() {
+  assert(UseNUMA, "Invariant");
+
+  size_t num_numa_ids = os::numa_get_groups_num();
+
+  _numa_ids = NEW_C_HEAP_ARRAY(int, num_numa_ids, mtGC);
+  _num_active_numa_ids = (uint)os::numa_get_leaf_groups(_numa_ids, num_numa_ids);
+
+  init_numa_id_to_index_map(_numa_ids, _num_active_numa_ids);
+
+  return true;
+}
+
+uint G1NUMA::index_of_current_thread() const {
+  int numa_id = os::numa_get_group_id();
+  return index_of_numa_id(numa_id);
+}
+
+void G1NUMA::set_page_size(size_t page_size) {
+  _page_size = page_size;
+}
+
+G1NUMA::~G1NUMA() {
+  FREE_C_HEAP_ARRAY(int, _numa_id_to_index_map);
+  FREE_C_HEAP_ARRAY(int, _numa_ids);
+  _inst = NULL;
+}
+
+uint G1NUMA::preferred_index_for_address(HeapWord* address) const {
+  uint region_index = G1CollectedHeap::heap()->addr_to_region(address);
+  if (HeapRegion::GrainBytes >= _page_size) {
+    // Simple case, pages are smaller than the region so we
+    // can just alternate over the nodes.
+    return region_index % _num_active_numa_ids;
+  } else {
+    // Multiple regions in one page, so we need to make sure the
+    // regions within a page is preferred on the same node.
+    size_t regions_per_page = _page_size / HeapRegion::GrainBytes;
+    return (region_index / regions_per_page) % _num_active_numa_ids;
+  }
+}
+
+uint G1NUMA::index_of_address(HeapWord* address) const {
+    int numa_id = os::numa_get_address_id((uintptr_t)address);
+    return index_of_numa_id(numa_id);
+}