Anatomie eines Compute-Kernels

A compute kernel is the small, focused routine that does the real numerical work, like adding two arrays element by element.

Most of a kernel's time lives in one tight inner loop. Speed up that loop and you speed up the whole program.

A clean kernel takes its data buffers as parameters, so the same routine can run on any arrays you pass in.

Kernels are written with fn, not def. The strict, typed style lets Mojo compile tight machine code with no surprises.

The fastest kernels do one thing. A short, predictable inner body is easy for the compiler to optimize aggressively.

Avoid heavy work like allocation or I/O in the hot loop. Each iteration should be cheap and uniform for peak throughput.

Think in terms of total operations. A kernel over n elements does roughly n units of work, so n drives the cost.

Many kernels are not compute-bound but memory-bound. They wait on data, so how you move bytes often matters most.

Design the loop so each step can later process many elements with SIMD. A regular access pattern makes vectorizing easy.

A classic kernel is saxpy: out = scale times a plus b. It is small, regular, and a great baseline to optimize.

Start with the simple correct version and time it. That number is your baseline for every optimization that follows.

You are about to optimize a kernel. Where does almost all of its time go?

A kernel is a small fn whose tight inner loop does the work; keep it uniform, mind memory, and measure a baseline first. 🔧