GC.c 115 KB
Newer Older
1
2
/* -----------------------------------------------------------------------------
 *
3
 * (c) The GHC Team 1998-2003
4
5
 *
 * Generational garbage collector
6
7
8
 *
 * ---------------------------------------------------------------------------*/

9
#include "PosixSource.h"
10
11
12
#include "Rts.h"
#include "RtsFlags.h"
#include "RtsUtils.h"
13
#include "Apply.h"
14
#include "Storage.h"
15
16
#include "LdvProfile.h"
#include "Updates.h"
17
18
19
20
#include "Stats.h"
#include "Schedule.h"
#include "Sanity.h"
#include "BlockAlloc.h"
21
#include "MBlock.h"
22
#include "ProfHeap.h"
23
24
#include "SchedAPI.h"
#include "Weak.h"
25
#include "Prelude.h"
26
27
#include "ParTicky.h"		// ToDo: move into Rts.h
#include "GCCompact.h"
28
#include "Signals.h"
29
#include "STM.h"
30
31
32
33
34
35
36
37
38
#if defined(GRAN) || defined(PAR)
# include "GranSimRts.h"
# include "ParallelRts.h"
# include "FetchMe.h"
# if defined(DEBUG)
#  include "Printer.h"
#  include "ParallelDebug.h"
# endif
#endif
39
40
#include "HsFFI.h"
#include "Linker.h"
41
42
43
#if defined(RTS_GTK_FRONTPANEL)
#include "FrontPanel.h"
#endif
44

45
46
#include "RetainerProfile.h"

47
48
#include <string.h>

49
50
/* STATIC OBJECT LIST.
 *
51
 * During GC:
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 * We maintain a linked list of static objects that are still live.
 * The requirements for this list are:
 *
 *  - we need to scan the list while adding to it, in order to
 *    scavenge all the static objects (in the same way that
 *    breadth-first scavenging works for dynamic objects).
 *
 *  - we need to be able to tell whether an object is already on
 *    the list, to break loops.
 *
 * Each static object has a "static link field", which we use for
 * linking objects on to the list.  We use a stack-type list, consing
 * objects on the front as they are added (this means that the
 * scavenge phase is depth-first, not breadth-first, but that
 * shouldn't matter).  
 *
 * A separate list is kept for objects that have been scavenged
 * already - this is so that we can zero all the marks afterwards.
 *
 * An object is on the list if its static link field is non-zero; this
 * means that we have to mark the end of the list with '1', not NULL.  
73
74
75
76
77
78
79
80
81
82
 *
 * Extra notes for generational GC:
 *
 * Each generation has a static object list associated with it.  When
 * collecting generations up to N, we treat the static object lists
 * from generations > N as roots.
 *
 * We build up a static object list while collecting generations 0..N,
 * which is then appended to the static object list of generation N+1.
 */
83
84
static StgClosure* static_objects;      // live static objects
StgClosure* scavenged_static_objects;   // static objects scavenged so far
85
86
87
88
89
90
91
92
93
94
95
96

/* N is the oldest generation being collected, where the generations
 * are numbered starting at 0.  A major GC (indicated by the major_gc
 * flag) is when we're collecting all generations.  We only attempt to
 * deal with static objects and GC CAFs when doing a major GC.
 */
static nat N;
static rtsBool major_gc;

/* Youngest generation that objects should be evacuated to in
 * evacuate().  (Logically an argument to evacuate, but it's static
 * a lot of the time so we optimise it into a global variable).
97
 */
98
static nat evac_gen;
99

100
/* Weak pointers
101
 */
102
StgWeak *old_weak_ptr_list; // also pending finaliser list
103
104
105
106
107
108

/* Which stage of processing various kinds of weak pointer are we at?
 * (see traverse_weak_ptr_list() below for discussion).
 */
typedef enum { WeakPtrs, WeakThreads, WeakDone } WeakStage;
static WeakStage weak_stage;
109

110
111
112
/* List of all threads during GC
 */
static StgTSO *old_all_threads;
113
StgTSO *resurrected_threads;
114

115
116
/* Flag indicating failure to evacuate an object to the desired
 * generation.
117
 */
118
static rtsBool failed_to_evac;
119

120
121
/* Old to-space (used for two-space collector only)
 */
122
static bdescr *old_to_blocks;
123

124
125
/* Data used for allocation area sizing.
 */
126
127
static lnat new_blocks;		 // blocks allocated during this GC 
static lnat g0s0_pcnt_kept = 30; // percentage of g0s0 live at last minor GC 
128

129
130
/* Used to avoid long recursion due to selector thunks
 */
131
static lnat thunk_selector_depth = 0;
132
#define MAX_THUNK_SELECTOR_DEPTH 8
133

134
135
136
137
/* -----------------------------------------------------------------------------
   Static function declarations
   -------------------------------------------------------------------------- */

138
static bdescr *     gc_alloc_block          ( step *stp );
139
static void         mark_root               ( StgClosure **root );
140
141
142

// Use a register argument for evacuate, if available.
#if __GNUC__ >= 2
143
#define REGPARM1 __attribute__((regparm(1)))
144
#else
145
#define REGPARM1
146
147
#endif

148
149
REGPARM1 static StgClosure * evacuate (StgClosure *q);

150
static void         zero_static_object_list ( StgClosure* first_static );
151

152
static rtsBool      traverse_weak_ptr_list  ( void );
153
static void         mark_weak_ptr_list      ( StgWeak **list );
154

155
156
static StgClosure * eval_thunk_selector     ( nat field, StgSelector * p );

157
158
159
160
161
162
163
164
165
166
167
168

static void    scavenge                ( step * );
static void    scavenge_mark_stack     ( void );
static void    scavenge_stack          ( StgPtr p, StgPtr stack_end );
static rtsBool scavenge_one            ( StgPtr p );
static void    scavenge_large          ( step * );
static void    scavenge_static         ( void );
static void    scavenge_mutable_list   ( generation *g );

static void    scavenge_large_bitmap   ( StgPtr p, 
					 StgLargeBitmap *large_bitmap, 
					 nat size );
169

170
#if 0 && defined(DEBUG)
171
static void         gcCAFs                  ( void );
172
173
#endif

174
175
176
177
178
179
180
181
182
183
184
/* -----------------------------------------------------------------------------
   inline functions etc. for dealing with the mark bitmap & stack.
   -------------------------------------------------------------------------- */

#define MARK_STACK_BLOCKS 4

static bdescr *mark_stack_bdescr;
static StgPtr *mark_stack;
static StgPtr *mark_sp;
static StgPtr *mark_splim;

185
186
187
188
189
190
// Flag and pointers used for falling back to a linear scan when the
// mark stack overflows.
static rtsBool mark_stack_overflowed;
static bdescr *oldgen_scan_bd;
static StgPtr  oldgen_scan;

sof's avatar
sof committed
191
STATIC_INLINE rtsBool
192
193
194
195
196
mark_stack_empty(void)
{
    return mark_sp == mark_stack;
}

sof's avatar
sof committed
197
STATIC_INLINE rtsBool
198
199
200
201
202
mark_stack_full(void)
{
    return mark_sp >= mark_splim;
}

sof's avatar
sof committed
203
STATIC_INLINE void
204
205
206
207
208
reset_mark_stack(void)
{
    mark_sp = mark_stack;
}

sof's avatar
sof committed
209
STATIC_INLINE void
210
211
212
213
push_mark_stack(StgPtr p)
{
    *mark_sp++ = p;
}
214

sof's avatar
sof committed
215
STATIC_INLINE StgPtr
216
217
218
219
pop_mark_stack(void)
{
    return *--mark_sp;
}
220

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
/* -----------------------------------------------------------------------------
   Allocate a new to-space block in the given step.
   -------------------------------------------------------------------------- */

static bdescr *
gc_alloc_block(step *stp)
{
    bdescr *bd = allocBlock();
    bd->gen_no = stp->gen_no;
    bd->step = stp;
    bd->link = NULL;

    // blocks in to-space in generations up to and including N
    // get the BF_EVACUATED flag.
    if (stp->gen_no <= N) {
	bd->flags = BF_EVACUATED;
    } else {
	bd->flags = 0;
    }

    // Start a new to-space block, chain it on after the previous one.
    if (stp->hp_bd == NULL) {
	stp->hp_bd = bd;
    } else {
	stp->hp_bd->free = stp->hp;
	stp->hp_bd->link = bd;
	stp->hp_bd = bd;
    }

    stp->hp    = bd->start;
    stp->hpLim = stp->hp + BLOCK_SIZE_W;

    stp->n_to_blocks++;
    new_blocks++;

    return bd;
}

259
260
261
/* -----------------------------------------------------------------------------
   GarbageCollect

262
263
   Rough outline of the algorithm: for garbage collecting generation N
   (and all younger generations):
264
265

     - follow all pointers in the root set.  the root set includes all 
266
       mutable objects in all generations (mutable_list).
267
268

     - for each pointer, evacuate the object it points to into either
269
270
271
272
273
274
275
276
277

       + to-space of the step given by step->to, which is the next
         highest step in this generation or the first step in the next
         generation if this is the last step.

       + to-space of generations[evac_gen]->steps[0], if evac_gen != 0.
         When we evacuate an object we attempt to evacuate
         everything it points to into the same generation - this is
         achieved by setting evac_gen to the desired generation.  If
278
         we can't do this, then an entry in the mut list has to
279
280
281
282
         be made for the cross-generation pointer.

       + if the object is already in a generation > N, then leave
         it alone.
283
284
285
286
287
288

     - repeatedly scavenge to-space from each step in each generation
       being collected until no more objects can be evacuated.
      
     - free from-space in each step, and set from-space = to-space.

sof's avatar
sof committed
289
290
   Locks held: sched_mutex

291
292
   -------------------------------------------------------------------------- */

293
294
void
GarbageCollect ( void (*get_roots)(evac_fn), rtsBool force_major_gc )
295
{
296
  bdescr *bd;
297
  step *stp;
298
  lnat live, allocated, collected = 0, copied = 0;
299
  lnat oldgen_saved_blocks = 0;
300
301
  nat g, s;

302
303
304
305
#ifdef PROFILING
  CostCentreStack *prev_CCS;
#endif

306
#if defined(DEBUG) && defined(GRAN)
307
  IF_DEBUG(gc, debugBelch("@@ Starting garbage collection at %ld (%lx)\n", 
308
		     Now, Now));
309
310
#endif

sof's avatar
sof committed
311
#if defined(RTS_USER_SIGNALS)
312
313
  // block signals
  blockUserSignals();
314
#endif
315

316
317
318
  // tell the STM to discard any cached closures its hoping to re-use
  stmPreGCHook();

319
  // tell the stats department that we've started a GC 
320
321
  stat_startGC();

322
  // Init stats and print par specific (timing) info 
323
324
  PAR_TICKY_PAR_START();

325
  // attribute any costs to CCS_GC 
326
327
328
329
330
#ifdef PROFILING
  prev_CCS = CCCS;
  CCCS = CCS_GC;
#endif

331
332
333
  /* Approximate how much we allocated.  
   * Todo: only when generating stats? 
   */
334
  allocated = calcAllocated();
335
336
337

  /* Figure out which generation to collect
   */
338
339
340
341
342
343
  if (force_major_gc) {
    N = RtsFlags.GcFlags.generations - 1;
    major_gc = rtsTrue;
  } else {
    N = 0;
    for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
344
345
346
      if (generations[g].steps[0].n_blocks +
	  generations[g].steps[0].n_large_blocks
	  >= generations[g].max_blocks) {
347
348
        N = g;
      }
349
    }
350
    major_gc = (N == RtsFlags.GcFlags.generations-1);
351
352
  }

353
354
355
356
357
358
#ifdef RTS_GTK_FRONTPANEL
  if (RtsFlags.GcFlags.frontpanel) {
      updateFrontPanelBeforeGC(N);
  }
#endif

359
  // check stack sanity *before* GC (ToDo: check all threads) 
360
361
362
#if defined(GRAN)
  // ToDo!: check sanity  IF_DEBUG(sanity, checkTSOsSanity());
#endif
363
  IF_DEBUG(sanity, checkFreeListSanity());
364

365
366
  /* Initialise the static object lists
   */
367
368
369
  static_objects = END_OF_STATIC_LIST;
  scavenged_static_objects = END_OF_STATIC_LIST;

370
371
372
  /* Save the old to-space if we're doing a two-space collection
   */
  if (RtsFlags.GcFlags.generations == 1) {
373
374
    old_to_blocks = g0s0->to_blocks;
    g0s0->to_blocks = NULL;
375
    g0s0->n_to_blocks = 0;
376
377
  }

378
379
380
381
382
  /* Keep a count of how many new blocks we allocated during this GC
   * (used for resizing the allocation area, later).
   */
  new_blocks = 0;

383
384
385
  // Initialise to-space in all the generations/steps that we're
  // collecting.
  //
386
  for (g = 0; g <= N; g++) {
387
388
389
390
391
392
393
394

    // throw away the mutable list.  Invariant: the mutable list
    // always has at least one block; this means we can avoid a check for
    // NULL in recordMutable().
    if (g != 0) {
	freeChain(generations[g].mut_list);
	generations[g].mut_list = allocBlock();
    }
395
396

    for (s = 0; s < generations[g].n_steps; s++) {
397

398
      // generation 0, step 0 doesn't need to-space 
399
400
401
402
      if (g == 0 && s == 0 && RtsFlags.GcFlags.generations > 1) { 
	continue; 
      }

403
      stp = &generations[g].steps[s];
404
      ASSERT(stp->gen_no == g);
405
406
407
408
409
410
411
412
413

      // start a new to-space for this step.
      stp->hp        = NULL;
      stp->hp_bd     = NULL;
      stp->to_blocks = NULL;

      // allocate the first to-space block; extra blocks will be
      // chained on as necessary.
      bd = gc_alloc_block(stp);
414
415
416
      stp->to_blocks   = bd;
      stp->scan        = bd->start;
      stp->scan_bd     = bd;
417
418

      // initialise the large object queues.
419
420
      stp->new_large_objects = NULL;
      stp->scavenged_large_objects = NULL;
421
      stp->n_scavenged_large_blocks = 0;
422

423
      // mark the large objects as not evacuated yet 
424
      for (bd = stp->large_objects; bd; bd = bd->link) {
425
	bd->flags &= ~BF_EVACUATED;
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
      }

      // for a compacted step, we need to allocate the bitmap
      if (stp->is_compacted) {
	  nat bitmap_size; // in bytes
	  bdescr *bitmap_bdescr;
	  StgWord *bitmap;

	  bitmap_size = stp->n_blocks * BLOCK_SIZE / (sizeof(W_)*BITS_PER_BYTE);

	  if (bitmap_size > 0) {
	      bitmap_bdescr = allocGroup((nat)BLOCK_ROUND_UP(bitmap_size) 
					 / BLOCK_SIZE);
	      stp->bitmap = bitmap_bdescr;
	      bitmap = bitmap_bdescr->start;
	      
442
	      IF_DEBUG(gc, debugBelch("bitmap_size: %d, bitmap: %p",
443
444
445
446
447
				   bitmap_size, bitmap););
	      
	      // don't forget to fill it with zeros!
	      memset(bitmap, 0, bitmap_size);
	      
448
	      // For each block in this step, point to its bitmap from the
449
450
451
452
	      // block descriptor.
	      for (bd=stp->blocks; bd != NULL; bd = bd->link) {
		  bd->u.bitmap = bitmap;
		  bitmap += BLOCK_SIZE_W / (sizeof(W_)*BITS_PER_BYTE);
453
454
455
456
457
458
459

		  // Also at this point we set the BF_COMPACTED flag
		  // for this block.  The invariant is that
		  // BF_COMPACTED is always unset, except during GC
		  // when it is set on those blocks which will be
		  // compacted.
		  bd->flags |= BF_COMPACTED;
460
461
	      }
	  }
462
463
464
465
466
      }
    }
  }

  /* make sure the older generations have at least one block to
467
   * allocate into (this makes things easier for copy(), see below).
468
469
470
   */
  for (g = N+1; g < RtsFlags.GcFlags.generations; g++) {
    for (s = 0; s < generations[g].n_steps; s++) {
471
472
      stp = &generations[g].steps[s];
      if (stp->hp_bd == NULL) {
473
	  ASSERT(stp->blocks == NULL);
474
	  bd = gc_alloc_block(stp);
475
476
	  stp->blocks = bd;
	  stp->n_blocks = 1;
477
478
479
      }
      /* Set the scan pointer for older generations: remember we
       * still have to scavenge objects that have been promoted. */
480
481
      stp->scan = stp->hp;
      stp->scan_bd = stp->hp_bd;
482
483
      stp->to_blocks = NULL;
      stp->n_to_blocks = 0;
484
485
      stp->new_large_objects = NULL;
      stp->scavenged_large_objects = NULL;
486
      stp->n_scavenged_large_blocks = 0;
487
488
    }
  }
489

490
491
492
493
494
495
496
497
498
499
500
  /* Allocate a mark stack if we're doing a major collection.
   */
  if (major_gc) {
      mark_stack_bdescr = allocGroup(MARK_STACK_BLOCKS);
      mark_stack = (StgPtr *)mark_stack_bdescr->start;
      mark_sp    = mark_stack;
      mark_splim = mark_stack + (MARK_STACK_BLOCKS * BLOCK_SIZE_W);
  } else {
      mark_stack_bdescr = NULL;
  }

501
  /* -----------------------------------------------------------------------
502
   * follow all the roots that we know about:
503
504
505
506
507
508
509
510
511
512
513
   *   - mutable lists from each generation > N
   * we want to *scavenge* these roots, not evacuate them: they're not
   * going to move in this GC.
   * Also: do them in reverse generation order.  This is because we
   * often want to promote objects that are pointed to by older
   * generations early, so we don't have to repeatedly copy them.
   * Doing the generations in reverse order ensures that we don't end
   * up in the situation where we want to evac an object to gen 3 and
   * it has already been evaced to gen 2.
   */
  { 
514
515
    int st;
    for (g = RtsFlags.GcFlags.generations-1; g > N; g--) {
516
      generations[g].saved_mut_list = generations[g].mut_list;
517
518
      generations[g].mut_list = allocBlock(); 
        // mut_list always has at least one block.
519
    }
520

521
    for (g = RtsFlags.GcFlags.generations-1; g > N; g--) {
522
      IF_PAR_DEBUG(verbose, printMutableList(&generations[g]));
523
524
525
526
      scavenge_mutable_list(&generations[g]);
      evac_gen = g;
      for (st = generations[g].n_steps-1; st >= 0; st--) {
	scavenge(&generations[g].steps[st]);
527
528
      }
    }
529
530
  }

531
532
533
534
  /* follow roots from the CAF list (used by GHCi)
   */
  evac_gen = 0;
  markCAFs(mark_root);
535

536
537
538
  /* follow all the roots that the application knows about.
   */
  evac_gen = 0;
539
  get_roots(mark_root);
540

541
542
543
544
545
546
547
548
549
#if defined(PAR)
  /* And don't forget to mark the TSO if we got here direct from
   * Haskell! */
  /* Not needed in a seq version?
  if (CurrentTSO) {
    CurrentTSO = (StgTSO *)MarkRoot((StgClosure *)CurrentTSO);
  }
  */

550
  // Mark the entries in the GALA table of the parallel system 
551
  markLocalGAs(major_gc);
552
  // Mark all entries on the list of pending fetches 
553
  markPendingFetches(major_gc);
554
555
#endif

556
557
558
  /* Mark the weak pointer list, and prepare to detect dead weak
   * pointers.
   */
559
  mark_weak_ptr_list(&weak_ptr_list);
560
561
  old_weak_ptr_list = weak_ptr_list;
  weak_ptr_list = NULL;
562
  weak_stage = WeakPtrs;
563

564
565
566
567
568
569
570
  /* The all_threads list is like the weak_ptr_list.  
   * See traverse_weak_ptr_list() for the details.
   */
  old_all_threads = all_threads;
  all_threads = END_TSO_QUEUE;
  resurrected_threads = END_TSO_QUEUE;

571
572
  /* Mark the stable pointer table.
   */
573
  markStablePtrTable(mark_root);
574

575
576
577
  /* -------------------------------------------------------------------------
   * Repeatedly scavenge all the areas we know about until there's no
   * more scavenging to be done.
578
579
   */
  { 
580
    rtsBool flag;
581
  loop:
582
583
    flag = rtsFalse;

584
    // scavenge static objects 
585
    if (major_gc && static_objects != END_OF_STATIC_LIST) {
586
587
588
589
	IF_DEBUG(sanity, checkStaticObjects(static_objects));
	scavenge_static();
    }

590
591
592
593
594
595
596
597
598
    /* When scavenging the older generations:  Objects may have been
     * evacuated from generations <= N into older generations, and we
     * need to scavenge these objects.  We're going to try to ensure that
     * any evacuations that occur move the objects into at least the
     * same generation as the object being scavenged, otherwise we
     * have to create new entries on the mutable list for the older
     * generation.
     */

599
    // scavenge each step in generations 0..maxgen 
600
    { 
ken's avatar
ken committed
601
602
      long gen;
      int st; 
603

604
    loop2:
605
      // scavenge objects in compacted generation
606
607
      if (mark_stack_overflowed || oldgen_scan_bd != NULL ||
	  (mark_stack_bdescr != NULL && !mark_stack_empty())) {
608
609
610
611
	  scavenge_mark_stack();
	  flag = rtsTrue;
      }

ken's avatar
ken committed
612
613
      for (gen = RtsFlags.GcFlags.generations; --gen >= 0; ) {
	for (st = generations[gen].n_steps; --st >= 0; ) {
614
	  if (gen == 0 && st == 0 && RtsFlags.GcFlags.generations > 1) { 
615
616
	    continue; 
	  }
617
	  stp = &generations[gen].steps[st];
618
	  evac_gen = gen;
619
620
	  if (stp->hp_bd != stp->scan_bd || stp->scan < stp->hp) {
	    scavenge(stp);
621
	    flag = rtsTrue;
622
	    goto loop2;
623
	  }
624
625
	  if (stp->new_large_objects != NULL) {
	    scavenge_large(stp);
626
	    flag = rtsTrue;
627
	    goto loop2;
628
629
630
	  }
	}
      }
631
    }
632

633
634
    if (flag) { goto loop; }

635
636
    // must be last...  invariant is that everything is fully
    // scavenged at this point.
637
    if (traverse_weak_ptr_list()) { // returns rtsTrue if evaced something 
638
639
640
641
      goto loop;
    }
  }

642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
  /* Update the pointers from the "main thread" list - these are
   * treated as weak pointers because we want to allow a main thread
   * to get a BlockedOnDeadMVar exception in the same way as any other
   * thread.  Note that the threads should all have been retained by
   * GC by virtue of being on the all_threads list, we're just
   * updating pointers here.
   */
  {
      StgMainThread *m;
      StgTSO *tso;
      for (m = main_threads; m != NULL; m = m->link) {
	  tso = (StgTSO *) isAlive((StgClosure *)m->tso);
	  if (tso == NULL) {
	      barf("main thread has been GC'd");
	  }
	  m->tso = tso;
      }
  }

661
#if defined(PAR)
662
  // Reconstruct the Global Address tables used in GUM 
663
664
665
666
  rebuildGAtables(major_gc);
  IF_DEBUG(sanity, checkLAGAtable(rtsTrue/*check closures, too*/));
#endif

667
668
669
670
671
672
673
674
  // Now see which stable names are still alive.
  gcStablePtrTable();

  // Tidy the end of the to-space chains 
  for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
      for (s = 0; s < generations[g].n_steps; s++) {
	  stp = &generations[g].steps[s];
	  if (!(g == 0 && s == 0 && RtsFlags.GcFlags.generations > 1)) {
675
	      ASSERT(Bdescr(stp->hp) == stp->hp_bd);
676
677
	      stp->hp_bd->free = stp->hp;
	  }
678
      }
679
  }
680

681
682
683
#ifdef PROFILING
  // We call processHeapClosureForDead() on every closure destroyed during
  // the current garbage collection, so we invoke LdvCensusForDead().
684
685
  if (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_LDV
      || RtsFlags.ProfFlags.bioSelector != NULL)
686
687
688
    LdvCensusForDead(N);
#endif

689
690
  // NO MORE EVACUATION AFTER THIS POINT!
  // Finally: compaction of the oldest generation.
691
  if (major_gc && oldest_gen->steps[0].is_compacted) {
692
693
      // save number of blocks for stats
      oldgen_saved_blocks = oldest_gen->steps[0].n_blocks;
694
695
696
697
698
      compact(get_roots);
  }

  IF_DEBUG(sanity, checkGlobalTSOList(rtsFalse));

699
700
  /* run through all the generations/steps and tidy up 
   */
701
  copied = new_blocks * BLOCK_SIZE_W;
702
  for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
703
704

    if (g <= N) {
705
      generations[g].collections++; // for stats 
706
707
    }

708
709
710
711
712
713
714
715
    // Count the mutable list as bytes "copied" for the purposes of
    // stats.  Every mutable list is copied during every GC.
    if (g > 0) {
	for (bd = generations[g].mut_list; bd != NULL; bd = bd->link) {
	    copied += (bd->free - bd->start) * sizeof(StgWord);
	}
    }

716
717
    for (s = 0; s < generations[g].n_steps; s++) {
      bdescr *next;
718
      stp = &generations[g].steps[s];
719

720
      if (!(g == 0 && s == 0 && RtsFlags.GcFlags.generations > 1)) {
721
	// stats information: how much we copied 
722
	if (g <= N) {
723
724
	  copied -= stp->hp_bd->start + BLOCK_SIZE_W -
	    stp->hp_bd->free;
725
	}
726
727
      }

728
      // for generations we collected... 
729
730
      if (g <= N) {

731
732
733
734
735
736
	  // rough calculation of garbage collected, for stats output
	  if (stp->is_compacted) {
	      collected += (oldgen_saved_blocks - stp->n_blocks) * BLOCK_SIZE_W;
	  } else {
	      collected += stp->n_blocks * BLOCK_SIZE_W;
	  }
737
738
739
740
741
742

	/* free old memory and shift to-space into from-space for all
	 * the collected steps (except the allocation area).  These
	 * freed blocks will probaby be quickly recycled.
	 */
	if (!(g == 0 && s == 0)) {
743
744
745
746
	    if (stp->is_compacted) {
		// for a compacted step, just shift the new to-space
		// onto the front of the now-compacted existing blocks.
		for (bd = stp->to_blocks; bd != NULL; bd = bd->link) {
747
		    bd->flags &= ~BF_EVACUATED;  // now from-space 
748
749
750
751
752
753
754
755
756
757
		}
		// tack the new blocks on the end of the existing blocks
		if (stp->blocks == NULL) {
		    stp->blocks = stp->to_blocks;
		} else {
		    for (bd = stp->blocks; bd != NULL; bd = next) {
			next = bd->link;
			if (next == NULL) {
			    bd->link = stp->to_blocks;
			}
758
759
760
761
762
			// NB. this step might not be compacted next
			// time, so reset the BF_COMPACTED flags.
			// They are set before GC if we're going to
			// compact.  (search for BF_COMPACTED above).
			bd->flags &= ~BF_COMPACTED;
763
764
765
766
767
768
769
770
771
		    }
		}
		// add the new blocks to the block tally
		stp->n_blocks += stp->n_to_blocks;
	    } else {
		freeChain(stp->blocks);
		stp->blocks = stp->to_blocks;
		stp->n_blocks = stp->n_to_blocks;
		for (bd = stp->blocks; bd != NULL; bd = bd->link) {
772
		    bd->flags &= ~BF_EVACUATED;	 // now from-space 
773
774
775
776
		}
	    }
	    stp->to_blocks = NULL;
	    stp->n_to_blocks = 0;
777
778
779
780
781
782
783
	}

	/* LARGE OBJECTS.  The current live large objects are chained on
	 * scavenged_large, having been moved during garbage
	 * collection from large_objects.  Any objects left on
	 * large_objects list are therefore dead, so we free them here.
	 */
784
	for (bd = stp->large_objects; bd != NULL; bd = next) {
785
786
787
788
	  next = bd->link;
	  freeGroup(bd);
	  bd = next;
	}
789
790

	// update the count of blocks used by large objects
791
	for (bd = stp->scavenged_large_objects; bd != NULL; bd = bd->link) {
792
	  bd->flags &= ~BF_EVACUATED;
793
	}
794
795
	stp->large_objects  = stp->scavenged_large_objects;
	stp->n_large_blocks = stp->n_scavenged_large_blocks;
796
797

      } else {
798
	// for older generations... 
799
800
801
802
803
	
	/* For older generations, we need to append the
	 * scavenged_large_object list (i.e. large objects that have been
	 * promoted during this GC) to the large_object list for that step.
	 */
804
	for (bd = stp->scavenged_large_objects; bd; bd = next) {
805
	  next = bd->link;
806
	  bd->flags &= ~BF_EVACUATED;
807
	  dbl_link_onto(bd, &stp->large_objects);
808
809
	}

810
811
	// add the new blocks we promoted during this GC 
	stp->n_blocks += stp->n_to_blocks;
812
	stp->n_to_blocks = 0;
813
	stp->n_large_blocks += stp->n_scavenged_large_blocks;
814
815
816
      }
    }
  }
817

818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
  /* Reset the sizes of the older generations when we do a major
   * collection.
   *
   * CURRENT STRATEGY: make all generations except zero the same size.
   * We have to stay within the maximum heap size, and leave a certain
   * percentage of the maximum heap size available to allocate into.
   */
  if (major_gc && RtsFlags.GcFlags.generations > 1) {
      nat live, size, min_alloc;
      nat max  = RtsFlags.GcFlags.maxHeapSize;
      nat gens = RtsFlags.GcFlags.generations;

      // live in the oldest generations
      live = oldest_gen->steps[0].n_blocks +
	     oldest_gen->steps[0].n_large_blocks;

      // default max size for all generations except zero
      size = stg_max(live * RtsFlags.GcFlags.oldGenFactor,
		     RtsFlags.GcFlags.minOldGenSize);

      // minimum size for generation zero
839
840
841
842
843
      min_alloc = stg_max((RtsFlags.GcFlags.pcFreeHeap * max) / 200,
			  RtsFlags.GcFlags.minAllocAreaSize);

      // Auto-enable compaction when the residency reaches a
      // certain percentage of the maximum heap size (default: 30%).
844
845
846
847
848
      if (RtsFlags.GcFlags.generations > 1 &&
	  (RtsFlags.GcFlags.compact ||
	   (max > 0 &&
	    oldest_gen->steps[0].n_blocks > 
	    (RtsFlags.GcFlags.compactThreshold * max) / 100))) {
849
	  oldest_gen->steps[0].is_compacted = 1;
850
//	  debugBelch("compaction: on\n", live);
851
852
      } else {
	  oldest_gen->steps[0].is_compacted = 0;
853
//	  debugBelch("compaction: off\n", live);
854
      }
855
856
857
858
859
860

      // if we're going to go over the maximum heap size, reduce the
      // size of the generations accordingly.  The calculation is
      // different if compaction is turned on, because we don't need
      // to double the space required to collect the old generation.
      if (max != 0) {
861
862
863
864
865
866
867
868

	  // this test is necessary to ensure that the calculations
	  // below don't have any negative results - we're working
	  // with unsigned values here.
	  if (max < min_alloc) {
	      heapOverflow();
	  }

869
	  if (oldest_gen->steps[0].is_compacted) {
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
	      if ( (size + (size - 1) * (gens - 2) * 2) + min_alloc > max ) {
		  size = (max - min_alloc) / ((gens - 1) * 2 - 1);
	      }
	  } else {
	      if ( (size * (gens - 1) * 2) + min_alloc > max ) {
		  size = (max - min_alloc) / ((gens - 1) * 2);
	      }
	  }

	  if (size < live) {
	      heapOverflow();
	  }
      }

#if 0
885
      debugBelch("live: %d, min_alloc: %d, size : %d, max = %d\n", live,
886
887
888
889
890
891
892
893
894
	      min_alloc, size, max);
#endif

      for (g = 0; g < gens; g++) {
	  generations[g].max_blocks = size;
      }
  }

  // Guess the amount of live data for stats.
895
896
  live = calcLive();

897
898
899
900
901
902
903
904
  /* Free the small objects allocated via allocate(), since this will
   * all have been copied into G0S1 now.  
   */
  if (small_alloc_list != NULL) {
    freeChain(small_alloc_list);
  }
  small_alloc_list = NULL;
  alloc_blocks = 0;
905
906
  alloc_Hp = NULL;
  alloc_HpLim = NULL;
907
908
  alloc_blocks_lim = RtsFlags.GcFlags.minAllocAreaSize;

909
910
911
  // Start a new pinned_object_block
  pinned_object_block = NULL;

912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
  /* Free the mark stack.
   */
  if (mark_stack_bdescr != NULL) {
      freeGroup(mark_stack_bdescr);
  }

  /* Free any bitmaps.
   */
  for (g = 0; g <= N; g++) {
      for (s = 0; s < generations[g].n_steps; s++) {
	  stp = &generations[g].steps[s];
	  if (stp->is_compacted && stp->bitmap != NULL) {
	      freeGroup(stp->bitmap);
	  }
      }
  }

929
930
931
932
  /* Two-space collector:
   * Free the old to-space, and estimate the amount of live data.
   */
  if (RtsFlags.GcFlags.generations == 1) {
933
934
    nat blocks;
    
935
936
    if (old_to_blocks != NULL) {
      freeChain(old_to_blocks);
937
    }
938
939
    for (bd = g0s0->to_blocks; bd != NULL; bd = bd->link) {
      bd->flags = 0;	// now from-space 
940
    }
941

942
943
944
    /* For a two-space collector, we need to resize the nursery. */
    
    /* set up a new nursery.  Allocate a nursery size based on a
945
946
947
     * function of the amount of live data (by default a factor of 2)
     * Use the blocks from the old nursery if possible, freeing up any
     * left over blocks.
948
949
950
951
952
953
954
955
     *
     * If we get near the maximum heap size, then adjust our nursery
     * size accordingly.  If the nursery is the same size as the live
     * data (L), then we need 3L bytes.  We can reduce the size of the
     * nursery to bring the required memory down near 2L bytes.
     * 
     * A normal 2-space collector would need 4L bytes to give the same
     * performance we get from 3L bytes, reducing to the same
956
     * performance at 2L bytes.
957
     */
958
    blocks = g0s0->n_to_blocks;
959

960
961
962
    if ( RtsFlags.GcFlags.maxHeapSize != 0 &&
	 blocks * RtsFlags.GcFlags.oldGenFactor * 2 > 
	   RtsFlags.GcFlags.maxHeapSize ) {
ken's avatar
ken committed
963
      long adjusted_blocks;  // signed on purpose 
964
965
966
      int pc_free; 
      
      adjusted_blocks = (RtsFlags.GcFlags.maxHeapSize - 2 * blocks);
967
      IF_DEBUG(gc, debugBelch("@@ Near maximum heap size of 0x%x blocks, blocks = %d, adjusted to %ld", RtsFlags.GcFlags.maxHeapSize, blocks, adjusted_blocks));
968
969
970
971
972
973
974
975
976
977
978
979
      pc_free = adjusted_blocks * 100 / RtsFlags.GcFlags.maxHeapSize;
      if (pc_free < RtsFlags.GcFlags.pcFreeHeap) /* might even be < 0 */ {
	heapOverflow();
      }
      blocks = adjusted_blocks;
      
    } else {
      blocks *= RtsFlags.GcFlags.oldGenFactor;
      if (blocks < RtsFlags.GcFlags.minAllocAreaSize) {
	blocks = RtsFlags.GcFlags.minAllocAreaSize;
      }
    }
980
    resizeNursery(blocks);
981
    
982
  } else {
983
    /* Generational collector:
984
985
     * If the user has given us a suggested heap size, adjust our
     * allocation area to make best use of the memory available.
986
987
988
     */

    if (RtsFlags.GcFlags.heapSizeSuggestion) {
ken's avatar
ken committed
989
      long blocks;
990
      nat needed = calcNeeded(); 	// approx blocks needed at next GC 
991
992

      /* Guess how much will be live in generation 0 step 0 next time.
993
       * A good approximation is obtained by finding the
994
       * percentage of g0s0 that was live at the last minor GC.
995
       */
996
997
      if (N == 0) {
	g0s0_pcnt_kept = (new_blocks * 100) / g0s0->n_blocks;
998
999
      }

1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
      /* Estimate a size for the allocation area based on the
       * information available.  We might end up going slightly under
       * or over the suggested heap size, but we should be pretty
       * close on average.
       *
       * Formula:            suggested - needed
       *                ----------------------------
       *                    1 + g0s0_pcnt_kept/100
       *
       * where 'needed' is the amount of memory needed at the next
       * collection for collecting all steps except g0s0.
1011
       */
1012
      blocks = 
ken's avatar
ken committed
1013
1014
	(((long)RtsFlags.GcFlags.heapSizeSuggestion - (long)needed) * 100) /
	(100 + (long)g0s0_pcnt_kept);
1015
      
ken's avatar
ken committed
1016
      if (blocks < (long)RtsFlags.GcFlags.minAllocAreaSize) {
1017
	blocks = RtsFlags.GcFlags.minAllocAreaSize;
1018
      }
1019
1020
      
      resizeNursery((nat)blocks);
1021
1022
1023
1024
1025

    } else {
      // we might have added extra large blocks to the nursery, so
      // resize back to minAllocAreaSize again.
      resizeNursery(RtsFlags.GcFlags.minAllocAreaSize);
1026
    }
1027
1028
  }

1029
1030
 // mark the garbage collected CAFs as dead 
#if 0 && defined(DEBUG) // doesn't work at the moment 
1031
  if (major_gc) { gcCAFs(); }
1032
1033
#endif
  
1034
1035
1036
1037
1038
1039
#ifdef PROFILING
  // resetStaticObjectForRetainerProfiling() must be called before
  // zeroing below.
  resetStaticObjectForRetainerProfiling();
#endif

1040
  // zero the scavenged static object list 
1041
  if (major_gc) {
1042
    zero_static_object_list(scavenged_static_objects);
1043
  }
1044

1045
  // Reset the nursery
1046
  resetNurseries();
1047

sof's avatar
sof committed
1048
1049
  RELEASE_LOCK(&sched_mutex);
  
1050
  // start any pending finalizers 
1051
  scheduleFinalizers(old_weak_ptr_list);
1052
  
sof's avatar
sof committed
1053
1054
1055
  // send exceptions to any threads which were about to die 
  resurrectThreads(resurrected_threads);
  
sof's avatar
sof committed
1056
1057
  ACQUIRE_LOCK(&sched_mutex);

1058
1059
  // Update the stable pointer hash table.
  updateStablePtrTable(major_gc);
1060

1061
1062
1063
1064
1065
  // check sanity after GC 
  IF_DEBUG(sanity, checkSanity());

  // extra GC trace info 
  IF_DEBUG(gc, statDescribeGens());
1066
1067

#ifdef DEBUG
1068
1069
  // symbol-table based profiling 
  /*  heapCensus(to_blocks); */ /* ToDo */
1070
1071
#endif

1072
  // restore enclosing cost centre 
1073
1074
1075
1076
#ifdef PROFILING
  CCCS = prev_CCS;
#endif

1077
  // check for memory leaks if sanity checking is on 
1078
1079
  IF_DEBUG(sanity, memInventory());

1080
1081
#ifdef RTS_GTK_FRONTPANEL
  if (RtsFlags.GcFlags.frontpanel) {
1082
1083
1084
1085
      updateFrontPanelAfterGC( N, live );
  }
#endif

1086
  // ok, GC over: tell the stats department what happened. 
1087
  stat_endGC(allocated, collected, live, copied, N);
1088

sof's avatar
sof committed
1089
#if defined(RTS_USER_SIGNALS)
1090
1091
  // unblock signals again
  unblockUserSignals();
1092
#endif
1093

1094
  //PAR_TICKY_TP();
1095
1096
}

1097

1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
/* -----------------------------------------------------------------------------
   Weak Pointers

   traverse_weak_ptr_list is called possibly many times during garbage
   collection.  It returns a flag indicating whether it did any work
   (i.e. called evacuate on any live pointers).

   Invariant: traverse_weak_ptr_list is called when the heap is in an
   idempotent state.  That means that there are no pending
   evacuate/scavenge operations.  This invariant helps the weak
   pointer code decide which weak pointers are dead - if there are no
   new live weak pointers, then all the currently unreachable ones are
   dead.
1111

1112
   For generational GC: we just don't try to finalize weak pointers in
1113
1114
1115
   older generations than the one we're collecting.  This could
   probably be optimised by keeping per-generation lists of weak
   pointers, but for a few weak pointers this scheme will work.
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139

   There are three distinct stages to processing weak pointers:

   - weak_stage == WeakPtrs

     We process all the weak pointers whos keys are alive (evacuate
     their values and finalizers), and repeat until we can find no new
     live keys.  If no live keys are found in this pass, then we
     evacuate the finalizers of all the dead weak pointers in order to
     run them.

   - weak_stage == WeakThreads

     Now, we discover which *threads* are still alive.  Pointers to
     threads from the all_threads and main thread lists are the
     weakest of all: a pointers from the finalizer of a dead weak
     pointer can keep a thread alive.  Any threads found to be unreachable
     are evacuated and placed on the resurrected_threads list so we 
     can send them a signal later.

   - weak_stage == WeakDone

     No more evacuation is done.

1140
1141
1142
1143
1144
1145
   -------------------------------------------------------------------------- */

static rtsBool 
traverse_weak_ptr_list(void)
{
  StgWeak *w, **last_w, *next_w;
1146
  StgClosure *new;
1147
1148
  rtsBool flag = rtsFalse;

1149
  switch (weak_stage) {
1150

1151
1152
  case WeakDone:
      return rtsFalse;
1153

1154
1155
1156
1157
1158
  case WeakPtrs:
      /* doesn't matter where we evacuate values/finalizers to, since
       * these pointers are treated as roots (iff the keys are alive).
       */
      evac_gen = 0;
1159
      
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
      last_w = &old_weak_ptr_list;
      for (w = old_weak_ptr_list; w != NULL; w = next_w) {
	  
	  /* There might be a DEAD_WEAK on the list if finalizeWeak# was
	   * called on a live weak pointer object.  Just remove it.
	   */
	  if (w->header.info == &stg_DEAD_WEAK_info) {
	      next_w = ((StgDeadWeak *)w)->link;
	      *last_w = next_w;
	      continue;
	  }
	  
1172
1173
1174
1175
1176
	  switch (get_itbl(w)->type) {

	  case EVACUATED:
	      next_w = (StgWeak *)((StgEvacuated *)w)->evacuee;
	      *last_w = next_w;
1177
	      continue;
1178
1179
1180
1181
1182
1183
1184
1185
1186