X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2Fsm%2FStorage.c;h=c441826a147769172c308eda4e928cc76f39eeab;hb=a148ad2778c66fbfd75f138af6e6a22ab7c843fe;hp=eb29b2daf6c96e7cae7dda741b0cfa37772ce2e3;hpb=c1540c3def6281ea67b5a4ce7499b1aa982faa25;p=ghc-hetmet.git

diff --git a/rts/sm/Storage.c b/rts/sm/Storage.c
index eb29b2d..c441826 100644
--- a/rts/sm/Storage.c
+++ b/rts/sm/Storage.c
@@ -29,6 +29,8 @@
 #include "RetainerProfile.h"	// for counting memory blocks (memInventory)
 #include "OSMem.h"
 #include "Trace.h"
+#include "GC.h"
+#include "GCUtils.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -84,20 +86,16 @@ initStep (step *stp, int g, int s)
     stp->n_old_blocks = 0;
     stp->gen = &generations[g];
     stp->gen_no = g;
-    stp->hp = NULL;
-    stp->hpLim = NULL;
-    stp->hp_bd = NULL;
-    stp->scavd_hp = NULL;
-    stp->scavd_hpLim = NULL;
-    stp->scan = NULL;
-    stp->scan_bd = NULL;
     stp->large_objects = NULL;
     stp->n_large_blocks = 0;
-    stp->new_large_objects = NULL;
     stp->scavenged_large_objects = NULL;
     stp->n_scavenged_large_blocks = 0;
     stp->is_compacted = 0;
     stp->bitmap = NULL;
+#ifdef THREADED_RTS
+    initSpinLock(&stp->sync_todo);
+    initSpinLock(&stp->sync_large_objects);
+#endif
 }
 
 void
@@ -105,6 +103,7 @@ initStorage( void )
 {
   nat g, s;
   generation *gen;
+  step *step_arr;
 
   if (generations != NULL) {
       // multi-init protection
@@ -116,7 +115,8 @@ initStorage( void )
   /* Sanity check to make sure the LOOKS_LIKE_ macros appear to be
    * doing something reasonable.
    */
-  ASSERT(LOOKS_LIKE_INFO_PTR(&stg_BLACKHOLE_info));
+  /* We use the NOT_NULL variant or gcc warns that the test is always true */
+  ASSERT(LOOKS_LIKE_INFO_PTR_NOT_NULL(&stg_BLACKHOLE_info));
   ASSERT(LOOKS_LIKE_CLOSURE_PTR(&stg_dummy_ret_closure));
   ASSERT(!HEAP_ALLOCED(&stg_dummy_ret_closure));
   
@@ -147,6 +147,15 @@ initStorage( void )
 					     * sizeof(struct generation_),
 					     "initStorage: gens");
 
+  /* allocate all the steps into an array.  It is important that we do
+     it this way, because we need the invariant that two step pointers
+     can be directly compared to see which is the oldest.
+     Remember that the last generation has only one step. */
+  step_arr = stgMallocBytes(sizeof(struct step_) 
+			    * (1 + ((RtsFlags.GcFlags.generations - 1)
+				    * RtsFlags.GcFlags.steps)),
+			    "initStorage: steps");
+
   /* Initialise all generations */
   for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
     gen = &generations[g];
@@ -167,21 +176,19 @@ initStorage( void )
 
     /* Oldest generation: one step */
     oldest_gen->n_steps = 1;
-    oldest_gen->steps = 
-      stgMallocBytes(1 * sizeof(struct step_), "initStorage: last step");
+    oldest_gen->steps   = step_arr + (RtsFlags.GcFlags.generations - 1)
+	                              * RtsFlags.GcFlags.steps;
 
     /* set up all except the oldest generation with 2 steps */
     for(g = 0; g < RtsFlags.GcFlags.generations-1; g++) {
       generations[g].n_steps = RtsFlags.GcFlags.steps;
-      generations[g].steps  = 
-	stgMallocBytes (RtsFlags.GcFlags.steps * sizeof(struct step_),
-			"initStorage: steps");
+      generations[g].steps   = step_arr + g * RtsFlags.GcFlags.steps;
     }
     
   } else {
     /* single generation, i.e. a two-space collector */
     g0->n_steps = 1;
-    g0->steps = stgMallocBytes (sizeof(struct step_), "initStorage: steps");
+    g0->steps   = step_arr;
   }
 
 #ifdef THREADED_RTS
@@ -247,6 +254,10 @@ initStorage( void )
   /* Tell GNU multi-precision pkg about our custom alloc functions */
   mp_set_memory_functions(stgAllocForGMP, stgReallocForGMP, stgDeallocForGMP);
 
+#ifdef THREADED_RTS
+  initSpinLock(&gc_alloc_block_sync);
+#endif
+
   IF_DEBUG(gc, statDescribeGens());
 
   RELEASE_SM_LOCK;
@@ -261,10 +272,7 @@ exitStorage (void)
 void
 freeStorage (void)
 {
-    nat g;
-
-    for(g = 0; g < RtsFlags.GcFlags.generations; g++)
-      stgFree(generations[g].steps);
+    stgFree(g0s0); // frees all the steps
     stgFree(generations);
     freeAllMBlocks();
 #if defined(THREADED_RTS)
@@ -565,6 +573,14 @@ allocateInGen (generation *g, nat n)
     if (n >= LARGE_OBJECT_THRESHOLD/sizeof(W_))
     {
 	nat req_blocks =  (lnat)BLOCK_ROUND_UP(n*sizeof(W_)) / BLOCK_SIZE;
+
+        // Attempting to allocate an object larger than maxHeapSize
+        // should definitely be disallowed.  (bug #1791)
+        if (RtsFlags.GcFlags.maxHeapSize > 0 && 
+            req_blocks >= RtsFlags.GcFlags.maxHeapSize) {
+            heapOverflow();
+        }
+
 	bd = allocGroup(req_blocks);
 	dbl_link_onto(bd, &stp->large_objects);
 	stp->n_large_blocks += bd->blocks; // might be larger than req_blocks
@@ -663,7 +679,9 @@ allocateLocal (Capability *cap, nat n)
             bd->gen_no = 0;
             bd->step = cap->r.rNursery;
             bd->flags = 0;
-            alloc_blocks++;
+            // NO: alloc_blocks++;
+            // calcAllocated() uses the size of the nursery, and we've
+            // already bumpted nursery->n_blocks above.
         } else {
             // we have a block in the nursery: take it and put
             // it at the *front* of the nursery list, and use it