2463 uintptr_t res = (uintptr_t) ::mmap(addr, size, prot, |
2463 uintptr_t res = (uintptr_t) ::mmap(addr, size, prot, |
2464 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0); |
2464 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0); |
2465 return res != (uintptr_t) MAP_FAILED; |
2465 return res != (uintptr_t) MAP_FAILED; |
2466 } |
2466 } |
2467 |
2467 |
|
2468 // Define MAP_HUGETLB here so we can build HotSpot on old systems. |
|
2469 #ifndef MAP_HUGETLB |
|
2470 #define MAP_HUGETLB 0x40000 |
|
2471 #endif |
|
2472 |
|
2473 // Define MADV_HUGEPAGE here so we can build HotSpot on old systems. |
|
2474 #ifndef MADV_HUGEPAGE |
|
2475 #define MADV_HUGEPAGE 14 |
|
2476 #endif |
|
2477 |
2468 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, |
2478 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, |
2469 bool exec) { |
2479 bool exec) { |
|
2480 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) { |
|
2481 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; |
|
2482 uintptr_t res = |
|
2483 (uintptr_t) ::mmap(addr, size, prot, |
|
2484 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS|MAP_HUGETLB, |
|
2485 -1, 0); |
|
2486 return res != (uintptr_t) MAP_FAILED; |
|
2487 } |
|
2488 |
2470 return commit_memory(addr, size, exec); |
2489 return commit_memory(addr, size, exec); |
2471 } |
2490 } |
2472 |
2491 |
2473 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } |
2492 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { |
|
2493 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) { |
|
2494 // We don't check the return value: madvise(MADV_HUGEPAGE) may not |
|
2495 // be supported or the memory may already be backed by huge pages. |
|
2496 ::madvise(addr, bytes, MADV_HUGEPAGE); |
|
2497 } |
|
2498 } |
2474 |
2499 |
2475 void os::free_memory(char *addr, size_t bytes) { |
2500 void os::free_memory(char *addr, size_t bytes) { |
2476 ::mmap(addr, bytes, PROT_READ | PROT_WRITE, |
2501 ::madvise(addr, bytes, MADV_DONTNEED); |
2477 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0); |
|
2478 } |
2502 } |
2479 |
2503 |
2480 void os::numa_make_global(char *addr, size_t bytes) { |
2504 void os::numa_make_global(char *addr, size_t bytes) { |
2481 Linux::numa_interleave_memory(addr, bytes); |
2505 Linux::numa_interleave_memory(addr, bytes); |
2482 } |
2506 } |
2814 return linux_mprotect(addr, size, PROT_NONE); |
2838 return linux_mprotect(addr, size, PROT_NONE); |
2815 } |
2839 } |
2816 |
2840 |
2817 bool os::unguard_memory(char* addr, size_t size) { |
2841 bool os::unguard_memory(char* addr, size_t size) { |
2818 return linux_mprotect(addr, size, PROT_READ|PROT_WRITE); |
2842 return linux_mprotect(addr, size, PROT_READ|PROT_WRITE); |
|
2843 } |
|
2844 |
|
2845 bool os::Linux::hugetlbfs_sanity_check(bool warn, size_t page_size) { |
|
2846 bool result = false; |
|
2847 void *p = mmap (NULL, page_size, PROT_READ|PROT_WRITE, |
|
2848 MAP_ANONYMOUS|MAP_PRIVATE|MAP_HUGETLB, |
|
2849 -1, 0); |
|
2850 |
|
2851 if (p != (void *) -1) { |
|
2852 // We don't know if this really is a huge page or not. |
|
2853 FILE *fp = fopen("/proc/self/maps", "r"); |
|
2854 if (fp) { |
|
2855 while (!feof(fp)) { |
|
2856 char chars[257]; |
|
2857 long x = 0; |
|
2858 if (fgets(chars, sizeof(chars), fp)) { |
|
2859 if (sscanf(chars, "%lx-%*lx", &x) == 1 |
|
2860 && x == (long)p) { |
|
2861 if (strstr (chars, "hugepage")) { |
|
2862 result = true; |
|
2863 break; |
|
2864 } |
|
2865 } |
|
2866 } |
|
2867 } |
|
2868 fclose(fp); |
|
2869 } |
|
2870 munmap (p, page_size); |
|
2871 if (result) |
|
2872 return true; |
|
2873 } |
|
2874 |
|
2875 if (warn) { |
|
2876 warning("HugeTLBFS is not supported by the operating system."); |
|
2877 } |
|
2878 |
|
2879 return result; |
2819 } |
2880 } |
2820 |
2881 |
2821 /* |
2882 /* |
2822 * Set the coredump_filter bits to include largepages in core dump (bit 6) |
2883 * Set the coredump_filter bits to include largepages in core dump (bit 6) |
2823 * |
2884 * |
2858 // Large page support |
2919 // Large page support |
2859 |
2920 |
2860 static size_t _large_page_size = 0; |
2921 static size_t _large_page_size = 0; |
2861 |
2922 |
2862 bool os::large_page_init() { |
2923 bool os::large_page_init() { |
2863 if (!UseLargePages) return false; |
2924 if (!UseLargePages) { |
|
2925 UseHugeTLBFS = false; |
|
2926 UseSHM = false; |
|
2927 return false; |
|
2928 } |
|
2929 |
|
2930 if (FLAG_IS_DEFAULT(UseHugeTLBFS) && FLAG_IS_DEFAULT(UseSHM)) { |
|
2931 // Our user has not expressed a preference, so we'll try both. |
|
2932 UseHugeTLBFS = UseSHM = true; |
|
2933 } |
2864 |
2934 |
2865 if (LargePageSizeInBytes) { |
2935 if (LargePageSizeInBytes) { |
2866 _large_page_size = LargePageSizeInBytes; |
2936 _large_page_size = LargePageSizeInBytes; |
2867 } else { |
2937 } else { |
2868 // large_page_size on Linux is used to round up heap size. x86 uses either |
2938 // large_page_size on Linux is used to round up heap size. x86 uses either |
2903 } |
2973 } |
2904 fclose(fp); |
2974 fclose(fp); |
2905 } |
2975 } |
2906 } |
2976 } |
2907 |
2977 |
|
2978 // print a warning if any large page related flag is specified on command line |
|
2979 bool warn_on_failure = !FLAG_IS_DEFAULT(UseHugeTLBFS); |
|
2980 |
2908 const size_t default_page_size = (size_t)Linux::page_size(); |
2981 const size_t default_page_size = (size_t)Linux::page_size(); |
2909 if (_large_page_size > default_page_size) { |
2982 if (_large_page_size > default_page_size) { |
2910 _page_sizes[0] = _large_page_size; |
2983 _page_sizes[0] = _large_page_size; |
2911 _page_sizes[1] = default_page_size; |
2984 _page_sizes[1] = default_page_size; |
2912 _page_sizes[2] = 0; |
2985 _page_sizes[2] = 0; |
2913 } |
2986 } |
2914 |
2987 |
|
2988 UseHugeTLBFS = UseHugeTLBFS && |
|
2989 Linux::hugetlbfs_sanity_check(warn_on_failure, _large_page_size); |
|
2990 |
|
2991 if (UseHugeTLBFS) |
|
2992 UseSHM = false; |
|
2993 |
|
2994 UseLargePages = UseHugeTLBFS || UseSHM; |
|
2995 |
2915 set_coredump_filter(); |
2996 set_coredump_filter(); |
2916 |
2997 |
2917 // Large page support is available on 2.6 or newer kernel, some vendors |
2998 // Large page support is available on 2.6 or newer kernel, some vendors |
2918 // (e.g. Redhat) have backported it to their 2.4 based distributions. |
2999 // (e.g. Redhat) have backported it to their 2.4 based distributions. |
2919 // We optimistically assume the support is available. If later it turns out |
3000 // We optimistically assume the support is available. If later it turns out |
2926 #endif |
3007 #endif |
2927 |
3008 |
2928 char* os::reserve_memory_special(size_t bytes, char* req_addr, bool exec) { |
3009 char* os::reserve_memory_special(size_t bytes, char* req_addr, bool exec) { |
2929 // "exec" is passed in but not used. Creating the shared image for |
3010 // "exec" is passed in but not used. Creating the shared image for |
2930 // the code cache doesn't have an SHM_X executable permission to check. |
3011 // the code cache doesn't have an SHM_X executable permission to check. |
2931 assert(UseLargePages, "only for large pages"); |
3012 assert(UseLargePages && UseSHM, "only for SHM large pages"); |
2932 |
3013 |
2933 key_t key = IPC_PRIVATE; |
3014 key_t key = IPC_PRIVATE; |
2934 char *addr; |
3015 char *addr; |
2935 |
3016 |
2936 bool warn_on_failure = UseLargePages && |
3017 bool warn_on_failure = UseLargePages && |
2993 |
3074 |
2994 size_t os::large_page_size() { |
3075 size_t os::large_page_size() { |
2995 return _large_page_size; |
3076 return _large_page_size; |
2996 } |
3077 } |
2997 |
3078 |
2998 // Linux does not support anonymous mmap with large page memory. The only way |
3079 // HugeTLBFS allows application to commit large page memory on demand; |
2999 // to reserve large page memory without file backing is through SysV shared |
3080 // with SysV SHM the entire memory region must be allocated as shared |
3000 // memory API. The entire memory region is committed and pinned upfront. |
3081 // memory. |
3001 // Hopefully this will change in the future... |
|
3002 bool os::can_commit_large_page_memory() { |
3082 bool os::can_commit_large_page_memory() { |
3003 return false; |
3083 return UseHugeTLBFS; |
3004 } |
3084 } |
3005 |
3085 |
3006 bool os::can_execute_large_page_memory() { |
3086 bool os::can_execute_large_page_memory() { |
3007 return false; |
3087 return UseHugeTLBFS; |
3008 } |
3088 } |
3009 |
3089 |
3010 // Reserve memory at an arbitrary address, only if that area is |
3090 // Reserve memory at an arbitrary address, only if that area is |
3011 // available (and not reserved for something else). |
3091 // available (and not reserved for something else). |
3012 |
3092 |