--- a/hotspot/src/os/linux/vm/os_linux.cpp Wed Apr 12 17:53:18 2017 +0200
+++ b/hotspot/src/os/linux/vm/os_linux.cpp Tue Jul 04 15:58:10 2017 +0200
@@ -578,7 +578,7 @@
// Adjust bottom to point to the largest address within the same page, it
// gives us a one-page buffer if alloca() allocates slightly more memory.
- bottom = (address)align_size_down((uintptr_t)bottom, os::Linux::page_size());
+ bottom = (address)align_down((uintptr_t)bottom, os::Linux::page_size());
bottom += os::Linux::page_size() - 1;
// sp might be slightly above current stack pointer; if that's the case, we
@@ -715,7 +715,7 @@
if (stack_size <= SIZE_MAX - guard_size) {
stack_size += guard_size;
}
- assert(is_size_aligned(stack_size, os::vm_page_size()), "stack_size not aligned");
+ assert(is_aligned(stack_size, os::vm_page_size()), "stack_size not aligned");
int status = pthread_attr_setstacksize(&attr, stack_size);
assert_status(status == 0, status, "pthread_attr_setstacksize");
@@ -1101,7 +1101,7 @@
}
// stack_top could be partially down the page so align it
- stack_top = align_size_up(stack_top, page_size());
+ stack_top = align_up(stack_top, page_size());
// Allowed stack value is minimum of max_size and what we derived from rlimit
if (max_size > 0) {
@@ -1111,7 +1111,7 @@
// clamp it at 8MB as we do on Solaris
_initial_thread_stack_size = MIN2(stack_size, 8*M);
}
- _initial_thread_stack_size = align_size_down(_initial_thread_stack_size, page_size());
+ _initial_thread_stack_size = align_down(_initial_thread_stack_size, page_size());
_initial_thread_stack_bottom = (address)stack_top - _initial_thread_stack_size;
assert(_initial_thread_stack_bottom < (address)stack_top, "overflow!");
@@ -3170,7 +3170,7 @@
start = NULL;
}
} else {
- char* const start_aligned = align_ptr_up(start, alignment);
+ char* const start_aligned = align_up(start, alignment);
char* const end_aligned = start_aligned + bytes;
char* const end = start + extra_size;
if (start_aligned > start) {
@@ -3200,7 +3200,7 @@
static bool linux_mprotect(char* addr, size_t size, int prot) {
// Linux wants the mprotect address argument to be page aligned.
- char* bottom = (char*)align_size_down((intptr_t)addr, os::Linux::page_size());
+ char* bottom = (char*)align_down((intptr_t)addr, os::Linux::page_size());
// According to SUSv3, mprotect() should only be used with mappings
// established by mmap(), and mmap() always maps whole pages. Unaligned
@@ -3209,7 +3209,7 @@
// caller if you hit this assert.
assert(addr == bottom, "sanity check");
- size = align_size_up(pointer_delta(addr, bottom, 1) + size, os::Linux::page_size());
+ size = align_up(pointer_delta(addr, bottom, 1) + size, os::Linux::page_size());
return ::mprotect(bottom, size, prot) == 0;
}
@@ -3244,7 +3244,7 @@
MAP_ANONYMOUS|MAP_PRIVATE,
-1, 0);
if (p != MAP_FAILED) {
- void *aligned_p = align_ptr_up(p, page_size);
+ void *aligned_p = align_up(p, page_size);
result = madvise(aligned_p, page_size, MADV_HUGEPAGE) == 0;
@@ -3487,9 +3487,9 @@
} while (0)
static char* shmat_with_alignment(int shmid, size_t bytes, size_t alignment) {
- assert(is_size_aligned(bytes, alignment), "Must be divisible by the alignment");
-
- if (!is_size_aligned(alignment, SHMLBA)) {
+ assert(is_aligned(bytes, alignment), "Must be divisible by the alignment");
+
+ if (!is_aligned(alignment, SHMLBA)) {
assert(false, "Code below assumes that alignment is at least SHMLBA aligned");
return NULL;
}
@@ -3525,7 +3525,7 @@
}
static char* shmat_at_address(int shmid, char* req_addr) {
- if (!is_ptr_aligned(req_addr, SHMLBA)) {
+ if (!is_aligned(req_addr, SHMLBA)) {
assert(false, "Requested address needs to be SHMLBA aligned");
return NULL;
}
@@ -3543,8 +3543,8 @@
static char* shmat_large_pages(int shmid, size_t bytes, size_t alignment, char* req_addr) {
// If a req_addr has been provided, we assume that the caller has already aligned the address.
if (req_addr != NULL) {
- assert(is_ptr_aligned(req_addr, os::large_page_size()), "Must be divisible by the large page size");
- assert(is_ptr_aligned(req_addr, alignment), "Must be divisible by given alignment");
+ assert(is_aligned(req_addr, os::large_page_size()), "Must be divisible by the large page size");
+ assert(is_aligned(req_addr, alignment), "Must be divisible by given alignment");
return shmat_at_address(shmid, req_addr);
}
@@ -3553,7 +3553,7 @@
// However, if the alignment is larger than the large page size, we have
// to manually ensure that the memory returned is 'alignment' aligned.
if (alignment > os::large_page_size()) {
- assert(is_size_aligned(alignment, os::large_page_size()), "Must be divisible by the large page size");
+ assert(is_aligned(alignment, os::large_page_size()), "Must be divisible by the large page size");
return shmat_with_alignment(shmid, bytes, alignment);
} else {
return shmat_at_address(shmid, NULL);
@@ -3565,10 +3565,10 @@
// "exec" is passed in but not used. Creating the shared image for
// the code cache doesn't have an SHM_X executable permission to check.
assert(UseLargePages && UseSHM, "only for SHM large pages");
- assert(is_ptr_aligned(req_addr, os::large_page_size()), "Unaligned address");
- assert(is_ptr_aligned(req_addr, alignment), "Unaligned address");
-
- if (!is_size_aligned(bytes, os::large_page_size())) {
+ assert(is_aligned(req_addr, os::large_page_size()), "Unaligned address");
+ assert(is_aligned(req_addr, alignment), "Unaligned address");
+
+ if (!is_aligned(bytes, os::large_page_size())) {
return NULL; // Fallback to small pages.
}
@@ -3627,8 +3627,8 @@
char* req_addr,
bool exec) {
assert(UseLargePages && UseHugeTLBFS, "only for Huge TLBFS large pages");
- assert(is_size_aligned(bytes, os::large_page_size()), "Unaligned size");
- assert(is_ptr_aligned(req_addr, os::large_page_size()), "Unaligned address");
+ assert(is_aligned(bytes, os::large_page_size()), "Unaligned size");
+ assert(is_aligned(req_addr, os::large_page_size()), "Unaligned address");
int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
char* addr = (char*)::mmap(req_addr, bytes, prot,
@@ -3640,7 +3640,7 @@
return NULL;
}
- assert(is_ptr_aligned(addr, os::large_page_size()), "Must be");
+ assert(is_aligned(addr, os::large_page_size()), "Must be");
return addr;
}
@@ -3659,8 +3659,8 @@
size_t large_page_size = os::large_page_size();
assert(bytes >= large_page_size, "Shouldn't allocate large pages for small sizes");
- assert(is_ptr_aligned(req_addr, alignment), "Must be");
- assert(is_size_aligned(bytes, alignment), "Must be");
+ assert(is_aligned(req_addr, alignment), "Must be");
+ assert(is_aligned(bytes, alignment), "Must be");
// First reserve - but not commit - the address range in small pages.
char* const start = anon_mmap_aligned(bytes, alignment, req_addr);
@@ -3669,17 +3669,17 @@
return NULL;
}
- assert(is_ptr_aligned(start, alignment), "Must be");
+ assert(is_aligned(start, alignment), "Must be");
char* end = start + bytes;
// Find the regions of the allocated chunk that can be promoted to large pages.
- char* lp_start = align_ptr_up(start, large_page_size);
- char* lp_end = align_ptr_down(end, large_page_size);
+ char* lp_start = align_up(start, large_page_size);
+ char* lp_end = align_down(end, large_page_size);
size_t lp_bytes = lp_end - lp_start;
- assert(is_size_aligned(lp_bytes, large_page_size), "Must be");
+ assert(is_aligned(lp_bytes, large_page_size), "Must be");
if (lp_bytes == 0) {
// The mapped region doesn't even span the start and the end of a large page.
@@ -3740,12 +3740,12 @@
char* req_addr,
bool exec) {
assert(UseLargePages && UseHugeTLBFS, "only for Huge TLBFS large pages");
- assert(is_ptr_aligned(req_addr, alignment), "Must be");
- assert(is_size_aligned(alignment, os::vm_allocation_granularity()), "Must be");
+ assert(is_aligned(req_addr, alignment), "Must be");
+ assert(is_aligned(alignment, os::vm_allocation_granularity()), "Must be");
assert(is_power_of_2(os::large_page_size()), "Must be");
assert(bytes >= os::large_page_size(), "Shouldn't allocate large pages for small sizes");
- if (is_size_aligned(bytes, os::large_page_size()) && alignment <= os::large_page_size()) {
+ if (is_aligned(bytes, os::large_page_size()) && alignment <= os::large_page_size()) {
return reserve_memory_special_huge_tlbfs_only(bytes, req_addr, exec);
} else {
return reserve_memory_special_huge_tlbfs_mixed(bytes, alignment, req_addr, exec);
@@ -5967,12 +5967,12 @@
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
- for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
+ for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, NULL, false);
test_log(SIZE_FORMAT_HEX " " SIZE_FORMAT_HEX " -> " PTR_FORMAT " %s",
size, alignment, p2i(p), (p != NULL ? "" : "(failed)"));
if (p != NULL) {
- assert(is_ptr_aligned(p, alignment), "must be");
+ assert(is_aligned(p, alignment), "must be");
small_page_write(p, size);
os::Linux::release_memory_special_huge_tlbfs(p, size);
}
@@ -5985,8 +5985,8 @@
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
- for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
- char* const req_addr = align_ptr_up(mapping1, alignment);
+ for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
+ char* const req_addr = align_up(mapping1, alignment);
char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
test_log(SIZE_FORMAT_HEX " " SIZE_FORMAT_HEX " " PTR_FORMAT " -> " PTR_FORMAT " %s",
size, alignment, p2i(req_addr), p2i(p),
@@ -6005,8 +6005,8 @@
for (int i = 0; i < num_sizes; i++) {
const size_t size = sizes[i];
- for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
- char* const req_addr = align_ptr_up(mapping2, alignment);
+ for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
+ char* const req_addr = align_up(mapping2, alignment);
char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
test_log(SIZE_FORMAT_HEX " " SIZE_FORMAT_HEX " " PTR_FORMAT " -> " PTR_FORMAT " %s",
size, alignment, p2i(req_addr), p2i(p), ((p != NULL ? "" : "(failed)")));
@@ -6039,8 +6039,8 @@
char* addr = os::Linux::reserve_memory_special_shm(size, alignment, NULL, false);
if (addr != NULL) {
- assert(is_ptr_aligned(addr, alignment), "Check");
- assert(is_ptr_aligned(addr, os::large_page_size()), "Check");
+ assert(is_aligned(addr, alignment), "Check");
+ assert(is_aligned(addr, os::large_page_size()), "Check");
small_page_write(addr, size);
@@ -6053,7 +6053,7 @@
size_t ag = os::vm_allocation_granularity();
for (size_t size = ag; size < lp * 3; size += ag) {
- for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
+ for (size_t alignment = ag; is_aligned(size, alignment); alignment *= 2) {
test_reserve_memory_special_shm(size, alignment);
}
}