Job Summary

We are looking for a Performance Engineer to make managed language runtimes run measurably faster on ARM64 mobile-class CPUs. You will work across the full runtime stack – interpreter, JIT and AOT compilers, garbage collector and runtime libraries – and you will follow every optimisation down to the generated machine code and the hardware counters that explain it. This is a hands-on role for someone who finds the bottleneck, writes the patch and proves the speedup with rigorous measurement. You will sit inside the CPU team, so what you learn about how runtimes stress the pipeline, caches and branch predictors feeds directly into next-generation core design, and you will work with LLM-agent pipelines that automate parts of the analyse, patch, benchmark and validate loop.

Key Responsibilities

• Runtime profiling: Find and rank performance bottlenecks in interpreter, JIT/AOT, GC and runtime-library code on real application and benchmark workloads, using sampling profilers, PMU counters, top-down analysis and flame graphs.
• Execution engine optimisation: Improve interpreter and compiler tiers end to end.
  • Interpreter dispatch (threaded code, tail calls), inline caches, hidden classes / shapes, and tier-up and deoptimisation policy.
  • JIT and AOT code quality: instruction selection, register allocation, inlining heuristics, escape analysis, check elimination and code-cache layout.
  • Startup time: snapshots, AOT images, lazy compilation and warm-up behaviour.
  • Memory management: tune allocation and collection for throughput, pause time and footprint.
    • Allocation fast paths, write and read barriers, generational, concurrent and compacting collectors, and heap sizing policy.
    • Object layout and pointer compression, and memory behaviour of pointer-chasing heaps.
• Microarchitectural analysis: Explain runtime behaviour in hardware terms – indirect-branch misprediction in dispatch loops, I-cache and iTLB pressure from JIT code, load-to-use latency and prefetch behaviour on object graphs – and turn the findings into concrete software changes and hardware feedback.
• Measurement infrastructure: Build benchmarking and regression-tracking pipelines with noise control, statistically sound A/B comparison and reproducible results, so that every claimed gain is trustworthy.
• Automated optimisation: Build and use LLM-agent pipelines that analyse profiles, propose patches, benchmark them and validate correctness, and decide where automation can be trusted and where it cannot.
• Hardware–software co-design: Work with CPU architects to identify where runtime workloads leave performance on the table and which hardware or ISA features would help.
• Upstream and share: Land patches, write internal technical reports and, where appropriate, contribute to patents and publications.