/* The invariant is

      *   created = converted + remaining + gcd + fizzled

      */

                             "(created == converted + remaining + gcd + fizzled)",

                             sparks.created, sparks.converted, remaining,

                             sparks.gcd, sparks.fizzled);

 /* CMM primop. Result is true on success, or false on allocation failure. */

 bool syncDelay(CapIOManager *iomgr, StgTSO *tso, HsInt us_delay)

 {

     ASSERT(tso->why_blocked == NotBlocked);

     switch (iomgr_type) {

 #if defined(IOMGR_ENABLED_SELECT)

     uint32_t i;

     for(i = 0; i < size; i++, bitmap >>= 1 ) {

         if ((bitmap & 1) == 0) {

             printPtr((P_)payload[i]);

             debugBelch(" -- ");

         StgWord bitmap = large_bitmap->bitmap[bmp];

         j = 0;

         for(; i < size && j < BITS_IN(W_); j++, i++, bitmap >>= 1 ) {

             if ((bitmap & 1) == 0) {

                 printPtr((P_)payload[i]);

                 debugBelch(" -- ");

   StgTRecHeader *__t = (_t);                                                    \

   StgTRecChunk *__c = __t -> current_chunk;                                     \

   StgWord __limit = __c -> next_entry_idx;                                      \

   while (__c != END_STM_CHUNK_LIST) {                                           \

     StgWord __i;                                                                \

     for (__i = 0; __i < __limit; __i ++) {                                      \

   if (sn != 0) {

     ASSERT(stable_name_table[sn].addr == p);

     stableNameUnlock();

     return sn;

   }

                 p->sn_obj = isAlive(p->sn_obj);

                 if (p->sn_obj == NULL) {

                     // StableName object died

                     freeSnEntry(p);

                 } else if (p->addr != NULL) {

                     // sn_obj is alive, update pointee

                 || (bh_info == &stg_WHITEHOLE_info))

             {

                 debugTrace(DEBUG_squeeze,

                 // If this closure is already an indirection, then

                 // suspend the computation up to this point.

         debugTrace(DEBUG_gc,

                    "threadStackOverflow of TSO %" FMT_StgThreadID " (%p): stack"

                    (long)tso->stackobj->stack_size, RtsFlags.GcFlags.maxStkSize);

         IF_DEBUG(gc,

                  /* If we're debugging, just print out the top of the stack */

     }

     debugTraceCap(DEBUG_sched, cap,

                   chunk_size * sizeof(W_));

     // Charge the current thread for allocating stack.  Stack usage is

   switch (UntagWhyBlocked(ACQUIRE_LOAD(&tso->why_blocked))) {

 #if defined(mingw32_HOST_OS)

     case BlockedOnDoProc:

     break;

 #endif

 #if !defined(THREADED_RTS)

 // -----------------------------------------------------------------------------

 #if defined(DEBUG)

 void traceEnd (void);

 #endif

         traceCap_(cap, msg, ##__VA_ARGS__);     \

     }

 /*

  * Emit a trace message

         trace_(msg, ##__VA_ARGS__);             \

     }

 /*

  * A message or event emitted by the program

         int res = ppoll(poll_table, nfds, &tv, NULL);

         debugTrace(DEBUG_iomanager,

                    nfds, res);

 #else

         int res = poll(poll_table, nfds, 0);

         debugTrace(DEBUG_iomanager,

                    nfds, res);

 #endif

         if (res == 0) {

         int res = ppoll(poll_table, nfds, timeout_ns, NULL);

         debugTrace(DEBUG_iomanager,

                    nfds, timeout_ns == NULL ? -1 : timeout_ns->tv_sec,

                          timeout_ns == NULL ?  0 : timeout_ns->tv_nsec,

                    res);

         int res = poll(poll_table, nfds, timeout_ms);

         debugTrace(DEBUG_iomanager,

                    nfds, timeout_ms, res);

 #endif

     insertTimeoutQueue(&iomgr->timeout_queue, timeout, target);

     debugTrace(DEBUG_iomanager,

                us_delay, target);

     return true;

 }

         if (now < waketime) {

             break;

         }

         StgTimeout *timeout;

         deleteMinTimeoutQueue(&iomgr->timeout_queue, &timeout);

         notifyTimeoutCompletion(iomgr, timeout);

     // 2. update forward ptrs

     for (W_ g = 0; g < RtsFlags.GcFlags.generations; g++) {

         generation *gen = &generations[g];

         update_fwd(gen->blocks);

         for (W_ n = 0; n < getNumCapabilities(); n++) {

         update_fwd_large(gen->scavenged_large_objects);

         update_fwd_cnf(gen->live_compact_objects);

         if (g == RtsFlags.GcFlags.generations-1 && gen->old_blocks != NULL) {

             update_fwd_compact(gen->old_blocks);

         }

     }

     if (gen->old_blocks != NULL) {

         W_ blocks = update_bkwd_compact(gen);

         debugTrace(DEBUG_gc,

                    gen->no, gen->n_old_blocks, blocks);

         gen->n_old_blocks = blocks;

     }

 #if defined(DEBUG)

         debugTrace(DEBUG_gc,

                    (unsigned long)(mut_list_size * sizeof(W_)),

                    mutlist_scav_stats.n_MUTVAR,

                    mutlist_scav_stats.n_MUTARR,

   // Free the mark stack.

   if (mark_stack_top_bd != NULL) {

                  countBlocks(mark_stack_top_bd));

       freeChain(mark_stack_top_bd);

   }

       need_copied_live = BLOCK_ROUND_UP(need_copied_live) / BLOCK_SIZE_W;

       need_uncopied_live = BLOCK_ROUND_UP(need_uncopied_live) / BLOCK_SIZE_W;

       // minOldGenSize states that the size of the oldest generation must be at least

       if (RtsFlags.GcFlags.minOldGenSize >= need_copied_live + need_uncopied_live){

         extra_needed = RtsFlags.GcFlags.minOldGenSize - (need_copied_live + need_uncopied_live);

       }

       // If oldest gen is uncopying in some manner (compact or non-moving) then

       // add the extra requested by minOldGenSize to uncopying portion of memory.

       ASSERT(need_uncopied_live + need_copied_live >= RtsFlags.GcFlags.minOldGenSize );

       need_prealloc = 0;

       for (i = 0; i < n_nurseries; i++) {

       need = BLOCKS_TO_MBLOCKS(need);

       got = mblocks_allocated;

       uint32_t returned = 0;

       if (got > need) {

             gen->bitmap = bitmap_bdescr;

             bitmap = bitmap_bdescr->start;

                        bitmap_size, bitmap);

             // don't forget to fill it with zeros!

             adjusted_blocks = (RtsFlags.GcFlags.maxHeapSize - 2 * blocks);

                        RtsFlags.GcFlags.maxHeapSize, blocks, adjusted_blocks);

             pc_free = adjusted_blocks * 100 / RtsFlags.GcFlags.maxHeapSize;

 void

 push_todo_block(bdescr *bd, gen_workspace *ws)

 {

     ASSERT(bd->link == NULL);

     // Do nothing if USE_LARGE_ADDRESS_SPACE, we never want

     // to release address space

 }

 #else // !USE_LARGE_ADDRESS_SPACE

   oldest_gen->n_words  -= pruned_segments * NONMOVING_SEGMENT_SIZE;

   nonmovingHeap.saved_free = NULL;

   debugTrace(DEBUG_nonmoving_gc,

             pruned_segments, new_length);

   traceNonmovingPrunedSegments(pruned_segments, new_length);

   trace(TRACE_nonmoving_gc, "Finished pruning free segment list.");

 bool nonmovingWaitForFlush(void)

 {

     ACQUIRE_LOCK(&upd_rem_set_lock);

     bool finished = upd_rem_set_flush_count == getNumCapabilities();

     if (!finished) {

         waitCondition(&upd_rem_set_flushed_cond, &upd_rem_set_lock);

                 RELEASE_SM_LOCK;

             } else {

                 // Nothing more to do

                 traceConcMarkEnd(count);

                 return;

             }

         node = capNoToNumaNode(i);

         if (nursery_blocks < blocks) {

                        nursery_blocks, blocks);

             nursery->blocks = allocNursery(node, nursery->blocks,

                                            blocks-nursery_blocks);

         {

             bdescr *next_bd;

                        nursery_blocks, blocks);

             bd = nursery->blocks;

             // might have gone just under, by freeing a large block, so make

             // up the difference.

             if (nursery_blocks < blocks) {

                              nursery_blocks, blocks);

                 nursery->blocks = allocNursery(node, nursery->blocks,

                                                blocks-nursery_blocks);

     gen->live_estimate = live;

           gen->n_old_blocks + freed,

           gen->n_old_blocks - blocks + freed,

           freed,