Function doCollect

src/machine.cpp:3441–3506

};

void doCollect(Thread* t, Heap::CollectionType type, int pendingAllocation)
{
  expect(t, not t->m->collecting);

  t->m->collecting = true;
  THREAD_RESOURCE0(t, t->m->collecting = false);

#ifdef VM_STRESS
  bool stress = (t->getFlags() & Thread::StressFlag) != 0;
  if (not stress)
    t->setFlag(Thread::StressFlag);
#endif

  Machine* m = t->m;

  m->unsafe = true;
  m->heap->collect(
      type,
      footprint(m->rootThread),
      pendingAllocation - (t->m->heapPoolIndex * ThreadHeapSizeInWords));
  m->unsafe = false;

  postCollect(m->rootThread);

  killZombies(t, m->rootThread);

  for (unsigned i = 0; i < m->heapPoolIndex; ++i) {
    m->heap->free(m->heapPool[i], ThreadHeapSizeInBytes);
  }
  m->heapPoolIndex = 0;

  if (m->heap->limitExceeded()) {
    // if we're out of memory, disallow further allocations of fixed
    // objects:
    m->fixedFootprint = FixedFootprintThresholdInBytes;
  } else {
    m->fixedFootprint = 0;
  }

#ifdef VM_STRESS
  if (not stress)
    t->clearFlag(Thread::StressFlag);
#endif

  GcFinalizer* finalizeQueue = t->m->finalizeQueue;
  t->m->finalizeQueue = 0;
  for (; finalizeQueue;
       finalizeQueue = cast<GcFinalizer>(t, finalizeQueue->next())) {
    void (*function)(Thread*, object);
    memcpy(&function, &finalizeQueue->finalize(), BytesPerWord);
    function(t, finalizeQueue->target());
  }

  if ((roots(t)->objectsToFinalize() or roots(t)->objectsToClean())
      and m->finalizeThread == 0 and t->state != Thread::ExitState) {
    m->finalizeThread = m->processor->makeThread(
        m, roots(t)->finalizerThread(), m->rootThread);