2865 #endif 2866 } else { 2867 WARN("Large page is not supported by the processor."); 2868 } 2869 } else { 2870 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory."); 2871 } 2872 #undef WARN 2873 2874 const size_t default_page_size = (size_t) vm_page_size(); 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 // On win32, one cannot release just a part of reserved memory, it's an 2886 // all or nothing deal. When we split a reservation, we must break the 2887 // reservation into two reservations. 2888 void os::pd_split_reserved_memory(char *base, size_t size, size_t split, 2889 bool realloc) { 2890 if (size > 0) { 2891 release_memory(base, size); 2892 if (realloc) { 2893 reserve_memory(split, base); 2894 } 2895 if (size != split) { 2896 reserve_memory(size - split, base + split); 2897 } 2898 } 2899 } 2900 2901 // Multiple threads can race in this code but it's not possible to unmap small sections of 2902 // virtual space to get requested alignment, like posix-like os's. 2903 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe. 2904 char* os::reserve_memory_aligned(size_t size, size_t alignment) { 2905 assert((alignment & (os::vm_allocation_granularity() - 1)) == 0, 2906 "Alignment must be a multiple of allocation granularity (page size)"); 2907 assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned"); 2908 2909 size_t extra_size = size + alignment; 2910 assert(extra_size >= size, "overflow, size is too large to allow alignment"); 2911 2912 char* aligned_base = NULL; 2913 2914 do { 2915 char* extra_base = os::reserve_memory(extra_size, NULL, alignment); 2916 if (extra_base == NULL) { 2917 return NULL; 2918 } 2919 // Do manual alignment 2920 aligned_base = align_up(extra_base, alignment); 2921 2922 os::release_memory(extra_base, extra_size); 2923 2924 aligned_base = os::reserve_memory(size, aligned_base); 2925 2926 } while (aligned_base == NULL); 2927 2928 return aligned_base; 2929 } 2930 2931 char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 2932 assert((size_t)addr % os::vm_allocation_granularity() == 0, 2933 "reserve alignment"); 2934 assert(bytes % os::vm_page_size() == 0, "reserve page size"); 2935 char* res; 2936 // note that if UseLargePages is on, all the areas that require interleaving 2937 // will go thru reserve_memory_special rather than thru here. 2938 bool use_individual = (UseNUMAInterleaving && !UseLargePages); 2939 if (!use_individual) { 2940 res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE); 2941 } else { 2942 elapsedTimer reserveTimer; 2943 if (Verbose && PrintMiscellaneous) reserveTimer.start(); 2944 // in numa interleaving, we have to allocate pages individually 2948 warning("NUMA page allocation failed"); 2949 } 2950 if (Verbose && PrintMiscellaneous) { 2951 reserveTimer.stop(); 2952 tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes, 2953 reserveTimer.milliseconds(), reserveTimer.ticks()); 2954 } 2955 } 2956 assert(res == NULL || addr == NULL || addr == res, 2957 "Unexpected address from reserve."); 2958 2959 return res; 2960 } 2961 2962 // Reserve memory at an arbitrary address, only if that area is 2963 // available (and not reserved for something else). 2964 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 2965 // Windows os::reserve_memory() fails of the requested address range is 2966 // not avilable. 2967 return reserve_memory(bytes, requested_addr); 2968 } 2969 2970 size_t os::large_page_size() { 2971 return _large_page_size; 2972 } 2973 2974 bool os::can_commit_large_page_memory() { 2975 // Windows only uses large page memory when the entire region is reserved 2976 // and committed in a single VirtualAlloc() call. This may change in the 2977 // future, but with Windows 2003 it's not possible to commit on demand. 2978 return false; 2979 } 2980 2981 bool os::can_execute_large_page_memory() { 2982 return true; 2983 } 2984 2985 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr, 2986 bool exec) { 2987 assert(UseLargePages, "only for large pages"); | 2865 #endif 2866 } else { 2867 WARN("Large page is not supported by the processor."); 2868 } 2869 } else { 2870 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory."); 2871 } 2872 #undef WARN 2873 2874 const size_t default_page_size = (size_t) vm_page_size(); 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_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 #ifdef _LP64 2922 HANDLE fileMapping = CreateFileMapping(fh, NULL, PAGE_READWRITE, 2923 (DWORD)(size >> 32), (DWORD)(size & 0xFFFFFFFF), NULL); 2924 #else 2925 HANDLE fileMapping = CreateFileMapping(fh, NULL, PAGE_READWRITE, 2926 0, (DWORD)size, NULL); 2927 #endif 2928 if (fileMapping == NULL) { 2929 if (GetLastError() == ERROR_DISK_FULL) { 2930 vm_exit_during_initialization(err_msg("Could not allocate sufficient disk space for Java heap")); 2931 } 2932 else { 2933 vm_exit_during_initialization(err_msg("Error in mapping Java heap at the given filesystem directory")); 2934 } 2935 2936 return NULL; 2937 } 2938 2939 LPVOID addr = MapViewOfFileEx(fileMapping, FILE_MAP_WRITE, 0, 0, size, base); 2940 2941 CloseHandle(fileMapping); 2942 2943 return (char*)addr; 2944 } 2945 2946 char* os::replace_existing_mapping_with_file_mapping(char* base, size_t size, int fd) { 2947 assert(fd != -1, "File descriptor is not valid"); 2948 assert(base != NULL, "Base address cannot be NULL"); 2949 2950 release_memory(base, size); 2951 return map_memory_to_file(base, size, fd); 2952 } 2953 2954 // On win32, one cannot release just a part of reserved memory, it's an 2955 // all or nothing deal. When we split a reservation, we must break the 2956 // reservation into two reservations. 2957 void os::pd_split_reserved_memory(char *base, size_t size, size_t split, 2958 bool realloc) { 2959 if (size > 0) { 2960 release_memory(base, size); 2961 if (realloc) { 2962 reserve_memory(split, base); 2963 } 2964 if (size != split) { 2965 reserve_memory(size - split, base + split); 2966 } 2967 } 2968 } 2969 2970 // Multiple threads can race in this code but it's not possible to unmap small sections of 2971 // virtual space to get requested alignment, like posix-like os's. 2972 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe. 2973 char* os::reserve_memory_aligned(size_t size, size_t alignment, int file_desc) { 2974 assert((alignment & (os::vm_allocation_granularity() - 1)) == 0, 2975 "Alignment must be a multiple of allocation granularity (page size)"); 2976 assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned"); 2977 2978 size_t extra_size = size + alignment; 2979 assert(extra_size >= size, "overflow, size is too large to allow alignment"); 2980 2981 char* aligned_base = NULL; 2982 2983 do { 2984 char* extra_base = os::reserve_memory(extra_size, NULL, alignment, file_desc); 2985 if (extra_base == NULL) { 2986 return NULL; 2987 } 2988 // Do manual alignment 2989 aligned_base = align_up(extra_base, alignment); 2990 2991 if (file_desc != -1) { 2992 os::unmap_memory(extra_base, extra_size); 2993 } else { 2994 os::release_memory(extra_base, extra_size); 2995 } 2996 2997 aligned_base = os::reserve_memory(size, aligned_base, 0, file_desc); 2998 2999 } while (aligned_base == NULL); 3000 3001 return aligned_base; 3002 } 3003 3004 char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 3005 assert((size_t)addr % os::vm_allocation_granularity() == 0, 3006 "reserve alignment"); 3007 assert(bytes % os::vm_page_size() == 0, "reserve page size"); 3008 char* res; 3009 // note that if UseLargePages is on, all the areas that require interleaving 3010 // will go thru reserve_memory_special rather than thru here. 3011 bool use_individual = (UseNUMAInterleaving && !UseLargePages); 3012 if (!use_individual) { 3013 res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE); 3014 } else { 3015 elapsedTimer reserveTimer; 3016 if (Verbose && PrintMiscellaneous) reserveTimer.start(); 3017 // in numa interleaving, we have to allocate pages individually 3021 warning("NUMA page allocation failed"); 3022 } 3023 if (Verbose && PrintMiscellaneous) { 3024 reserveTimer.stop(); 3025 tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes, 3026 reserveTimer.milliseconds(), reserveTimer.ticks()); 3027 } 3028 } 3029 assert(res == NULL || addr == NULL || addr == res, 3030 "Unexpected address from reserve."); 3031 3032 return res; 3033 } 3034 3035 // Reserve memory at an arbitrary address, only if that area is 3036 // available (and not reserved for something else). 3037 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 3038 // Windows os::reserve_memory() fails of the requested address range is 3039 // not avilable. 3040 return reserve_memory(bytes, requested_addr); 3041 } 3042 3043 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr, int file_desc) { 3044 assert(file_desc >= 0, "file_desc is not valid"); 3045 return map_memory_to_file(requested_addr, bytes, file_desc); 3046 } 3047 3048 size_t os::large_page_size() { 3049 return _large_page_size; 3050 } 3051 3052 bool os::can_commit_large_page_memory() { 3053 // Windows only uses large page memory when the entire region is reserved 3054 // and committed in a single VirtualAlloc() call. This may change in the 3055 // future, but with Windows 2003 it's not possible to commit on demand. 3056 return false; 3057 } 3058 3059 bool os::can_execute_large_page_memory() { 3060 return true; 3061 } 3062 3063 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr, 3064 bool exec) { 3065 assert(UseLargePages, "only for large pages"); |