void Collector::markProtectedObjects() { for (int i = 0; i < ProtectedValues::_tableSize; i++) { ValueImp *val = ProtectedValues::_table[i].key; if (val && !val->marked()) { val->mark(); } } }
void ArrayInstanceImp::mark() { ObjectImp::mark(); unsigned l = storageLength; for (unsigned i = 0; i < l; ++i) { ValueImp *imp = storage[i]; if (imp && !imp->marked()) imp->mark(); } }
void Collector::markStackObjectsConservatively(void *start, void *end) { if (start > end) { void *tmp = start; start = end; end = tmp; } assert(((char *)end - (char *)start) < 0x1000000); assert(IS_POINTER_ALIGNED(start)); assert(IS_POINTER_ALIGNED(end)); char **p = (char **)start; char **e = (char **)end; while (p != e) { char *x = *p++; if (IS_POINTER_ALIGNED(x) && x) { bool good = false; for (int block = 0; block < heap.usedBlocks; block++) { size_t offset = x - (char *)heap.blocks[block]; const size_t lastCellOffset = sizeof(CollectorCell) * (CELLS_PER_BLOCK - 1); if (offset <= lastCellOffset && offset % sizeof(CollectorCell) == 0) { good = true; break; } } if (!good) { int n = heap.usedOversizeCells; for (int i = 0; i != n; i++) { if (x == (char *)heap.oversizeCells[i]) { good = true; break; } } } if (good && ((CollectorCell *)x)->u.freeCell.zeroIfFree != 0) { ValueImp *imp = (ValueImp *)x; if (!imp->marked()) imp->mark(); } } } }
bool Collector::collect() { assert(Interpreter::lockCount() > 0); bool deleted = false; #if TEST_CONSERVATIVE_GC // CONSERVATIVE MARK: mark the root set using conservative GC bit (will compare later) ValueImp::useConservativeMark(true); #endif #if USE_CONSERVATIVE_GC || TEST_CONSERVATIVE_GC if (InterpreterImp::s_hook) { InterpreterImp *scr = InterpreterImp::s_hook; do { //fprintf( stderr, "Collector marking interpreter %p\n",(void*)scr); scr->mark(); scr = scr->next; } while (scr != InterpreterImp::s_hook); } markStackObjectsConservatively(); markProtectedObjects(); #endif #if TEST_CONSERVATIVE_GC ValueImp::useConservativeMark(false); #endif #if !USE_CONSERVATIVE_GC // MARK: first mark all referenced objects recursively // starting out from the set of root objects if (InterpreterImp::s_hook) { InterpreterImp *scr = InterpreterImp::s_hook; do { //fprintf( stderr, "Collector marking interpreter %p\n",(void*)scr); scr->mark(); scr = scr->next; } while (scr != InterpreterImp::s_hook); } // mark any other objects that we wouldn't delete anyway for (int block = 0; block < heap.usedBlocks; block++) { int minimumCellsToProcess = heap.blocks[block]->usedCells; CollectorBlock *curBlock = heap.blocks[block]; for (int cell = 0; cell < CELLS_PER_BLOCK; cell++) { if (minimumCellsToProcess < cell) { goto skip_block_mark; } ValueImp *imp = (ValueImp *)(curBlock->cells + cell); if (((CollectorCell *)imp)->u.freeCell.zeroIfFree != 0) { if ((imp->_flags & (ValueImp::VI_CREATED|ValueImp::VI_MARKED)) == ValueImp::VI_CREATED && ((imp->_flags & ValueImp::VI_GCALLOWED) == 0 || imp->refcount != 0)) { imp->mark(); } } else { minimumCellsToProcess++; } } skip_block_mark: ; } for (int cell = 0; cell < heap.usedOversizeCells; cell++) { ValueImp *imp = (ValueImp *)heap.oversizeCells[cell]; if ((imp->_flags & (ValueImp::VI_CREATED|ValueImp::VI_MARKED)) == ValueImp::VI_CREATED && ((imp->_flags & ValueImp::VI_GCALLOWED) == 0 || imp->refcount != 0)) { imp->mark(); } } #endif // SWEEP: delete everything with a zero refcount (garbage) and unmark everything else int emptyBlocks = 0; for (int block = 0; block < heap.usedBlocks; block++) { CollectorBlock *curBlock = heap.blocks[block]; int minimumCellsToProcess = curBlock->usedCells; for (int cell = 0; cell < CELLS_PER_BLOCK; cell++) { if (minimumCellsToProcess < cell) { goto skip_block_sweep; } ValueImp *imp = (ValueImp *)(curBlock->cells + cell); if (((CollectorCell *)imp)->u.freeCell.zeroIfFree != 0) { #if USE_CONSERVATIVE_GC if (!imp->_marked) #else if (!imp->refcount && imp->_flags == (ValueImp::VI_GCALLOWED | ValueImp::VI_CREATED)) #endif { //fprintf( stderr, "Collector::deleting ValueImp %p (%s)\n", (void*)imp, typeid(*imp).name()); // emulate destructing part of 'operator delete()' imp->~ValueImp(); curBlock->usedCells--; heap.numLiveObjects--; deleted = true; // put it on the free list ((CollectorCell *)imp)->u.freeCell.zeroIfFree = 0; ((CollectorCell *)imp)->u.freeCell.next = curBlock->freeList; curBlock->freeList = (CollectorCell *)imp; } else { #if USE_CONSERVATIVE_GC imp->_marked = 0; #elif TEST_CONSERVATIVE_GC imp->_flags &= ~(ValueImp::VI_MARKED | ValueImp::VI_CONSERVATIVE_MARKED); #else imp->_flags &= ~ValueImp::VI_MARKED; #endif } } else { minimumCellsToProcess++; } } skip_block_sweep: if (heap.blocks[block]->usedCells == 0) { emptyBlocks++; if (emptyBlocks > SPARE_EMPTY_BLOCKS) { #if !DEBUG_COLLECTOR free(heap.blocks[block]); #endif // swap with the last block so we compact as we go heap.blocks[block] = heap.blocks[heap.usedBlocks - 1]; heap.usedBlocks--; block--; // Don't move forward a step in this case if (heap.numBlocks > MIN_ARRAY_SIZE && heap.usedBlocks < heap.numBlocks / LOW_WATER_FACTOR) { heap.numBlocks = heap.numBlocks / GROWTH_FACTOR; heap.blocks = (CollectorBlock **)realloc(heap.blocks, heap.numBlocks * sizeof(CollectorBlock *)); } } } } if (deleted) { heap.firstBlockWithPossibleSpace = 0; } int cell = 0; while (cell < heap.usedOversizeCells) { ValueImp *imp = (ValueImp *)heap.oversizeCells[cell]; #if USE_CONSERVATIVE_GC if (!imp->_marked) { #else if (!imp->refcount && imp->_flags == (ValueImp::VI_GCALLOWED | ValueImp::VI_CREATED)) { #endif imp->~ValueImp(); #if DEBUG_COLLECTOR heap.oversizeCells[cell]->u.freeCell.zeroIfFree = 0; #else free((void *)imp); #endif // swap with the last oversize cell so we compact as we go heap.oversizeCells[cell] = heap.oversizeCells[heap.usedOversizeCells - 1]; heap.usedOversizeCells--; deleted = true; heap.numLiveObjects--; if (heap.numOversizeCells > MIN_ARRAY_SIZE && heap.usedOversizeCells < heap.numOversizeCells / LOW_WATER_FACTOR) { heap.numOversizeCells = heap.numOversizeCells / GROWTH_FACTOR; heap.oversizeCells = (CollectorCell **)realloc(heap.oversizeCells, heap.numOversizeCells * sizeof(CollectorCell *)); } } else { #if USE_CONSERVATIVE_GC imp->_marked = 0; #elif TEST_CONSERVATIVE_GC imp->_flags &= ~(ValueImp::VI_MARKED | ValueImp::VI_CONSERVATIVE_MARKED); #else imp->_flags &= ~ValueImp::VI_MARKED; #endif cell++; } } heap.numAllocationsSinceLastCollect = 0; memoryFull = (heap.numLiveObjects >= KJS_MEM_LIMIT); return deleted; } int Collector::size() { return heap.numLiveObjects; } #ifdef KJS_DEBUG_MEM void Collector::finalCheck() { } #endif #if APPLE_CHANGES int Collector::numInterpreters() { int count = 0; if (InterpreterImp::s_hook) { InterpreterImp *scr = InterpreterImp::s_hook; do { ++count; scr = scr->next; } while (scr != InterpreterImp::s_hook); } return count; }