[project @ 2005-01-28 12:55:17 by simonmar]

[ghc-hetmet.git] / ghc / rts / MBlock.c

diff --git a/ghc/rts/MBlock.c b/ghc/rts/MBlock.c
index 60aa97b..0ce1e76 100644 (file)
--- a/ghc/rts/MBlock.c
+++ b/ghc/rts/MBlock.c
@@ -29,7 +29,7 @@
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
-#ifndef mingw32_TARGET_OS
+#ifndef mingw32_HOST_OS
 # ifdef HAVE_SYS_MMAN_H
 # include <sys/mman.h>
 # endif
@@ -40,7 +40,7 @@
 #if HAVE_WINDOWS_H
 #include <windows.h>
 #endif
-#if darwin_TARGET_OS
+#if darwin_HOST_OS
 #include <mach/vm_map.h>
 #endif
 
@@ -52,10 +52,63 @@ lnat mblocks_allocated = 0;
    The MBlock Map: provides our implementation of HEAP_ALLOCED()
    -------------------------------------------------------------------------- */
 
-#ifdef MBLOCK_MAP_SIZE
+#if SIZEOF_VOID_P == 4
 StgWord8 mblock_map[MBLOCK_MAP_SIZE]; // initially all zeros
+#elif SIZEOF_VOID_P == 8
+static MBlockMap dummy_mblock_map;
+MBlockMap *mblock_cache = &dummy_mblock_map;
+int mblock_map_count = 0;
+MBlockMap **mblock_maps = NULL;
+
+static MBlockMap *
+findMBlockMap(void *p)
+{
+    int i;
+    StgWord32 hi = (StgWord32) (((StgWord)p) >> 32);
+    for( i = 0; i < mblock_map_count; i++ )
+    {
+        if(mblock_maps[i]->addrHigh32 == hi)
+        {
+           return mblock_maps[i];
+       }
+    }
+    return NULL;
+}
+
+StgBool
+slowIsHeapAlloced(void *p)
+{
+    MBlockMap *map = findMBlockMap(p);
+    if(map)
+    {
+       mblock_cache = map;
+       return map->mblocks[MBLOCK_MAP_ENTRY(p)];
+    }
+    else
+       return 0;
+}
 #endif
 
+static void
+markHeapAlloced(void *p)
+{
+#if SIZEOF_VOID_P == 4
+    mblock_map[MBLOCK_MAP_ENTRY(p)] = 1;
+#elif SIZEOF_VOID_P == 8
+    MBlockMap *map = findMBlockMap(p);
+    if(map == NULL)
+    {
+       mblock_map_count++;
+       mblock_maps = realloc(mblock_maps,
+                             sizeof(MBlockMap*) * mblock_map_count);
+       map = mblock_maps[mblock_map_count-1] = calloc(1,sizeof(MBlockMap));
+       map->addrHigh32 = (StgWord32) (((StgWord)p) >> 32);
+    }
+    map->mblocks[MBLOCK_MAP_ENTRY(p)] = 1;
+    mblock_cache = map;
+#endif
+}
+
 /* -----------------------------------------------------------------------------
    Allocate new mblock(s)
    -------------------------------------------------------------------------- */
@@ -83,7 +136,7 @@ getMBlock(void)
    again using the general method.
    -------------------------------------------------------------------------- */
 
-#if !defined(mingw32_TARGET_OS) && !defined(cygwin32_TARGET_OS)
+#if !defined(mingw32_HOST_OS) && !defined(cygwin32_HOST_OS)
 
 // A wrapper around mmap(), to abstract away from OS differences in
 // the mmap() interface.
@@ -93,16 +146,16 @@ my_mmap (void *addr, lnat size)
 {
     void *ret;
 
-#if defined(solaris2_TARGET_OS) || defined(irix_TARGET_OS)
+#if defined(solaris2_HOST_OS) || defined(irix_HOST_OS)
     { 
        int fd = open("/dev/zero",O_RDONLY);
        ret = mmap(addr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
        close(fd);
     }
-#elif hpux_TARGET_OS
+#elif hpux_HOST_OS
     ret = mmap(addr, size, PROT_READ | PROT_WRITE, 
               MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-#elif darwin_TARGET_OS
+#elif darwin_HOST_OS
     // Without MAP_FIXED, Apple's mmap ignores addr.
     // With MAP_FIXED, it overwrites already mapped regions, whic
     // mmap(0, ... MAP_FIXED ...) is worst of all: It unmaps the program text
@@ -224,7 +277,7 @@ getMBlocks(nat n)
 
   // fill in the table
   for (i = 0; i < n; i++) {
-      MARK_HEAP_ALLOCED( ret + i * MBLOCK_SIZE );
+      markHeapAlloced( ret + i * MBLOCK_SIZE );
   }
 
   mblocks_allocated += n;
@@ -232,7 +285,7 @@ getMBlocks(nat n)
   return ret;
 }
 
-#else /* defined(mingw32_TARGET_OS) || defined(cygwin32_TARGET_OS) */
+#else /* defined(mingw32_HOST_OS) || defined(cygwin32_HOST_OS) */
 
 /*
  On Win32 platforms we make use of the two-phased virtual memory API
@@ -333,7 +386,7 @@ getMBlocks(nat n)
   
   // fill in the table
   for (i = 0; i < n; i++) {
-      MARK_HEAP_ALLOCED ( ret + i * MBLOCK_SIZE );
+      markHeapAlloced( ret + i * MBLOCK_SIZE );
   }
 
   return ret;