Devito age defines how long the compiler keeps generated low‑level abstractions in memory during each JIT compilation cycle. Understanding this metric helps you balance binary freshness, memory pressure, and runtime performance.
Longer retention can reuse compiled kernels across repeated calls, while shorter retention reduces cache footprint and startup latency. The table below summarizes the most relevant dimensions of Devito age behavior.
| Parameter | Typical Default | Effect of Increasing Age | Effect of Decreasing Age |
|---|---|---|---|
| Kernel Cache Lifetime | Process lifetime | Higher reuse, lower compilation frequency | More frequent recompilation |
| Memory Overhead | Moderate | Higher steady‑state memory use | Lower steady‑state memory use |
| First‑Run Latency | Higher | Longer warm‑up for new symbolic shapes | Shorter initial latency for repeated shapes |
| Compilation CPU Cost | Medium | Spread over fewer runs | Concentrated over fewer but more frequent runs |
Tuning Devito Age in Production Deployments
Production environments often prioritize predictable throughput and low tail latency. You can adjust the age policy by configuring the JIT options before building operators, for example via environment variables or Python runtime APIs. The right setting depends on workload patterns, device constraints, and cost budgets.
Performance Implications Across Workloads
Compute‑bound seismic models benefit from longer retention because each time step reuses expensive staggered grid kernels. Shallow water or highly dynamic meshes gain from moderate settings that limit memory while still exploiting reuse across similar subdomains. In exploration workflows with rapidly changing source geometries, shorter retention avoids holding many specialized kernels that may never be used again.
Memory Footprint and Cache Behavior
Longer Devito age keeps compiled binary blobs and associated metadata resident in process memory. This increases resident set size and may pressure shared caches on multi‑tenant nodes. Shorter age reduces peak memory but can raise instruction cache pressure if the same kernels are rebuilt often, especially on devices with limited L1 instruction cache.
Operational Guidance and Best Practices
- Measure compile time versus runtime savings for your specific stencil complexity and hardware.
- Start with the default process‑level retention, then experiment with shorter ages in memory‑constrained services.
- For bursty or multi‑tenant deployments, prefer shorter age to avoid cache pollution between jobs.
- Log JIT compilation frequency and peak memory to validate the chosen age policy in staging.
- Document age settings alongside kernel parameters to ensure reproducible performance across environments.
Operational Recommendations for Scaling Devito Age Settings
FAQ
Reader questions
How do I set Devito age for a specific operator in Python?
Pass the `time_axis` configuration when constructing the operator or set `devito.configuration.configuration['platform']['core'].jit_cache` globally to control retention across runs.
Does Devito age affect GPU memory usage as well as CPU cache?
Yes, longer retention keeps compiled PTX or SPIR binaries and associated data structures in GPU memory, increasing consumption and potentially limiting concurrent kernels.
What happens if I set Devito age to a very low value on a steady workload? You will see frequent recompilation events, higher CPU usage during runtime, and potentially higher tail latency due to repeated JIT compilation of the same kernels. Can I change Devito age dynamically between time steps?
Age policies apply at kernel build time; you can rebuild operators with different settings between phases, but changing age mid‑time‑step is not supported.