graal-jvmci-8: src/os/linux/vm/os

comparison src/os/linux/vm/os_linux.cpp @ 12144:d8e99408faad

8009062: poor performance of JNI AttachCurrentThread after fix for 7017193 Summary: don't re-evaluate stack bounds for main thread before install guard page Reviewed-by: coleenp, dholmes, dlong

author	dsamersoff
date	Thu, 29 Aug 2013 21:48:23 +0400
parents	4c84d351cca9
children	bb57d48691f5

comparison

equal deleted inserted replaced

-:76482cbba706
+:d8e99408faad
 uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE,
 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0);
 return res  != (uintptr_t) MAP_FAILED;
 }
+static
+address get_stack_commited_bottom(address bottom, size_t size) {
+address nbot = bottom;
+address ntop = bottom + size;
+size_t page_sz = os::vm_page_size();
+unsigned pages = size / page_sz;
+unsigned char vec[1];
+unsigned imin = 1, imax = pages + 1, imid;
+int mincore_return_value;
+while (imin < imax) {
+imid = (imax + imin) / 2;
+nbot = ntop - (imid * page_sz);
+// Use a trick with mincore to check whether the page is mapped or not.
+// mincore sets vec to 1 if page resides in memory and to 0 if page
+// is swapped output but if page we are asking for is unmapped
+// it returns -1,ENOMEM
+mincore_return_value = mincore(nbot, page_sz, vec);
+if (mincore_return_value == -1) {
+// Page is not mapped go up
+// to find first mapped page
+if (errno != EAGAIN) {
+assert(errno == ENOMEM, "Unexpected mincore errno");
+imax = imid;
+}
+} else {
+// Page is mapped go down
+// to find first not mapped page
+imin = imid + 1;
+}
+}
+nbot = nbot + page_sz;
+// Adjust stack bottom one page up if last checked page is not mapped
+if (mincore_return_value == -1) {
+nbot = nbot + page_sz;
+}
+return nbot;
+}
 // Linux uses a growable mapping for the stack, and if the mapping for
 // the stack guard pages is not removed when we detach a thread the
 // stack cannot grow beyond the pages where the stack guard was
 // mapped.  If at some point later in the process the stack expands to
 // that point, the Linux kernel cannot expand the stack any further
 // so if the stack mapping has already grown beyond the guard pages at
 // the time we create them, we have to truncate the stack mapping.
 // So, we need to know the extent of the stack mapping when
 // create_stack_guard_pages() is called.
-// Find the bounds of the stack mapping.  Return true for success.
-//
 // We only need this for stacks that are growable: at the time of
 // writing thread stacks don't use growable mappings (i.e. those
 // creeated with MAP_GROWSDOWN), and aren't marked "[stack]", so this
 // only applies to the main thread.
-static
-bool get_stack_bounds(uintptr_t *bottom, uintptr_t *top) {
-char buf[128];
-int fd, sz;
-if ((fd = ::open("/proc/self/maps", O_RDONLY)) < 0) {
-return false;
-}
-const char kw[] = "[stack]";
-const int kwlen = sizeof(kw)-1;
-// Address part of /proc/self/maps couldn't be more than 128 bytes
-while ((sz = os::get_line_chars(fd, buf, sizeof(buf))) > 0) {
-if (sz > kwlen && ::memcmp(buf+sz-kwlen, kw, kwlen) == 0) {
-// Extract addresses
-if (sscanf(buf, "%" SCNxPTR "-%" SCNxPTR, bottom, top) == 2) {
-uintptr_t sp = (uintptr_t) __builtin_frame_address(0);
-if (sp >= *bottom && sp <= *top) {
-::close(fd);
-return true;
-}
-}
-}
-}
-::close(fd);
-return false;
-}
 // If the (growable) stack mapping already extends beyond the point
 // where we're going to put our guard pages, truncate the mapping at
 // that point by munmap()ping it.  This ensures that when we later
 // munmap() the guard pages we don't leave a hole in the stack
-// mapping. This only affects the main/initial thread, but guard
+// mapping. This only affects the main/initial thread
-// against future OS changes
 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
-uintptr_t stack_extent, stack_base;
-bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
+if (os::Linux::is_initial_thread()) {
-if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {
+// As we manually grow stack up to bottom inside create_attached_thread(),
-assert(os::Linux::is_initial_thread(),
+// it's likely that os::Linux::initial_thread_stack_bottom is mapped and
-"growable stack in non-initial thread");
+// we don't need to do anything special.
-if (stack_extent < (uintptr_t)addr)
+// Check it first, before calling heavy function.
-::munmap((void*)stack_extent, (uintptr_t)addr - stack_extent);
+uintptr_t stack_extent = (uintptr_t) os::Linux::initial_thread_stack_bottom();
+unsigned char vec[1];
+if (mincore((address)stack_extent, os::vm_page_size(), vec) == -1) {
+// Fallback to slow path on all errors, including EAGAIN
+stack_extent = (uintptr_t) get_stack_commited_bottom(
+os::Linux::initial_thread_stack_bottom(),
+(size_t)addr - stack_extent);
+}
+if (stack_extent < (uintptr_t)addr) {
+::munmap((void*)stack_extent, (uintptr_t)(addr - stack_extent));
+}
 }
 return os::commit_memory(addr, size, !ExecMem);
 }
 // If this is a growable mapping, remove the guard pages entirely by
 // munmap()ping them.  If not, just call uncommit_memory(). This only
 // affects the main/initial thread, but guard against future OS changes
+// It's safe to always unmap guard pages for initial thread because we
+// always place it right after end of the mapped region
 bool os::remove_stack_guard_pages(char* addr, size_t size) {
 uintptr_t stack_extent, stack_base;
-bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
-if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {
+if (os::Linux::is_initial_thread()) {
-assert(os::Linux::is_initial_thread(),
-"growable stack in non-initial thread");
 return ::munmap(addr, size) == 0;
 }
 return os::uncommit_memory(addr, size);
 }

Mercurial > hg > graal-jvmci-8

comparison src/os/linux/vm/os_linux.cpp @ 12144:d8e99408faad