Escrevendo uma função de kernel para GPU

A GPU kernel is the function each thread runs. You write the work for one element, and the hardware repeats it across many.

The trick is to write a kernel from a single thread's view. Each thread does its own small slice of the work.

In Mojo a kernel is a normal fn. Its strict, typed nature is exactly what device code needs to compile fast.

A kernel takes pointers to device memory as parameters. These buffers hold the inputs and the output it will fill.

Inside the kernel, each thread computes its own position first. That index selects which element it must process.

Always check the index before touching memory. A bounds check keeps stray threads from reading past the array.

The body is tiny: read inputs, compute, write one result. The whole kernel often fits in a single line of math.

You launch it by choosing a grid and block size. The launch fans your one-thread code out across the whole grid.

Kernels do not return results to the caller. They write into the output buffer, which you read back afterward.

Threads run best in lockstep. Heavy branching makes lanes diverge and wait, so keep kernel logic simple and uniform.

One short kernel plus a big grid equals millions of results. The scale comes from the launch, not from longer code.

You are writing the body of a GPU kernel for one thread.

A kernel is an fn for one thread: find your index, guard the bounds, do one element's math, then launch over a grid. ⚡