base-4.20.2.0: Core data structures and operations

Copyright | (c) The University of Glasgow 2001
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | provisional
Portability | portable
Safe Haskell | Safe
Language | Haskell2010

System.Mem

Contents

- Garbage collection
- Allocation counter and limits

Description

Memory-related system things.

Synopsis

- performGC :: IO ()
- performMajorGC :: IO ()
- performBlockingMajorGC :: IO ()
- performMinorGC :: IO ()
- setAllocationCounter :: Int64 -> IO ()
- getAllocationCounter :: IO Int64
- enableAllocationLimit :: IO ()
- disableAllocationLimit :: IO ()

# Garbage collection

performGC :: IO () Source #

Triggers an immediate major garbage collection.

performMajorGC :: IO () Source #

Triggers an immediate major garbage collection.

Since: base-4.7.0.0

performBlockingMajorGC :: IO () Source #

Triggers an immediate major garbage collection, ensuring that collection finishes before returning.

Since: base-4.20.0.0

performMinorGC :: IO () Source #

Triggers an immediate minor garbage collection.

Since: base-4.7.0.0

# Allocation counter and limits

setAllocationCounter :: Int64 -> IO () Source #

Every thread has an allocation counter that tracks how much memory has been allocated by the thread. The counter is initialized to zero, and `setAllocationCounter` sets the current value. The allocation counter counts *down*, so in the absence of a call to `setAllocationCounter` its value is the negation of the number of bytes of memory allocated by the thread.

There are two things that you can do with this counter:

- Use it as a simple profiling mechanism, with `getAllocationCounter`.
- Use it as a resource limit. See `enableAllocationLimit`.

Allocation accounting is accurate only to about 4Kbytes.

Since: base-4.8.0.0

getAllocationCounter :: IO Int64 Source #

Return the current value of the allocation counter for the current thread.

Since: base-4.8.0.0

enableAllocationLimit :: IO () Source #

Enables the allocation counter to be treated as a limit for the current thread. When the allocation limit is enabled, if the allocation counter counts down below zero, the thread will be sent the `AllocationLimitExceeded` asynchronous exception. When this happens, the counter is reinitialised (by default to 100K, but tunable with the `+RTS -xq` option) so that it can handle the exception and perform any necessary clean up. If it exhausts this additional allowance, another `AllocationLimitExceeded` exception is sent, and so forth. Like other asynchronous exceptions, the `AllocationLimitExceeded` exception is deferred while the thread is inside `mask` or an exception handler in `catch`.

Note that memory allocation is unrelated to live memory, also known as heap residency. A thread can allocate a large amount of memory and retain anything between none and all of it. It is better to think of the allocation limit as a limit on CPU time, rather than a limit on memory.

Compared to using timeouts, allocation limits don't count time spent blocked or in foreign calls.

Since: base-4.8.0.0

disableAllocationLimit :: IO () Source #

Disable allocation limit processing for the current thread.

Since: base-4.8.0.0