Writing codelets in Julia

The IPUToolkit.IPUCompiler submodule allows you to write codelets for the IPU in Julia. Codelets are defined with the @codelet macro, and then you can use them inside a program, written using the interface to the Poplar SDK described before. This mechanism uses the GPUCompiler.jl package, which is a generic framework for generating LLVM IR code for specialised targets, not limited to GPUs despite the historical name.

Examples of codelets written in Julia are shown in the files examples/main.jl, examples/pi.jl, examples/adam.jl, examples/diffeq.jl.

The code inside a codelet has the same limitations as all the compilation models based on GPUCompiler.jl:

the code has to be statically inferred and compiled, dynamic dispatch is not admitted;
you cannot use functionalities which require the Julia runtime, most notably the garbage collector;
you cannot call into any other external binary library at runtime, for example you cannot call into a BLAS library.

After defining a codelet with @codelet you can add a vertex calling this codelet to the graph with the function add_vertex, which also allows controlling the tile mapping in a basic way, or Poplar.GraphAddVertex.

IPUToolkit.IPUCompiler.@codelet — Macro

@codelet graph <function definition>

Define a codelet and add it to the graph. The @codelet macro takes two argument:

the graph to which to add the codelet with the Poplar.GraphAddCodelets function;
the function definition of the codelet that you want to compile for the IPU device.

All the arguments of the function must be either VertexVectors, which represent the Vector vertex type in the Poplar SDK, or VertexScalars, which represent scalar arguments. The function passed as second argument to @codelet should have a single method.

@codelet defines the function passed as argument, generates its LLVM Intermediate Representation (IR) using GPUCompiler.jl and then compiles it down to native code using the Poplar compiler popc, which must be in PATH. By default the LLVM IR of the function is written to a temporary file, but you can choose to keep it in the current directory by customising IPUCompiler.KEEP_LLVM_FILES. You can control flags passed to the popc compiler like debug and optimisation levels or target types by customising IPUCompiler.POPC_FLAGS. During compilation of codelets a spinner is displayed to show the progress, as this step can take a few seconds for each codelet to be generated. This can be disabled by setting IPUCompiler.PROGRESS_SPINNER. All the options mentioned in this section have to be set before the @codelet invocation where you want them to have effect.

The codelet is automatically added to the graph but you will have to separately use it in a vertex, by using either the add_vertex function, or Poplar's Poplar.GraphAddVertex.

Example

using IPUToolkit.IPUCompiler, IPUToolkit.Poplar
device = Poplar.get_ipu_device()
target = Poplar.DeviceGetTarget(device)
graph = Poplar.Graph(target)
@codelet graph function test(in::VertexVector{Int32,In}, out::VertexVector{Float32,Out})
    for idx in eachindex(out)
        out[idx] = sin(in[idx])
    end
end

This snippet of code defines a codelet called test, which takes in input the vector in, whose elements are Int32s, and modifies the vector out, of type Float32, by computing the sine of the elements of in.

Writing codelets in Julia

IPU builtins

Printing

Benchmarking

Passing non-constant variables from global scope

Debugging compilation errors in codelets

Domain-Specific Language: @ipuprogram

Domain-Specific Language: `@ipuprogram`