Lines Matching full:gc
36 #include "gc/collector/gc_type.h"
37 #include "gc/collector/iteration.h"
38 #include "gc/collector/mark_compact.h"
39 #include "gc/collector_type.h"
40 #include "gc/gc_cause.h"
41 #include "gc/space/large_object_space.h"
42 #include "gc/space/space.h"
71 namespace gc {
120 // Reject due to disabled moving GC.
157 // Whether or not parallel GC is enabled. If not, then we never create the thread pool.
182 // RegisterNativeAllocation checks immediately whether GC is needed if size exceeds the
195 // Whether the transition-GC heap threshold condition applies or not for non-low memory devices.
196 // Stressing GC will bypass the heap threshold condition.
389 // Enables us to compacting GC until objects are released.
408 // Initiates an explicit garbage collection. Guarantees that a GC started after this call has
413 // Does a concurrent GC, provided the GC numbered requested_gc_num has not already been
414 // completed. Should only be called by the GC daemon thread through runtime.
485 // Blocks the caller until the garbage collector becomes idle and returns the type of GC we
486 // waited for. Only waits for running collections, ignoring a requested but unstarted GC. Only
487 // heuristic, since a new GC may have started by the time we return. However, if we hold the
488 // mutator lock, even in shared mode, a new GC can't get very far, so long as we keep it.
541 // Returns the heap growth multiplier, this affects how much we grow the heap after a GC.
613 // Returns approximately how much free memory we have until the next GC happens.
753 space::RosAllocSpace* GetRosAllocSpace(gc::allocator::RosAlloc* rosalloc) const
782 // GC performance measuring
877 // Retrieve the current GC number, i.e. the number n such that we completed n GCs so far.
878 // Provides acquire ordering, so that if we read this first, and then check whether a GC is
879 // required, we know that the GC number read actually preceded the test.
884 // Request asynchronous GC. Observed_gc_num is the value of GetCurrentGcNum() when we started to
885 // evaluate the GC triggering condition. If a GC has been completed since then, we consider our
993 // Install a gc pause listener.
995 // Get the currently installed gc pause listener, or null.
999 // Remove a gc pause listener. Note: the listener must not be deleted, as for performance
1009 bool AddHeapTask(gc::HeapTask* task);
1111 // Handles Allocate()'s slow allocation path with GC involved after an initial allocation
1160 // Are we out of memory, and thus should force a GC or fail?
1169 // Blocks the caller until the garbage collector becomes idle and returns the type of GC we
1170 // waited for. If only_one is true, we only wait for the currently running GC, and may return
1171 // while a new GC is again running.
1186 // Sometimes CollectGarbageInternal decides to run a different Gc than you requested. Returns
1187 // which type of Gc was actually run.
1188 // We pass in the intended GC sequence number to ensure that multiple approximately concurrent
1189 // requests result in a single GC; clearly redundant request will be pruned. A requested_gc_num
1191 // that gcs_completed_ gets this big, we just accept a potential extra GC or two.)
1199 void PreGcVerification(collector::GarbageCollector* gc)
1201 void PreGcVerificationPaused(collector::GarbageCollector* gc)
1203 void PrePauseRosAllocVerification(collector::GarbageCollector* gc)
1205 void PreSweepingGcVerification(collector::GarbageCollector* gc)
1207 void PostGcVerification(collector::GarbageCollector* gc)
1209 void PostGcVerificationPaused(collector::GarbageCollector* gc)
1212 // Find a collector based on GC type.
1232 // the GC was run.
1294 // GC stress mode attempts to do one GC per unique backtrace.
1310 // but allow it to be adjusted upward for large heaps to limit GC overhead. in NativeAllocationGcWatermark()
1320 // Update *_freed_ever_ counters to reflect current GC values.
1357 // The main space is the space which the GC copies to and from on process state updates. This
1389 // How many GC threads we may use for paused parts of garbage collection.
1392 // How many GC threads we may use for unpaused parts of garbage collection.
1398 // If we get a pause longer than long pause log threshold, then we print out the GC after it
1402 // If we get a GC longer than long GC log threshold, then we print out the GC after it finishes.
1408 // Last time (before and after) GC started; meant to be used to measure the
1418 // is useful for benchmarking since it reduces time spent in GC to a low %.
1435 // Guards access to the state of GC, associated conditional variable is used to signal when a GC
1457 // Collector type of the running GC.
1460 // Cause of the last running or attempted GC or GC-like action.
1463 // The thread currently running the GC.
1466 // Last Gc type we ran. Used by WaitForConcurrentGc to know which Gc was waited on.
1479 // a while to usually trigger the initial GC.
1483 // non-concurrent GC. Used as a guideline for computing concurrent_start_bytes_ in the
1484 // concurrent GC case. Updates normally occur while collector_type_running_ is not none.
1495 // When num_bytes_allocated_ exceeds this amount then a concurrent GC should be requested so that
1497 // A multiple of this is also used to determine when to trigger a GC in response to native
1515 // RegisterNativeFree. Used to help determine when to trigger GC for native allocations. Should
1519 // Approximately the smallest value of GetNativeBytes() we've seen since the last GC.
1523 // Allows us to check for GC only roughly every kNotifyNativeInterval allocations.
1530 // GC.
1533 // Records the number of bytes allocated at the time of GC, which is used later to calculate
1534 // how many bytes have been allocated since the last GC
1537 // Info related to the current or previous GC iteration.
1578 // Parallel GC data structures.
1581 // A bitmap that is set corresponding to the known live objects since the last GC cycle.
1583 // A bitmap that is set corresponding to the marked objects in the current GC cycle.
1625 // The amount of native memory allocation since the last GC required to cause us to wait for a
1632 // Total time which mutators are paused or waiting for GC to complete.
1638 // Compacting GC disable count, prevents compacting GC from running iff > 0.
1681 // (logically) less means that no new GC has been requested.
1698 // The number of blocking GC runs.
1700 // The total duration of blocking GC runs.
1702 // The duration of the window for the GC count rate histograms.
1706 // The last time when the GC count rate histograms were updated.
1709 // The running count of GC runs in the last window.
1711 // The running count of blocking GC runs in the last window.
1713 // The maximum number of buckets in the GC count rate histograms.
1715 // The histogram of the number of GC invocations per window duration.
1717 // The histogram of the number of blocking GC invocations per window duration.
1728 // GC stress related data structures.
1736 // We disable GC when we are shutting down the runtime in case there are daemon threads still
1741 // emit region info before and after each GC cycle.
1752 // The number of times we initiated a GC of last resort to try to avoid an OOME.
1757 // An installed GC Pause listener.
1779 } // namespace gc