GHC.Stats.Experimental

Total number of GCs

Total number of major (oldest generation) GCs

Total bytes allocated

Maximum live data (including large objects + compact regions) in the heap. Updated after a major GC.

Maximum live data in large objects

Maximum live data in compact regions

Maximum slop

Maximum memory in use by the RTS

Sum of live bytes across all major GCs. Divided by major_gcs gives the average live data over the lifetime of the program.

Sum of copied_bytes across all GCs

Sum of copied_bytes across all parallel GCs

Sum of par_max_copied_bytes across all parallel GCs. Deprecated.

Sum of par_balanced_copied bytes across all parallel GCs

Total CPU time used by the init phase @since base-4.12.0.0

Total elapsed time used by the init phase @since base-4.12.0.0

Total CPU time used by the mutator

Total elapsed time used by the mutator

Total CPU time used by the GC

Total elapsed time used by the GC

Total CPU time (at the previous GC)

Total elapsed time (at the previous GC)

The total CPU time used during the post-mark pause phase of the concurrent nonmoving GC.

The total time elapsed during the post-mark pause phase of the concurrent nonmoving GC.

The maximum elapsed length of any post-mark pause phase of the concurrent nonmoving GC.

The total CPU time used by the nonmoving GC.

The total time elapsed during which there is a nonmoving GC active.

The maximum time elapsed during any nonmoving GC cycle.

Details about the most recent GC

The generation number of this GC

Number of threads used in this GC

Number of bytes allocated since the previous GC

Total amount of live data in the heap (includes large + compact data). Updated after every GC. Data in uncollected generations (in minor GCs) are considered live.

Total amount of live data in large objects

Total amount of live data in compact regions

Total amount of slop (wasted memory)

Total amount of memory in use by the RTS

Total amount of data copied during this GC

In parallel GC, the max amount of data copied by any one thread. Deprecated.

In parallel GC, the amount of balanced data copied by all threads

The amount of memory lost due to block fragmentation in bytes. Block fragmentation is the difference between the amount of blocks retained by the RTS and the blocks that are in use. This occurs when megablocks are only sparsely used, eg, when data that cannot be moved retains a megablock.

The time elapsed during synchronisation before GC

The CPU time used during GC itself

The time elapsed during GC itself

The CPU time used during the post-mark pause phase of the concurrent nonmoving GC.

The time elapsed during the post-mark pause phase of the concurrent nonmoving GC.