diff options
Diffstat (limited to 'java/openjdk8')
5 files changed, 241 insertions, 5 deletions
diff --git a/java/openjdk8/Makefile b/java/openjdk8/Makefile index e4d143acb27f..12a1b0e8a96a 100644 --- a/java/openjdk8/Makefile +++ b/java/openjdk8/Makefile @@ -2,6 +2,7 @@ PORTNAME= openjdk PORTVERSION= ${JDK_MAJOR_VERSION}.${JDK_UPDATE_VERSION}.${JDK_BUILD_NUMBER:S/^0//} +PORTREVISION= 1 CATEGORIES= java devel MASTER_SITES= http://download.java.net/openjdk/jdk${JDK_MAJOR_VERSION}/promoted/b${DIST_BUILD_NUMBER}/:jdk \ https://adopt-openjdk.ci.cloudbees.com/job/jtreg/${JTREG_JENKINS_BUILD}/artifact/:jtreg \ diff --git a/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_globals__bsd.hpp b/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_globals__bsd.hpp new file mode 100644 index 000000000000..5449e002c8f2 --- /dev/null +++ b/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_globals__bsd.hpp @@ -0,0 +1,27 @@ +--- hotspot/src/os/bsd/vm/globals_bsd.hpp.orig 2014-03-04 02:52:13 UTC ++++ hotspot/src/os/bsd/vm/globals_bsd.hpp +@@ -35,19 +35,17 @@ + product(bool, UseBsdPosixThreadCPUClocks, true, \ + "enable fast Bsd Posix clocks where available") \ + /* NB: The default value of UseBsdPosixThreadCPUClocks may be \ +- overridden in Arguments::parse_each_vm_init_arg. */ \ +- \ +- product(bool, UseHugeTLBFS, false, \ +- "Use MAP_HUGETLB for large pages") \ +- \ +- product(bool, UseSHM, false, \ +- "Use SYSV shared memory for large pages") ++ overridden in Arguments::parse_each_vm_init_arg. */ + + // + // Defines Bsd-specific default values. The flags are available on all + // platforms, but they may have different default values on other platforms. + // ++#ifdef __FreeBSD__ ++define_pd_global(bool, UseLargePages, true); ++#else + define_pd_global(bool, UseLargePages, false); ++#endif + define_pd_global(bool, UseLargePagesIndividualAllocation, false); + define_pd_global(bool, UseOSErrorReporting, false); + define_pd_global(bool, UseThreadPriorities, true) ; diff --git a/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_os__bsd.cpp b/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_os__bsd.cpp index 54602f2b4dca..7991f1265b82 100644 --- a/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_os__bsd.cpp +++ b/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_os__bsd.cpp @@ -1,6 +1,6 @@ ---- hotspot/src/os/bsd/vm/os_bsd.cpp.orig 2014-03-04 02:52:13 UTC +--- hotspot/src/os/bsd/vm/os_bsd.cpp.orig 2017-12-01 00:32:02 UTC +++ hotspot/src/os/bsd/vm/os_bsd.cpp -@@ -1452,6 +1452,10 @@ void * os::dll_load(const char *filename, char *ebuf, +@@ -1588,6 +1588,10 @@ void * os::dll_load(const char *filename, char *ebuf, #define EM_X86_64 62 /* AMD x86-64 */ #endif @@ -11,7 +11,7 @@ static const arch_t arch_array[]={ {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, -@@ -1468,7 +1472,8 @@ void * os::dll_load(const char *filename, char *ebuf, +@@ -1604,7 +1608,8 @@ void * os::dll_load(const char *filename, char *ebuf, {EM_MIPS_RS3_LE, EM_MIPS_RS3_LE, ELFCLASS32, ELFDATA2LSB, (char*)"MIPSel"}, {EM_MIPS, EM_MIPS, ELFCLASS32, ELFDATA2MSB, (char*)"MIPS"}, {EM_PARISC, EM_PARISC, ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"}, @@ -21,7 +21,7 @@ }; #if (defined IA32) -@@ -1485,6 +1490,8 @@ void * os::dll_load(const char *filename, char *ebuf, +@@ -1621,6 +1626,8 @@ void * os::dll_load(const char *filename, char *ebuf, static Elf32_Half running_arch_code=EM_PPC64; #elif (defined __powerpc__) static Elf32_Half running_arch_code=EM_PPC; @@ -30,7 +30,7 @@ #elif (defined ARM) static Elf32_Half running_arch_code=EM_ARM; #elif (defined S390) -@@ -1501,7 +1508,7 @@ void * os::dll_load(const char *filename, char *ebuf, +@@ -1637,7 +1644,7 @@ void * os::dll_load(const char *filename, char *ebuf, static Elf32_Half running_arch_code=EM_68K; #else #error Method os::dll_load requires that one of following is defined:\ @@ -39,3 +39,188 @@ #endif // Identify compatability class for VM's architecture and library's architecture +@@ -2395,14 +2402,18 @@ static address _highest_vm_reserved_address = NULL; + // 'requested_addr' is only treated as a hint, the return value may or + // may not start from the requested address. Unlike Bsd mmap(), this + // function returns NULL to indicate failure. +-static char* anon_mmap(char* requested_addr, size_t bytes, bool fixed) { ++static char* anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed) { + char * addr; + int flags; + ++ assert(!(fixed && (alignment_hint > 0)), "alignment hint meaningless with fixed mmap"); ++ + flags = MAP_PRIVATE | MAP_ANONYMOUS; + if (fixed) { + assert((uintptr_t)requested_addr % os::Bsd::page_size() == 0, "unaligned address"); + flags |= MAP_FIXED; ++ } else if (alignment_hint > 0) { ++ flags |= MAP_ALIGNED(ffs(alignment_hint) - 1); + } + + // Map reserved/uncommitted pages PROT_NONE so we fail early if we +@@ -2434,7 +2445,7 @@ static int anon_munmap(char * addr, size_t size) { + + char* os::pd_reserve_memory(size_t bytes, char* requested_addr, + size_t alignment_hint) { +- return anon_mmap(requested_addr, bytes, (requested_addr != NULL)); ++ return anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL)); + } + + bool os::pd_release_memory(char* addr, size_t size) { +@@ -2480,19 +2491,93 @@ bool os::unguard_memory(char* addr, size_t size) { + return bsd_mprotect(addr, size, PROT_READ|PROT_WRITE); + } + +-bool os::Bsd::hugetlbfs_sanity_check(bool warn, size_t page_size) { +- return false; +-} +- + // Large page support + + static size_t _large_page_size = 0; + + void os::large_page_init() { ++ if (UseLargePages) { ++ // print a warning if any large page related flag is specified on command line ++ bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) || ++ !FLAG_IS_DEFAULT(LargePageSizeInBytes); ++ ++ UseLargePages = Bsd::superpage_sanity_check(warn_on_failure, &_large_page_size); ++ } + } + ++// Insertion sort for small arrays (descending order). ++static void insertion_sort_descending(size_t* array, int len) { ++ for (int i = 0; i < len; i++) { ++ size_t val = array[i]; ++ for (size_t key = i; key > 0 && array[key - 1] < val; --key) { ++ size_t tmp = array[key]; ++ array[key] = array[key - 1]; ++ array[key - 1] = tmp; ++ } ++ } ++} + ++bool os::Bsd::superpage_sanity_check(bool warn, size_t* page_size) { ++#ifdef __FreeBSD__ ++ const unsigned int usable_count = VM_Version::page_size_count(); ++ if (usable_count == 1) { ++ return false; ++ } ++ ++ // Fill the array of page sizes. ++ int n = ::getpagesizes(_page_sizes, page_sizes_max); ++ assert(n > 0, "FreeBSD bug?"); ++ ++ if (n == page_sizes_max) { ++ // Add a sentinel value (necessary only if the array was completely filled ++ // since it is static (zeroed at initialization)). ++ _page_sizes[--n] = 0; ++ DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");) ++ } ++ assert(_page_sizes[n] == 0, "missing sentinel"); ++ trace_page_sizes("available page sizes", _page_sizes, n); ++ ++ if (n == 1) return false; // Only one page size available. ++ ++ // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and ++ // select up to usable_count elements. First sort the array, find the first ++ // acceptable value, then copy the usable sizes to the top of the array and ++ // trim the rest. Make sure to include the default page size :-). ++ // ++ // A better policy could get rid of the 4M limit by taking the sizes of the ++ // important VM memory regions (java heap and possibly the code cache) into ++ // account. ++ insertion_sort_descending(_page_sizes, n); ++ const size_t size_limit = ++ FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes; ++ int beg; ++ for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */ ; ++ const int end = MIN2((int)usable_count, n) - 1; ++ for (int cur = 0; cur < end; ++cur, ++beg) { ++ _page_sizes[cur] = _page_sizes[beg]; ++ } ++ _page_sizes[end] = vm_page_size(); ++ _page_sizes[end + 1] = 0; ++ ++ if (_page_sizes[end] > _page_sizes[end - 1]) { ++ // Default page size is not the smallest; sort again. ++ insertion_sort_descending(_page_sizes, end + 1); ++ } ++ *page_size = _page_sizes[0]; ++ ++ trace_page_sizes("usable page sizes", _page_sizes, end + 1); ++ return true; ++#else ++ return false; ++#endif ++} ++ ++ + char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) { ++#ifdef __FreeBSD__ ++ fatal("os::reserve_memory_special should not be called on FreeBSD."); ++ return NULL; ++#else + fatal("This code is not used or maintained."); + + // "exec" is passed in but not used. Creating the shared image for +@@ -2552,9 +2637,14 @@ char* os::reserve_memory_special(size_t bytes, size_t + MemTracker::record_virtual_memory_reserve_and_commit((address)addr, bytes, CALLER_PC); + + return addr; ++#endif + } + + bool os::release_memory_special(char* base, size_t bytes) { ++#ifdef __FreeBSD__ ++ fatal("os::release_memory_special should not be called on FreeBSD."); ++ return false; ++#else + if (MemTracker::tracking_level() > NMT_minimal) { + Tracker tkr = MemTracker::get_virtual_memory_release_tracker(); + // detaching the SHM segment will also delete it, see reserve_memory_special() +@@ -2568,21 +2658,28 @@ bool os::release_memory_special(char* base, size_t byt + } else { + return shmdt(base) == 0; + } ++#endif + } + + size_t os::large_page_size() { + return _large_page_size; + } + +-// HugeTLBFS allows application to commit large page memory on demand; +-// with SysV SHM the entire memory region must be allocated as shared +-// memory. ++// FreeBSD allows application to commit large page memory on demand. + bool os::can_commit_large_page_memory() { +- return UseHugeTLBFS; ++#ifdef __FreeBSD__ ++ return true; ++#else ++ return false; ++#endif + } + + bool os::can_execute_large_page_memory() { +- return UseHugeTLBFS; ++#ifdef __FreeBSD__ ++ return true; ++#else ++ return false; ++#endif + } + + // Reserve memory at an arbitrary address, only if that area is +@@ -2614,7 +2711,7 @@ char* os::pd_attempt_reserve_memory_at(size_t bytes, c + + // Bsd mmap allows caller to pass an address as hint; give it a try first, + // if kernel honors the hint then we can return immediately. +- char * addr = anon_mmap(requested_addr, bytes, false); ++ char * addr = anon_mmap(requested_addr, bytes, 0, false); + if (addr == requested_addr) { + return requested_addr; + } diff --git a/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_os__bsd.hpp b/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_os__bsd.hpp new file mode 100644 index 000000000000..1f513305cc5b --- /dev/null +++ b/java/openjdk8/files/patch-hotspot_src_os_bsd_vm_os__bsd.hpp @@ -0,0 +1,11 @@ +--- hotspot/src/os/bsd/vm/os_bsd.hpp.orig 2017-12-01 00:32:02 UTC ++++ hotspot/src/os/bsd/vm/os_bsd.hpp +@@ -87,7 +87,7 @@ class Bsd { + static void rebuild_cpu_to_node_map(); + static GrowableArray<int>* cpu_to_node() { return _cpu_to_node; } + +- static bool hugetlbfs_sanity_check(bool warn, size_t page_size); ++ static bool superpage_sanity_check(bool warn, size_t *page_size); + + public: + diff --git a/java/openjdk8/files/patch-hotspot_src_share_vm_runtime_arguments.cpp b/java/openjdk8/files/patch-hotspot_src_share_vm_runtime_arguments.cpp new file mode 100644 index 000000000000..a437f8fccb42 --- /dev/null +++ b/java/openjdk8/files/patch-hotspot_src_share_vm_runtime_arguments.cpp @@ -0,0 +1,12 @@ +--- hotspot/src/share/vm/runtime/arguments.cpp.orig 2017-12-01 00:32:02.284351000 +0000 ++++ hotspot/src/share/vm/runtime/arguments.cpp 2017-12-01 00:38:48.362549000 +0000 +@@ -3974,7 +3974,8 @@ jint Arguments::parse(const JavaVMInitArgs* args) { + hotspotrc, hotspotrc); + } + +-#ifdef _ALLBSD_SOURCE // UseLargePages is not yet supported on BSD. ++#if defined(_ALLBSD_SOURCE) && !defined(__FreeBSD__) ++ // UseLargePages is not yet supported on BSD. + UNSUPPORTED_OPTION(UseLargePages, "-XX:+UseLargePages"); + #endif + |