Cross Reference: /art/runtime/gc/heap.cc

Lines Matching defs:stack
94 // How many reserve entries are at the end of the allocation stack, these are only needed if the
95 // allocation stack overflows.
97 // Default mark stack size in bytes.
107 // GC alot mode uses a small allocation stack to stress test a lot of GC.
110 // Verify objet has a small allocation stack size since searching the allocation stack is slow.
176        * causes a lot of GC since we do a GC for alloc whenever the stack is full. When heap
397   mark_stack_.reset(accounting::ObjectStack::Create("mark stack", kDefaultMarkStackSize,
401       "allocation stack", max_allocation_stack_size_, alloc_stack_capacity));
403       "live stack", max_allocation_stack_size_, alloc_stack_capacity));
544     // The allocation stack may have non movable objects in it. We need to flush it since the GC
545     // can't only handle marking allocation stack objects of one non moving space and one main
718       // stack or the class not yet being written in the object. Or, if kUseThreadLocalAllocationStack,
719       // there can be nulls on the allocation stack.
727 void Heap::MarkAllocStackAsLive(accounting::ObjectStack* stack) {
734                  large_object_space_->GetLiveBitmap(), stack);
879   // If we don't reset then the mark stack complains in its destructor.
1158   // This is covering the allocation/live stack swapping that is done without mutators suspended.
1184   // then clear the stack containing it.
2081                           accounting::ObjectStack* stack) {
2084   mirror::Object** limit = stack->End();
2085   for (mirror::Object** it = stack->Begin(); it != limit; ++it) {
2143     LOG(WARNING) << "Performing GC on a thread that is handling a stack overflow.";
2399           LOG(ERROR) << "Object " << obj << " found in allocation stack";
2402           LOG(ERROR) << "Object " << obj << " found in live stack";
2405           LOG(ERROR) << "Ref " << ref << " found in allocation stack";
2408           LOG(ERROR) << "Ref " << ref << " found in live stack";
2466   // Slow path, the allocation stack push back must have already failed.
2472     // Push our object into the reserve region of the allocaiton stack. This is only required due
2474     // allocation stack).
2481   // Slow path, the allocation stack push back must have already failed.
2490     // Push our object into the reserve region of the allocaiton stack. This is only required due
2492     // allocation stack).
2494     // Push into the reserve allocation stack.
2498   // Retry on the new thread-local allocation stack.
2509   // Since we sorted the allocation stack content, need to revoke all
2514   // Verify objects in the allocation stack since these will be objects which were:
2517   // We don't want to verify the objects in the live stack since they themselves may be
2555       // If the object is not dirty and it is referencing something in the live stack other than
2567             LOG(ERROR) << "Object " << obj << " found in live stack";
2573                     << " references " << ref << " " << PrettyTypeOf(ref) << " in live stack";
2585                 LOG(ERROR) << (is_static ? "Static " : "") << "field in the live stack is "
2635   // We need to sort the live stack since we binary search it.
2637   // Since we sorted the allocation stack content, need to revoke all
2642   // We can verify objects in the live stack since none of these should reference dead objects.
2740   // Check that all objects which reference things in the live stack are on dirty cards.
2745     // Sort the live stack so that we can quickly binary search it later.