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

comparison src/os/windows/vm/os_windows.cpp @ 8883:b9a918201d47

Merge with hsx25

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Sat, 06 Apr 2013 20:04:06 +0200
parents	5fc51c1ecdeb 0ca3dd0ffaba
children	89e4d67fdd2a

comparison

equal deleted inserted replaced

-:d47b52b0ff68
+:b9a918201d47
 #include "runtime/stubRoutines.hpp"
 #include "runtime/thread.inline.hpp"
 #include "runtime/threadCritical.hpp"
 #include "runtime/timer.hpp"
 #include "services/attachListener.hpp"
+#include "services/memTracker.hpp"
 #include "services/runtimeService.hpp"
 #include "utilities/decoder.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/events.hpp"
 #include "utilities/growableArray.hpp"
 julong os::physical_memory() {
 return win32::physical_memory();
 }
-julong os::allocatable_physical_memory(julong size) {
+bool os::has_allocatable_memory_limit(julong* limit) {
+MEMORYSTATUSEX ms;
+ms.dwLength = sizeof(ms);
+GlobalMemoryStatusEx(&ms);
 #ifdef _LP64
-return size;
+*limit = (julong)ms.ullAvailVirtual;
+return true;
 #else
 // Limit to 1400m because of the 2gb address space wall
-return MIN2(size, (julong)1400*M);
+*limit = MIN2((julong)1400*M, (julong)ms.ullAvailVirtual);
+return true;
 #endif
 }
 // VC6 lacks DWORD_PTR
 #if _MSC_VER < 1300
 size_of_reserve,  // size of Reserve
 MEM_RESERVE,
 PAGE_READWRITE);
 // If reservation failed, return NULL
 if (p_buf == NULL) return NULL;
+MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
 os::release_memory(p_buf, bytes + chunk_size);
 // we still need to round up to a page boundary (in case we are using large pages)
 // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
 // instead we handle this in the bytes_to_rq computation below
 if (p_new == NULL) {
 // Free any allocated pages
 if (next_alloc_addr > p_buf) {
 // Some memory was committed so release it.
 size_t bytes_to_release = bytes - bytes_remaining;
+// NMT has yet to record any individual blocks, so it
+// need to create a dummy 'reserve' record to match
+// the release.
+MemTracker::record_virtual_memory_reserve((address)p_buf,
+bytes_to_release, CALLER_PC);
 os::release_memory(p_buf, bytes_to_release);
 }
 #ifdef ASSERT
 if (should_inject_error) {
 if (TracePageSizes && Verbose) {
 }
 }
 #endif
 return NULL;
 }
 bytes_remaining -= bytes_to_rq;
 next_alloc_addr += bytes_to_rq;
 count++;
 }
+// Although the memory is allocated individually, it is returned as one.
+// NMT records it as one block.
+address pc = CALLER_PC;
+MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, pc);
+if ((flags & MEM_COMMIT) != 0) {
+MemTracker::record_virtual_memory_commit((address)p_buf, bytes, pc);
+}
 // made it this far, success
 return p_buf;
 }
 } else {
 // normal policy just allocate it all at once
 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
+if (res != NULL) {
+address pc = CALLER_PC;
+MemTracker::record_virtual_memory_reserve((address)res, bytes, pc);
+MemTracker::record_virtual_memory_commit((address)res, bytes, pc);
+}
 return res;
 }
 }
 bool os::release_memory_special(char* base, size_t bytes) {
+assert(base != NULL, "Sanity check");
+// Memory allocated via reserve_memory_special() is committed
+MemTracker::record_virtual_memory_uncommit((address)base, bytes);
 return release_memory(base, bytes);
 }
 void os::print_statistics() {
 }
 static void perfMemory_exit_helper() {
 perfMemory_exit();
 }
 }
+static jint initSock();
 // this is called _after_ the global arguments have been parsed
 jint os::init_2(void) {
 // Allocate a single page and mark it as readable for safepoint polling
 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
 guarantee( polling_page != NULL, "Reserve Failed for polling page");
 if (UseNUMAInterleaving) {
 // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
 bool success = numa_interleaving_init();
 if (!success) UseNUMAInterleaving = false;
+}
+if (initSock() != JNI_OK) {
+return JNI_ERR;
 }
 return JNI_OK;
 }
 }
 // We don't build a headless jre for Windows
 bool os::is_headless_jre() { return false; }
+static jint initSock() {
-typedef CRITICAL_SECTION mutex_t;
-#define mutexInit(m)    InitializeCriticalSection(m)
-#define mutexDestroy(m) DeleteCriticalSection(m)
-#define mutexLock(m)    EnterCriticalSection(m)
-#define mutexUnlock(m)  LeaveCriticalSection(m)
-static bool sock_initialized = FALSE;
-static mutex_t sockFnTableMutex;
-static void initSock() {
 WSADATA wsadata;
 if (!os::WinSock2Dll::WinSock2Available()) {
-jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n",
+jio_fprintf(stderr, "Could not load Winsock (error: %d)\n",
 ::GetLastError());
-return;
+return JNI_ERR;
 }
-if (sock_initialized == TRUE) return;
+if (os::WinSock2Dll::WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
-::mutexInit(&sockFnTableMutex);
+jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n",
-::mutexLock(&sockFnTableMutex);
+::GetLastError());
-if (os::WinSock2Dll::WSAStartup(MAKEWORD(1,1), &wsadata) != 0) {
+return JNI_ERR;
-jio_fprintf(stderr, "Could not initialize Winsock\n");
+}
-}
+return JNI_OK;
-sock_initialized = TRUE;
-::mutexUnlock(&sockFnTableMutex);
 }
 struct hostent* os::get_host_by_name(char* name) {
-if (!sock_initialized) {
-initSock();
-}
-if (!os::WinSock2Dll::WinSock2Available()) {
-return NULL;
-}
 return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
 }
 int os::socket_close(int fd) {
 return ::closesocket(fd);

Mercurial > hg > graal-jvmci-8

comparison src/os/windows/vm/os_windows.cpp @ 8883:b9a918201d47