rts: delint/detab/dewhitespace win32/OSMem.c
[ghc.git] / rts / win32 / OSMem.c
index d9a6459..d970072 100644 (file)
@@ -6,6 +6,8 @@
  *
  * ---------------------------------------------------------------------------*/
 
+#define _WIN32_WINNT 0x0501
+
 #include "Rts.h"
 #include "sm/OSMem.h"
 #include "RtsUtils.h"
 #endif
 
 typedef struct alloc_rec_ {
-    char* base;     /* non-aligned base address, directly from VirtualAlloc */
-    lnat size;       /* Size in bytes */
+    char* base;    // non-aligned base address, directly from VirtualAlloc
+    W_ size;       // Size in bytes
     struct alloc_rec_* next;
 } alloc_rec;
 
 typedef struct block_rec_ {
-    char* base;         /* base address, non-MBLOCK-aligned */
-    lnat size;           /* size in bytes */
+    char* base;        // base address, non-MBLOCK-aligned
+    W_ size;           // size in bytes
     struct block_rec_* next;
 } block_rec;
 
@@ -46,7 +48,7 @@ alloc_rec*
 allocNew(nat n) {
     alloc_rec* rec;
     rec = (alloc_rec*)stgMallocBytes(sizeof(alloc_rec),"getMBlocks: allocNew");
-    rec->size = ((lnat)n+1)*MBLOCK_SIZE;
+    rec->size = ((W_)n+1)*MBLOCK_SIZE;
     rec->base =
         VirtualAlloc(NULL, rec->size, MEM_RESERVE, PAGE_READWRITE);
     if(rec->base==0) {
@@ -76,7 +78,7 @@ allocNew(nat n) {
 
 static
 void
-insertFree(char* alloc_base, lnat alloc_size) {
+insertFree(char* alloc_base, W_ alloc_size) {
     block_rec temp;
     block_rec* it;
     block_rec* prev;
@@ -87,19 +89,20 @@ insertFree(char* alloc_base, lnat alloc_size) {
     for( ; it!=0 && it->base<alloc_base; prev=it, it=it->next) {}
 
     if(it!=0 && alloc_base+alloc_size == it->base) {
-        if(prev->base + prev->size == alloc_base) {        /* Merge it, alloc, prev */
+        if(prev->base + prev->size == alloc_base) { /* Merge it, alloc, prev */
             prev->size += alloc_size + it->size;
             prev->next = it->next;
             stgFree(it);
-        } else {                                            /* Merge it, alloc */
+        } else {                                    /* Merge it, alloc */
             it->base = alloc_base;
             it->size += alloc_size;
         }
-    } else if(prev->base + prev->size == alloc_base) {     /* Merge alloc, prev */
+    } else if(prev->base + prev->size == alloc_base) { /* Merge alloc, prev */
         prev->size += alloc_size;
-    } else {                                                /* Merge none */
+    } else {                                           /* Merge none */
         block_rec* rec;
-        rec = (block_rec*)stgMallocBytes(sizeof(block_rec),"getMBlocks: insertFree");
+        rec = (block_rec*)stgMallocBytes(sizeof(block_rec),
+                                         "getMBlocks: insertFree");
         rec->base=alloc_base;
         rec->size=alloc_size;
         rec->next = it;
@@ -116,7 +119,7 @@ findFreeBlocks(nat n) {
     block_rec temp;
     block_rec* prev;
 
-    lnat required_size;
+    W_ required_size;
     it=free_blocks;
     required_size = n*MBLOCK_SIZE;
     temp.next=free_blocks; temp.base=0; temp.size=0;
@@ -124,7 +127,7 @@ findFreeBlocks(nat n) {
     /* TODO: Don't just take first block, find smallest sufficient block */
     for( ; it!=0 && it->size<required_size; prev=it, it=it->next ) {}
     if(it!=0) {
-        if( (((lnat)it->base) & MBLOCK_MASK) == 0) { /* MBlock aligned */
+        if( (((W_)it->base) & MBLOCK_MASK) == 0) { /* MBlock aligned */
             ret = (void*)it->base;
             if(it->size==required_size) {
                 prev->next=it->next;
@@ -137,7 +140,8 @@ findFreeBlocks(nat n) {
             char* need_base;
             block_rec* next;
             int new_size;
-            need_base = (char*)(((lnat)it->base) & ((lnat)~MBLOCK_MASK)) + MBLOCK_SIZE;
+            need_base =
+                (char*)(((W_)it->base) & ((W_)~MBLOCK_MASK)) + MBLOCK_SIZE;
             next = (block_rec*)stgMallocBytes(
                     sizeof(block_rec)
                     , "getMBlocks: findFreeBlocks: splitting");
@@ -158,12 +162,12 @@ findFreeBlocks(nat n) {
    so we might need to do many VirtualAlloc MEM_COMMITs.  We simply walk the
    (ordered) allocated blocks. */
 static void
-commitBlocks(char* base, lnat size) {
+commitBlocks(char* base, W_ size) {
     alloc_rec* it;
     it=allocs;
     for( ; it!=0 && (it->base+it->size)<=base; it=it->next ) {}
     for( ; it!=0 && size>0; it=it->next ) {
-        lnat size_delta;
+        W_ size_delta;
         void* temp;
         size_delta = it->size - (base-it->base);
         if(size_delta>size) size_delta=size;
@@ -199,7 +203,7 @@ osGetMBlocks(nat n) {
             barf("getMBlocks: misaligned block returned");
         }
 
-        commitBlocks(ret, (lnat)MBLOCK_SIZE*n);
+        commitBlocks(ret, (W_)MBLOCK_SIZE*n);
     }
 
     return ret;
@@ -208,7 +212,7 @@ osGetMBlocks(nat n) {
 void osFreeMBlocks(char *addr, nat n)
 {
     alloc_rec *p;
-    lnat nBytes = (lnat)n * MBLOCK_SIZE;
+    W_ nBytes = (W_)n * MBLOCK_SIZE;
 
     insertFree(addr, nBytes);
 
@@ -229,7 +233,7 @@ void osFreeMBlocks(char *addr, nat n)
             nBytes = 0;
         }
         else {
-            lnat bytesToFree = p->base + p->size - addr;
+            W_ bytesToFree = p->base + p->size - addr;
             if (!VirtualFree(addr, bytesToFree, MEM_DECOMMIT)) {
                 sysErrorBelch("osFreeMBlocks: VirtualFree MEM_DECOMMIT failed");
                 stg_exit(EXIT_FAILURE);
@@ -303,7 +307,9 @@ void osReleaseFreeMemory(void)
                     if (fb->base != a->base) {
                         block_rec *new_fb;
 
-                        new_fb = (block_rec *)stgMallocBytes(sizeof(block_rec),"osReleaseFreeMemory");
+                        new_fb =
+                            (block_rec *)stgMallocBytes(sizeof(block_rec),
+                                                        "osReleaseFreeMemory");
                         new_fb->base = fb->base;
                         new_fb->size = a->base - fb->base;
                         new_fb->next = fb;
@@ -315,7 +321,8 @@ void osReleaseFreeMemory(void)
                 /* Now we can free the alloc */
                 prev_a->next = a->next;
                 if(!VirtualFree((void *)a->base, 0, MEM_RELEASE)) {
-                    sysErrorBelch("freeAllMBlocks: VirtualFree MEM_RELEASE failed");
+                    sysErrorBelch("freeAllMBlocks: VirtualFree MEM_RELEASE "
+                                  "failed");
                     stg_exit(EXIT_FAILURE);
                 }
                 stgFree(a);
@@ -365,9 +372,9 @@ osFreeAllMBlocks(void)
     }
 }
 
-lnat getPageSize (void)
+W_ getPageSize (void)
 {
-    static lnat pagesize = 0;
+    static W_ pagesize = 0;
     if (pagesize) {
         return pagesize;
     } else {
@@ -378,15 +385,34 @@ lnat getPageSize (void)
     }
 }
 
-void setExecutable (void *p, lnat len, rtsBool exec)
+/* Returns 0 if physical memory size cannot be identified */
+StgWord64 getPhysicalMemorySize (void)
+{
+    static StgWord64 physMemSize = 0;
+    if (!physMemSize) {
+        MEMORYSTATUSEX status;
+        status.dwLength = sizeof(status);
+        if (!GlobalMemoryStatusEx(&status)) {
+#if defined(DEBUG)
+            errorBelch("warning: getPhysicalMemorySize: cannot get physical "
+                       "memory size");
+#endif
+            return 0;
+        }
+        physMemSize = status.ullTotalPhys;
+    }
+    return physMemSize;
+}
+
+void setExecutable (void *p, W_ len, rtsBool exec)
 {
     DWORD dwOldProtect = 0;
     if (VirtualProtect (p, len,
                         exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,
                         &dwOldProtect) == 0)
     {
-        sysErrorBelch("setExecutable: failed to protect 0x%p; old protection: %lu\n",
-                      p, (unsigned long)dwOldProtect);
+        sysErrorBelch("setExecutable: failed to protect 0x%p; old protection: "
+                      "%lu\n", p, (unsigned long)dwOldProtect);
         stg_exit(EXIT_FAILURE);
     }
 }