2875 if (success && _large_page_size > default_page_size) {
2876 _page_sizes[0] = _large_page_size;
2877 _page_sizes[1] = default_page_size;
2878 _page_sizes[2] = 0;
2879 }
2880
2881 cleanup_after_large_page_init();
2882 UseLargePages = success;
2883 }
2884
2885 int os::create_file_for_heap(const char* dir) {
2886
2887 const char name_template[] = "/jvmheap.XXXXXX";
2888 char *fullname = (char*)os::malloc((strlen(dir) + strlen(name_template) + 1), mtInternal);
2889 if (fullname == NULL) {
2890 vm_exit_during_initialization(err_msg("Malloc failed during creation of backing file for heap (%s)", os::strerror(errno)));
2891 return -1;
2892 }
2893
2894 (void)strncpy(fullname, dir, strlen(dir)+1);
2895 (void)strncat(fullname, name_template, strlen(name_template);
2896
2897 os::native_path(fullname);
2898
2899 char *path = _mktemp(fullname);
2900 if (path == NULL) {
2901 warning("_mktemp could not create file name from template (%s)", os::strerror(errno));
2902 os::free(fullname);
2903 return -1;
2904 }
2905
2906 int fd = _open(path, O_RDWR | O_CREAT | O_TEMPORARY | O_EXCL, S_IWRITE | S_IREAD);
2907
2908 os::free(fullname);
2909 if (fd < 0) {
2910 warning("Problem opening file for heap (%s)", os::strerror(errno));
2911 return -1;
2912 }
2913 return fd;
2914 }
2915
2916 // If 'base' is not NULL, function will return NULL if it cannot get 'base'
2917 char* os::map_memory_to_dax_file(char* base, size_t size, int fd) {
2918 assert(fd != -1, "File descriptor is not valid");
2919
2920 HANDLE fh = (HANDLE)_get_osfhandle(fd);
2921 HANDLE fileMapping = CreateFileMapping(fh, NULL, PAGE_READWRITE,
2929 }
2930
2931 return NULL;
2932 }
2933
2934 LPVOID addr = MapViewOfFileEx(fileMapping, FILE_MAP_WRITE, 0, 0, size, base);
2935
2936 CloseHandle(fileMapping);
2937
2938 return (char*)addr;
2939 }
2940
2941 char* os::replace_existing_mapping_with_dax_file_mapping(char* base, size_t size, int fd) {
2942 assert(fd != -1, "File descriptor is not valid");
2943 assert(base != NULL, "Base address cannot be NULL");
2944
2945 release_memory(base, size);
2946 return map_memory_to_dax_file(base, size, fd);
2947 }
2948
2949 char* os::attempt_reserve_memory_at(size_t bytes, char* addr, int file_desc) {
2950 char* result = NULL;
2951 if (file_desc != -1) {
2952 result = map_memory_to_dax_file(addr, bytes, file_desc);
2953 if (result != NULL) {
2954 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC);
2955 }
2956 } else {
2957 result = pd_attempt_reserve_memory_at(bytes, addr);
2958 if (result != NULL) {
2959 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
2960 }
2961 }
2962 return result;
2963 }
2964
2965 // On win32, one cannot release just a part of reserved memory, it's an
2966 // all or nothing deal. When we split a reservation, we must break the
2967 // reservation into two reservations.
2968 void os::pd_split_reserved_memory(char *base, size_t size, size_t split,
2969 bool realloc) {
2970 if (size > 0) {
2971 release_memory(base, size);
2972 if (realloc) {
2973 reserve_memory(split, base);
2974 }
2975 if (size != split) {
2976 reserve_memory(size - split, base + split);
2977 }
2978 }
2979 }
2980
2981 // Multiple threads can race in this code but it's not possible to unmap small sections of
2982 // virtual space to get requested alignment, like posix-like os's.
2983 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe.
2984 char* os::reserve_memory_aligned(size_t size, size_t alignment, int file_desc) {
3032 warning("NUMA page allocation failed");
3033 }
3034 if (Verbose && PrintMiscellaneous) {
3035 reserveTimer.stop();
3036 tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes,
3037 reserveTimer.milliseconds(), reserveTimer.ticks());
3038 }
3039 }
3040 assert(res == NULL || addr == NULL || addr == res,
3041 "Unexpected address from reserve.");
3042
3043 return res;
3044 }
3045
3046 // Reserve memory at an arbitrary address, only if that area is
3047 // available (and not reserved for something else).
3048 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3049 // Windows os::reserve_memory() fails of the requested address range is
3050 // not avilable.
3051 return reserve_memory(bytes, requested_addr);
3052 }
3053
3054 size_t os::large_page_size() {
3055 return _large_page_size;
3056 }
3057
3058 bool os::can_commit_large_page_memory() {
3059 // Windows only uses large page memory when the entire region is reserved
3060 // and committed in a single VirtualAlloc() call. This may change in the
3061 // future, but with Windows 2003 it's not possible to commit on demand.
3062 return false;
3063 }
3064
3065 bool os::can_execute_large_page_memory() {
3066 return true;
3067 }
3068
3069 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr,
3070 bool exec) {
3071 assert(UseLargePages, "only for large pages");
|
2875 if (success && _large_page_size > default_page_size) {
2876 _page_sizes[0] = _large_page_size;
2877 _page_sizes[1] = default_page_size;
2878 _page_sizes[2] = 0;
2879 }
2880
2881 cleanup_after_large_page_init();
2882 UseLargePages = success;
2883 }
2884
2885 int os::create_file_for_heap(const char* dir) {
2886
2887 const char name_template[] = "/jvmheap.XXXXXX";
2888 char *fullname = (char*)os::malloc((strlen(dir) + strlen(name_template) + 1), mtInternal);
2889 if (fullname == NULL) {
2890 vm_exit_during_initialization(err_msg("Malloc failed during creation of backing file for heap (%s)", os::strerror(errno)));
2891 return -1;
2892 }
2893
2894 (void)strncpy(fullname, dir, strlen(dir)+1);
2895 (void)strncat(fullname, name_template, strlen(name_template));
2896
2897 os::native_path(fullname);
2898
2899 char *path = _mktemp(fullname);
2900 if (path == NULL) {
2901 warning("_mktemp could not create file name from template %s (%s)", fullname, os::strerror(errno));
2902 os::free(fullname);
2903 return -1;
2904 }
2905
2906 int fd = _open(path, O_RDWR | O_CREAT | O_TEMPORARY | O_EXCL, S_IWRITE | S_IREAD);
2907
2908 os::free(fullname);
2909 if (fd < 0) {
2910 warning("Problem opening file for heap (%s)", os::strerror(errno));
2911 return -1;
2912 }
2913 return fd;
2914 }
2915
2916 // If 'base' is not NULL, function will return NULL if it cannot get 'base'
2917 char* os::map_memory_to_dax_file(char* base, size_t size, int fd) {
2918 assert(fd != -1, "File descriptor is not valid");
2919
2920 HANDLE fh = (HANDLE)_get_osfhandle(fd);
2921 HANDLE fileMapping = CreateFileMapping(fh, NULL, PAGE_READWRITE,
2929 }
2930
2931 return NULL;
2932 }
2933
2934 LPVOID addr = MapViewOfFileEx(fileMapping, FILE_MAP_WRITE, 0, 0, size, base);
2935
2936 CloseHandle(fileMapping);
2937
2938 return (char*)addr;
2939 }
2940
2941 char* os::replace_existing_mapping_with_dax_file_mapping(char* base, size_t size, int fd) {
2942 assert(fd != -1, "File descriptor is not valid");
2943 assert(base != NULL, "Base address cannot be NULL");
2944
2945 release_memory(base, size);
2946 return map_memory_to_dax_file(base, size, fd);
2947 }
2948
2949 // On win32, one cannot release just a part of reserved memory, it's an
2950 // all or nothing deal. When we split a reservation, we must break the
2951 // reservation into two reservations.
2952 void os::pd_split_reserved_memory(char *base, size_t size, size_t split,
2953 bool realloc) {
2954 if (size > 0) {
2955 release_memory(base, size);
2956 if (realloc) {
2957 reserve_memory(split, base);
2958 }
2959 if (size != split) {
2960 reserve_memory(size - split, base + split);
2961 }
2962 }
2963 }
2964
2965 // Multiple threads can race in this code but it's not possible to unmap small sections of
2966 // virtual space to get requested alignment, like posix-like os's.
2967 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe.
2968 char* os::reserve_memory_aligned(size_t size, size_t alignment, int file_desc) {
3016 warning("NUMA page allocation failed");
3017 }
3018 if (Verbose && PrintMiscellaneous) {
3019 reserveTimer.stop();
3020 tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes,
3021 reserveTimer.milliseconds(), reserveTimer.ticks());
3022 }
3023 }
3024 assert(res == NULL || addr == NULL || addr == res,
3025 "Unexpected address from reserve.");
3026
3027 return res;
3028 }
3029
3030 // Reserve memory at an arbitrary address, only if that area is
3031 // available (and not reserved for something else).
3032 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3033 // Windows os::reserve_memory() fails of the requested address range is
3034 // not avilable.
3035 return reserve_memory(bytes, requested_addr);
3036 }
3037
3038 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr, int file_desc) {
3039 assert(file_desc >= 0, "file_desc is not valid");
3040 return map_memory_to_dax_file(requested_addr, bytes, file_desc);
3041 }
3042
3043 size_t os::large_page_size() {
3044 return _large_page_size;
3045 }
3046
3047 bool os::can_commit_large_page_memory() {
3048 // Windows only uses large page memory when the entire region is reserved
3049 // and committed in a single VirtualAlloc() call. This may change in the
3050 // future, but with Windows 2003 it's not possible to commit on demand.
3051 return false;
3052 }
3053
3054 bool os::can_execute_large_page_memory() {
3055 return true;
3056 }
3057
3058 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr,
3059 bool exec) {
3060 assert(UseLargePages, "only for large pages");
|