|
| 1 | +# [Memory Management and Garbage Collection](@id man-memory-management) |
| 2 | + |
| 3 | +Julia uses automatic memory management through its built-in garbage collector (GC). This section provides an overview of how Julia manages memory and how you can configure and optimize memory usage for your applications. |
| 4 | + |
| 5 | +## [Garbage Collection Overview](@id man-gc-overview) |
| 6 | + |
| 7 | +Julia features a garbage collector with the following characteristics: |
| 8 | + |
| 9 | +* **Non-moving**: Objects are not relocated in memory during garbage collection |
| 10 | +* **Generational**: Younger objects are collected more frequently than older ones |
| 11 | +* **Parallel and partially concurrent**: The GC can use multiple threads and run concurrently with your program |
| 12 | +* **Mostly precise**: The GC accurately identifies object references with minimal conservative scanning |
| 13 | + |
| 14 | +The garbage collector automatically reclaims memory used by objects that are no longer reachable from your program, freeing you from manual memory management in most cases. |
| 15 | + |
| 16 | +## [Memory Architecture](@id man-memory-architecture) |
| 17 | + |
| 18 | +Julia uses a two-tier allocation strategy: |
| 19 | + |
| 20 | +* **Small objects** (≤ 2032 bytes): Allocated using a fast per-thread pool allocator |
| 21 | +* **Large objects** (> 2032 bytes): Allocated directly through the system's `malloc` |
| 22 | + |
| 23 | +This hybrid approach optimizes for both allocation speed and memory efficiency, with the pool allocator providing fast allocation for the many small objects typical in Julia programs. |
| 24 | + |
| 25 | +## [System Memory Requirements](@id man-system-memory) |
| 26 | + |
| 27 | +### Swap Space |
| 28 | + |
| 29 | +Julia's garbage collector is designed with the expectation that your system has adequate swap space configured. The GC uses heuristics that assume it can allocate memory beyond physical RAM when needed, relying on the operating system's virtual memory management. |
| 30 | + |
| 31 | +If your system has limited or no swap space, you may experience out-of-memory errors during garbage collection. In such cases, you can use the `--heap-size-hint` option to limit Julia's memory usage. |
| 32 | + |
| 33 | +### Memory Hints |
| 34 | + |
| 35 | +You can provide a hint to Julia about the maximum amount of memory to use: |
| 36 | + |
| 37 | +```bash |
| 38 | +julia --heap-size-hint=4G # Limit heap to ~4GB |
| 39 | +julia --heap-size-hint=50% # Use up to 50% of physical memory |
| 40 | +``` |
| 41 | + |
| 42 | +The `--heap-size-hint` option tells the garbage collector to trigger collection more aggressively when approaching the specified limit. This is particularly useful in: |
| 43 | + |
| 44 | +* Containers with memory limits |
| 45 | +* Systems without swap space |
| 46 | +* Shared systems where you want to limit Julia's memory footprint |
| 47 | + |
| 48 | +You can also set this via the `JULIA_HEAP_SIZE_HINT` environment variable: |
| 49 | + |
| 50 | +```bash |
| 51 | +export JULIA_HEAP_SIZE_HINT=2G |
| 52 | +julia |
| 53 | +``` |
| 54 | + |
| 55 | +## [Multithreaded Garbage Collection](@id man-gc-multithreading) |
| 56 | + |
| 57 | +Julia's garbage collector can leverage multiple threads to improve performance on multi-core systems. |
| 58 | + |
| 59 | +### GC Thread Configuration |
| 60 | + |
| 61 | +By default, Julia uses multiple threads for garbage collection: |
| 62 | + |
| 63 | +* **Mark threads**: Used during the mark phase to trace object references (default: same as compute threads (thread 1 is shared)) |
| 64 | +* **Sweep threads**: Used for concurrent sweeping of freed memory (default: 0, disabled) |
| 65 | + |
| 66 | +You can configure GC threading using: |
| 67 | + |
| 68 | +```bash |
| 69 | +julia --gcthreads=4,1 # 4 mark threads, 1 sweep thread |
| 70 | +julia --gcthreads=8 # 8 mark threads, 0 sweep threads |
| 71 | +``` |
| 72 | + |
| 73 | +Or via environment variable: |
| 74 | + |
| 75 | +```bash |
| 76 | +export JULIA_NUM_GC_THREADS=4,1 |
| 77 | +julia |
| 78 | +``` |
| 79 | + |
| 80 | +### Recommendations |
| 81 | + |
| 82 | +For compute-intensive workloads: |
| 83 | + |
| 84 | +* Use multiple mark threads (the default configuration is usually appropriate) |
| 85 | +* Consider enabling concurrent sweeping with 1 sweep thread for allocation-heavy workloads |
| 86 | + |
| 87 | +For memory-intensive workloads: |
| 88 | + |
| 89 | +* Enable concurrent sweeping to reduce GC pauses |
| 90 | +* Monitor GC time using `@time` and adjust thread counts accordingly |
| 91 | + |
| 92 | +## [Monitoring and Debugging](@id man-gc-monitoring) |
| 93 | + |
| 94 | +### Basic Memory Monitoring |
| 95 | + |
| 96 | +Use the `@time` macro to see memory allocation and GC overhead: |
| 97 | + |
| 98 | +```julia |
| 99 | +julia> @time some_computation() |
| 100 | + 2.123456 seconds (1.50 M allocations: 58.725 MiB, 17.17% gc time) |
| 101 | +``` |
| 102 | + |
| 103 | +This shows: |
| 104 | + |
| 105 | +* Total execution time |
| 106 | +* Number of allocations |
| 107 | +* Memory allocated |
| 108 | +* Percentage of time spent in garbage collection |
| 109 | + |
| 110 | +### GC Logging |
| 111 | + |
| 112 | +Enable detailed GC logging to understand collection patterns: |
| 113 | + |
| 114 | +```julia |
| 115 | +julia> GC.enable_logging(true) |
| 116 | +julia> # Run your code |
| 117 | +julia> GC.enable_logging(false) |
| 118 | +``` |
| 119 | + |
| 120 | +This logs each garbage collection event with timing and memory statistics. |
| 121 | + |
| 122 | +### Manual GC Control |
| 123 | + |
| 124 | +While generally not recommended, you can manually trigger garbage collection: |
| 125 | + |
| 126 | +```julia |
| 127 | +GC.gc() # Force a garbage collection |
| 128 | +GC.enable(false) # Disable automatic GC (use with caution!) |
| 129 | +GC.enable(true) # Re-enable automatic GC |
| 130 | +``` |
| 131 | + |
| 132 | +**Warning**: Disabling GC can lead to memory exhaustion. Only use this for specific performance measurements or debugging. |
| 133 | + |
| 134 | +## [Performance Considerations](@id man-gc-performance) |
| 135 | + |
| 136 | +### Reducing Allocations |
| 137 | + |
| 138 | +The best way to minimize GC impact is to reduce unnecessary allocations: |
| 139 | + |
| 140 | +* Use in-place operations when possible (e.g., `x .+= y` instead of `x = x + y`) |
| 141 | +* Pre-allocate arrays and reuse them |
| 142 | +* Avoid creating temporary objects in tight loops |
| 143 | +* Consider using `StaticArrays.jl` for small, fixed-size arrays |
| 144 | + |
| 145 | +### Memory-Efficient Patterns |
| 146 | + |
| 147 | +* Use `Vector{Float64}` instead of `Vector{Any}` when possible |
| 148 | +* Avoid global variables that change type |
| 149 | +* Use `const` for global constants |
| 150 | +* Consider memory pools for frequently allocated/freed objects |
| 151 | + |
| 152 | +### Profiling Memory Usage |
| 153 | + |
| 154 | +For detailed guidance on profiling memory allocations and identifying performance bottlenecks, see the [Profiling](@ref man-profiling) section. |
| 155 | + |
| 156 | +## [Advanced Configuration](@id man-gc-advanced) |
| 157 | + |
| 158 | +### Environment Variables |
| 159 | + |
| 160 | +Additional GC-related environment variables: |
| 161 | + |
| 162 | +* `JULIA_GC_WAIT_FOR_DEBUGGER`: Pause for debugger attachment during GC (debug builds only) |
| 163 | +* `JULIA_PROFILE_PEEK_HEAP_SNAPSHOT`: Enable heap snapshot collection during profiling |
| 164 | + |
| 165 | +### Integration with System Memory Management |
| 166 | + |
| 167 | +Julia works best when: |
| 168 | + |
| 169 | +* The system has adequate swap space (recommended: 2x physical RAM) |
| 170 | +* Virtual memory is properly configured |
| 171 | +* Other processes leave sufficient memory available |
| 172 | +* Container memory limits are set appropriately with `--heap-size-hint` |
| 173 | + |
| 174 | +## [Troubleshooting Memory Issues](@id man-gc-troubleshooting) |
| 175 | + |
| 176 | +### Out of Memory Errors |
| 177 | + |
| 178 | +If you encounter out-of-memory errors: |
| 179 | + |
| 180 | +1. **Check system memory**: Ensure adequate RAM and swap space |
| 181 | +2. **Use heap size hints**: Set `--heap-size-hint` to limit memory usage |
| 182 | +3. **Profile allocations**: Identify and reduce unnecessary allocations |
| 183 | +4. **Consider chunking**: Process data in smaller chunks for large datasets |
| 184 | + |
| 185 | +### High GC Overhead |
| 186 | + |
| 187 | +If garbage collection is taking too much time: |
| 188 | + |
| 189 | +1. **Reduce allocation rate**: Focus on algorithmic improvements |
| 190 | +2. **Adjust GC threads**: Experiment with different `--gcthreads` settings |
| 191 | +3. **Use concurrent sweeping**: Enable background sweeping with `--gcthreads=N,1` |
| 192 | +4. **Profile memory patterns**: Identify allocation hotspots and optimize them |
| 193 | + |
| 194 | +### Memory Leaks |
| 195 | + |
| 196 | +While Julia's GC prevents most memory leaks, issues can still occur: |
| 197 | + |
| 198 | +* **Global references**: Avoid holding references to large objects in global variables |
| 199 | +* **Closures**: Be careful with closures that capture large amounts of data |
| 200 | +* **C interop**: Ensure proper cleanup when interfacing with C libraries |
| 201 | +* **Circular references**: While handled by the GC, they can delay collection |
| 202 | + |
| 203 | +For more detailed information about Julia's garbage collector internals, see the Garbage Collection section in the Developer Documentation. |
0 commit comments