Skip to content
xc

Benchmark sources

These are the programs behind the performance figures, each written four times with the same algorithm and the same data. Choose a language on any of them and every one switches to it.

The xc versions are plain loops over arrays and objects. None of them asks for vector instructions, threads, a matrix unit or anything else by name: where matrix_mul_f32 runs on Apple’s SME matrix unit, or array_map on AVX-512, it is because xcc saw the loop and chose to.

Each program times its own work with bench_now_us() (the monotonic clock) and prints a checksum, which must agree across the four languages for a run to count.

arc_alloc

Section titled “arc_alloc”

Allocate an object per iteration and let ARC free it.

Lines: xc 31, Objective-C 35, C++ 34, Swift 24.

// arc_alloc — allocate an object per iteration and let ARC free it.
// Exercises: heap allocation, retain/release traffic, method dispatch.
// Each object outlives its iteration (it is kept until the next one replaces
// it), so no compiler can put it on the stack or fold the loop away, and the
// result is folded in with ^ so the sum has no closed form.
#import "Stdio.xc"
#import "include/bench_time.xc"


class Node
    {
    u32 v;
    void init(u32 x) { v = x; }
    u32 get(void)    { return v; }
    }


i32 main(i32 argc, u8** argv)
    {
    u32 seed = (u32)argc;
    u32 acc  = (u32)0;
    Node* keep = new Node(seed);
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)80000000; r++)
        {
        Node* n = new Node(r + seed);
        acc = (acc ^ n.get()) + keep.get();
        keep = n;
        }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

arc_array

Section titled “arc_array”

Hold objects in an array and walk them.

Lines: xc 21, Objective-C 31, C++ 34, Swift 25.

// arc_array — hold objects in an array and walk them.
// Exercises: retain/release on stored references, field access through a pointer.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 1024


class Cell { u32 v; void init(u32 x) { v = x; } u32 get(void) { return v; } }


i32 main(i32 argc, u8** argv)
    {
    u32 seed = (u32)argc;
    Cell* cells[N];
    for (u32 i = (u32)0; i < (u32)N; i++) cells[i] = new Cell(i + seed);
    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)3000000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++) acc = acc + cells[i].get();
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

array_map

Section titled “array_map”

Elementwise c[i] = a[i] + b[i] * k.

Lines: xc 21, Objective-C 22, C++ 22, Swift 24.

// array_map — elementwise c[i] = a[i] + b[i] * k.
// Exercises: elementwise map loop, the shape the arm64 map vectoriser takes.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 4096
i32 main(i32 argc, u8** argv)
    {
    u32 a[N]; u32 b[N]; u32 c[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++)
        { a[i] = i + seed; b[i] = (i * (u32)3) + seed; }
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)5000000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++)
            c[i] = a[i] + (b[i] * (u32)7) + r;
    u32 acc = (u32)0;
    for (u32 i = (u32)0; i < (u32)N; i++) acc = acc + c[i];
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

array_sum

Section titled “array_sum”

Sum an array. Exercises: reduction loop, array addressing.

Lines: xc 18, Objective-C 20, C++ 21, Swift 18.

// array_sum — sum an array. Exercises: reduction loop, array addressing.
// This is the shape the arm64 reduction vectoriser recognises.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 4096
i32 main(i32 argc, u8** argv)
    {
    u32 a[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++) a[i] = (i * (u32)2654435761) + seed;
    u32 sum = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)7000000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++) sum = sum + a[i];
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", sum, t1 - t0);
    return 0;
    }

bit_ops

Section titled “bit_ops”

Shifts and bitwise logic over an array.

Lines: xc 19, Objective-C 21, C++ 22, Swift 21.

// bit_ops — shifts and bitwise logic over an array.
// Exercises: shift lowering, and/or/xor, rotate idioms.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 4096
i32 main(i32 argc, u8** argv)
    {
    u32 a[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++) a[i] = (i * (u32)2654435761) + seed;
    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)600000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++)
            acc = acc + (((a[i] + r) << (u32)3) | ((a[i] + r) >> (u32)5)) ^ (u32)0x0F0F0F0F;
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

branch_mix

Section titled “branch_mix”

Data-dependent branches over an array.

Lines: xc 22, Objective-C 21, C++ 22, Swift 20.

// branch_mix — data-dependent branches over an array.
// Exercises: if-conversion, select formation, branch prediction behaviour.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 4096
i32 main(i32 argc, u8** argv)
    {
    u32 a[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++) a[i] = (i * (u32)2654435761) + seed;
    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)500000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++)
            {
            if ((a[i] & (u32)1) == (u32)0) acc = acc + a[i];
            else                           acc = acc ^ a[i];
            }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

call_depth

Section titled “call_depth”

A small non-inlinable call chain in a hot loop.

Lines: xc 19, Objective-C 22, C++ 22, Swift 17.

// call_depth — a small non-inlinable call chain in a hot loop.
// Exercises: call overhead, leaf inlining, tail-call conversion.
#import "Stdio.xc"
#import "include/bench_time.xc"


u32 leaf(u32 x)  { return (x * (u32)3) ^ (x >> (u32)2); }
u32 mid(u32 x)   { return leaf(x) + leaf(x + (u32)1); }
u32 outer(u32 x) { return mid(x) ^ mid(x + (u32)2); }


i32 main(i32 argc, u8** argv)
    {
    u32 seed = (u32)argc;
    u32 acc  = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)2800000000; r++) acc = acc + outer(r + seed);
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

float_math

Section titled “float_math”

Float multiply, accumulated in double.

Lines: xc 29, Objective-C 24, C++ 28, Swift 24.

// float_math — float multiply, accumulated in double.
// Exercises: float arithmetic, multiply-add fusion, float register pressure.
//
// Values are small exact integers and the accumulator is double, so the sum is
// exact whatever order the additions happen in. A vectorising compiler reorders
// them, and without exactness the two languages would disagree on rounding.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 4096
i32 main(i32 argc, u8** argv)
    {
    float a[N]; float b[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++)
        { a[i] = (float)((i + seed) % (u32)16); b[i] = (float)((i % (u32)7) + (u32)1); }
    double acc = 0.0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)400000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++)
            acc = acc + (double)(a[i] * b[i]);
    i64 t1 = bench_now_us();
    // (u32)acc directly is UNDEFINED once the sum exceeds u32: at this
    // iteration count acc reaches ~4.9e10, and the two compilers chose
    // differently (0 against 4294967295). The double is still exact — well
    // under 2^53 — so going through u64 and letting the u32 narrowing wrap,
    // which IS defined, keeps the checksum meaningful and identical.
    Stdio.printf("%lu %lld\n", (u32)((u64)acc), t1 - t0);
    return 0;
    }

hash_mix

Section titled “hash_mix”

An integer avalanche chain.

Lines: xc 19, Objective-C 22, C++ 20, Swift 17.

// hash_mix — an integer avalanche chain.
// Exercises: multiply, shift and xor chains with a serial dependency.
#import "Stdio.xc"
#import "include/bench_time.xc"
i32 main(i32 argc, u8** argv)
    {
    u32 h = (u32)argc;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)640000000; r++)
        {
        h = h ^ (h >> (u32)16);
        h = h * (u32)2246822519;
        h = h ^ (h >> (u32)13);
        h = h + r;
        }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", h, t1 - t0);
    return 0;
    }

int_accum

Section titled “int_accum”

Integer add and xor over an array.

Lines: xc 29, Objective-C 30, C++ 24, Swift 18.

// int_accum — integer add and xor over an array.
// Exercises: loop induction, array addressing, u32 wraparound arithmetic.
//
// The array is seeded from argc so its contents are unknown at compile time,
// and the loop reads it every iteration. Without that both compilers reduce the
// whole loop to a closed form and the benchmark measures nothing.
#import "Stdio.xc"
#import "include/bench_time.xc"


#define N 4096


i32 main(i32 argc, u8** argv)
    {
    u32 a[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++)
        a[i] = (i * (u32)2654435761) + seed;


    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)600000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++)
            acc = acc + (a[i] ^ acc);


    i64 t1 = bench_now_us();


    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

int_muldiv

Section titled “int_muldiv”

Integer multiply and divide by compile-time constants.

Lines: xc 19, Objective-C 21, C++ 21, Swift 18.

// int_muldiv — integer multiply and divide by compile-time constants.
// Exercises: strength reduction, magic-number division.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 1024
i32 main(i32 argc, u8** argv)
    {
    u32 a[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++) a[i] = (i * (u32)2654435761) + seed;
    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)6800000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++)
            acc = acc + ((a[i] * (u32)7) / (u32)3) + (a[i] / (u32)11);
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

matrix_mul

Section titled “matrix_mul”

Multiply two small square matrices, repeatedly.

Lines: xc 27, Objective-C 29, C++ 29, Swift 30.

// matrix_mul — multiply two small square matrices, repeatedly.
// Exercises: triple-nested loops, strided addressing, accumulation.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define M 32
i32 main(i32 argc, u8** argv)
    {
    u32 a[M * M]; u32 b[M * M]; u32 c[M * M];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)(M * M); i++)
        { a[i] = (i + seed) & (u32)15; b[i] = (i ^ seed) & (u32)15; }
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)180000; r++)
        for (u32 i = (u32)0; i < (u32)M; i++)
            for (u32 j = (u32)0; j < (u32)M; j++)
                {
                u32 s = (u32)0;
                for (u32 k = (u32)0; k < (u32)M; k++)
                    s = s + (a[i * (u32)M + k] * b[k * (u32)M + j]);
                c[i * (u32)M + j] = s + r;
                }
    u32 acc = (u32)0;
    for (u32 i = (u32)0; i < (u32)(M * M); i++) acc = acc + c[i];
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

matrix_mul_f32

Section titled “matrix_mul_f32”

Multiply two float matrices, repeatedly.

Lines: xc 37, Objective-C 35, C++ 33, Swift 32.

// matrix_mul_f32 — multiply two float matrices, repeatedly.
// Exercises: a dense float matrix multiply (SME outer products on arm64 macOS
// with SME; NEON or SSE elsewhere). The values are small integers, so every
// product and sum is exact and the checksum is the same in every language,
// whether or not it fuses a*b + s. `:goal(speed)` lets the SME kernel skip
// its NaN check of C: only NaN payloads could differ, and there are no NaNs.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define M 128
i32 main(i32 argc, u8** argv)
    {
    float* a = new float[M * M];
    float* b = new float[M * M];
    float* c = new float[M * M];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)(M * M); i++)
        { a[i] = (float)((i + seed) & (u32)15); b[i] = (float)((i ^ seed) & (u32)15); }
    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)10000; r++)
        {
        a[r % (u32)(M * M)] = (float)(r & (u32)15);
        for (u32 i = (u32)0; i < (u32)M; i++) :goal(speed)
            for (u32 j = (u32)0; j < (u32)M; j++)
                {
                float s = 0.0;
                for (u32 k = (u32)0; k < (u32)M; k++)
                    s = s + a[i * (u32)M + k] * b[k * (u32)M + j];
                c[i * (u32)M + j] = s;
                }
        acc = acc + (u32)c[(r * (u32)7919) % (u32)(M * M)];
        }
    for (u32 i = (u32)0; i < (u32)(M * M); i++) acc = acc + (u32)c[i];
    i64 t1 = bench_now_us();
    Stdio.printf("%u %lld\n", acc, t1 - t0);
    return 0;
    }

mem_copy

Section titled “mem_copy”

Copy between arrays element by element.

Lines: xc 21, Objective-C 24, C++ 24, Swift 20.

// mem_copy — copy between arrays element by element.
// Exercises: load/store pairing, the memcpy idiom, pointer induction.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 4096
i32 main(i32 argc, u8** argv)
    {
    u32 src[N]; u32 dst[N];
    u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++) src[i] = i + seed;
    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)6800000; r++)
        {
        for (u32 i = (u32)0; i < (u32)N; i++) dst[i] = src[i] + r;
        acc = acc + dst[r % (u32)N];
        }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

method_call

Section titled “method_call”

A virtual method call per iteration.

Lines: xc 27, Objective-C 32, C++ 35, Swift 24.

// method_call — a virtual method call per iteration.
// Exercises: dispatch cost, inlining across a method boundary.
// The class is chosen at run time and score() takes the iteration number, so
// the call can be neither resolved at compile time nor hoisted out of the loop.
#import "Stdio.xc"
#import "include/bench_time.xc"


class Shape      { u32 k; void init(u32 x) { k = x; } u32 score(u32 x) { return k ^ x; } }
class Boxy : Shape
    {
    void init(u32 x) { super.init(x); }
    u32 score(u32 x) { return (k ^ x) + (u32)1; }
    }


i32 main(i32 argc, u8** argv)
    {
    u32 seed = (u32)argc;
    Shape* s = new Shape(seed);
    if ((argc & 1) == 0)
        s = new Boxy(seed);
    u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)1600000000; r++) acc = acc + s.score(r);
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

poly_dispatch

Section titled “poly_dispatch”

Dispatch through a mixed array of subclasses.

Lines: xc 25, Objective-C 35, C++ 52, Swift 40.

// poly_dispatch — dispatch through a mixed array of subclasses.
// Exercises: virtual dispatch the compiler cannot devirtualise.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 256
class Op       { u32 k; void init(u32 x) { k = x; } u32 apply(u32 v) { return v + k; } }
class OpMul : Op { void init(u32 x) { super.init(x); } u32 apply(u32 v) { return v * (k | (u32)1); } }
class OpXor : Op { void init(u32 x) { super.init(x); } u32 apply(u32 v) { return v ^ k; } }
i32 main(i32 argc, u8** argv)
    {
    Op* ops[N]; u32 seed = (u32)argc;
    for (u32 i = (u32)0; i < (u32)N; i++)
        {
        if ((i % (u32)3) == (u32)0)      ops[i] = new Op(i + seed);
        else if ((i % (u32)3) == (u32)1) ops[i] = new OpMul(i + seed);
        else                             ops[i] = new OpXor(i + seed);
        }
    u32 acc = (u32)1;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)3000000; r++)
        for (u32 i = (u32)0; i < (u32)N; i++) acc = ops[i].apply(acc) + r;
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

sieve

Section titled “sieve”

Sieve of Eratosthenes over a fixed range, repeatedly.

Lines: xc 25, Objective-C 28, C++ 30, Swift 27.

// sieve — sieve of Eratosthenes over a fixed range, repeatedly.
// Exercises: byte array writes, strided inner loops, division-free stepping.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 8192
i32 main(i32 argc, u8** argv)
    {
    u8 flags[N]; u32 seed = (u32)argc; u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)150000; r++)
        {
        for (u32 i = (u32)0; i < (u32)N; i++) flags[i] = (u8)1;
        u32 count = (u32)0;
        for (u32 i = (u32)2; i < (u32)N; i++)
            if (flags[i] != (u8)0)
                {
                count = count + (u32)1;
                for (u32 j = i + i; j < (u32)N; j = j + i) flags[j] = (u8)0;
                }
        acc = acc + count + (r & seed);
        }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

sort_small

Section titled “sort_small”

Insertion sort of a small array, repeatedly.

Lines: xc 25, Objective-C 28, C++ 30, Swift 29.

// sort_small — insertion sort of a small array, repeatedly.
// Exercises: nested loops, data-dependent branches, swaps.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 64
i32 main(i32 argc, u8** argv)
    {
    u32 a[N]; u32 seed = (u32)argc; u32 acc = (u32)0;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)3200000; r++)
        {
        for (u32 i = (u32)0; i < (u32)N; i++)
            a[i] = ((i * (u32)2654435761) ^ (r * (u32)40503)) + seed;
        for (u32 i = (u32)1; i < (u32)N; i++)
            {
            u32 v = a[i]; u32 j = i;
            while (j > (u32)0 && a[j - (u32)1] > v) { a[j] = a[j - (u32)1]; j = j - (u32)1; }
            a[j] = v;
            }
        acc = acc + a[0] + a[N - 1];
        }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

string_scan

Section titled “string_scan”

Scan bytes for a delimiter and checksum them.

Lines: xc 22, Objective-C 24, C++ 26, Swift 23.

// string_scan — scan bytes for a delimiter and checksum them.
// Exercises: byte loads, comparisons, narrow-type arithmetic.
#import "Stdio.xc"
#import "include/bench_time.xc"
#define N 8192
i32 main(i32 argc, u8** argv)
    {
    u8 buf[N]; u32 seed = (u32)argc; u32 acc = (u32)0;
    for (u32 i = (u32)0; i < (u32)N; i++)
        buf[i] = (u8)(((i * (u32)31) + seed) & (u32)127);
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)3800000; r++)
        {
        u32 n = (u32)0;
        for (u32 i = (u32)0; i < (u32)N; i++)
            { if (buf[i] == (u8)44) n = n + (u32)1; acc = acc + (u32)buf[i]; }
        acc = acc + n;
        }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

struct_copy

Section titled “struct_copy”

Pass and return a small struct by value.

Lines: xc 17, Objective-C 19, C++ 23, Swift 26.

// struct_copy — pass and return a small struct by value.
// Exercises: struct copy semantics, field layout, argument passing.
#import "Stdio.xc"
#import "include/bench_time.xc"
struct Pt { u32 x, y; }
Pt bump(Pt p, u32 d) { Pt q; q.x = p.x + d; q.y = p.y ^ d; return q; }
i32 main(i32 argc, u8** argv)
    {
    u32 seed = (u32)argc; u32 acc = (u32)0;
    Pt p; p.x = seed; p.y = seed;
    i64 t0 = bench_now_us();
    for (u32 r = (u32)0; r < (u32)2200000000; r++)
        { p = bump(p, r); acc = acc + p.x + p.y; }
    i64 t1 = bench_now_us();
    Stdio.printf("%lu %lld\n", acc, t1 - t0);
    return 0;
    }

Parallel blocks and the GPU

Section titled “Parallel blocks and the GPU”

The programs behind the performance page’s GPU tables. Each is one xc program: its work is a par block, a loop whose iterations are independent, and the runtime runs it on the CPU’s threads or on the GPU (Metal on a Mac, CUDA or Vulkan on Windows, Vulkan on Linux and Android, WebGPU in the browser), whichever it finds faster. Nothing in the source names a device, a kernel language or a thread.

mandelbrot

Section titled “mandelbrot”

Escape-time iteration counts over a 2048x2048 grid, one item

Lines: 51.

// mandelbrot — escape-time iteration counts over a 2048x2048 grid, one item
// per pixel: arithmetic only, with a data-dependent loop. Prints
// "<checksum> <best_us> <first_us>"; the checksum is the total iteration count to
// the nearest million, coarse enough that fast GPU maths cannot move it.
#import "Stdio.xc"
#import "Par.xc"
#import "../src/include/bench_time.xc"


#define W 2048
#define SIZE (2048 * 2048)


i32 main(void)
{
    // Eight runs: the first carries one-off costs (a GPU builds its kernel
    // then), so the figure is the best run; the first is printed too. Auto
    // decides after its fourth (two on each device), and uses the rest.
    u32 total = (u32)0;
    i64 best = (i64)0;
    i64 first = (i64)0;
    for (u32 rep in 0..8)
    {
        total = (u32)0;
        i64 t0 = bench_now_us();
        par mandel :reduce(+ total)
        {
            for (u32 i in 0..SIZE)
            {
                float cx = (float)(i % (u32)W) * (3.0f / 2048.0f) - 2.0f;
                float cy = (float)(i / (u32)W) * (3.0f / 2048.0f) - 1.5f;
                float x = 0.0f;
                float y = 0.0f;
                u32 k = (u32)0;
                while (k < (u32)256 && x * x + y * y < 4.0f)
                {
                    float xt = x * x - y * y + cx;
                    y = 2.0f * x * y + cy;
                    x = xt;
                    k = k + (u32)1;
                }
                total = total + k;
            }
        }
        i64 t1 = bench_now_us();
        if (rep == (u32)0)
            first = t1 - t0;
        if (rep == (u32)0 || t1 - t0 < best)
            best = t1 - t0;
    }
    Stdio.printf("%u %lld %lld\n", (total + (u32)500000) / (u32)1000000, best, first);
    return 0;
}

nbody

Section titled “nbody”

The gravitational force on each of 8192 bodies from all the others:

Lines: 63.

// nbody — the gravitational force on each of 8192 bodies from all the others:
// O(n^2) arithmetic over small arrays, one item per body. Prints
// "<checksum> <best_us> <first_us>"; the checksum counts the bodies pulled right
// (positive x force), a coarse figure fast GPU maths does not move.
#import "Stdio.xc"
#import "Math.xc"
#import "Par.xc"
#import "../src/include/bench_time.xc"


#define N 8192


float px[N];
float py[N];
float mass[N];
float fx[N];


i32 main(void)
{
    u32 seed = (u32)7;
    for (u32 i in 0..N)
    {
        seed = seed * (u32)1664525 + (u32)1013904223;
        px[i] = (float)(seed >> (u32)8) / 16777216.0f;
        seed = seed * (u32)1664525 + (u32)1013904223;
        py[i] = (float)(seed >> (u32)8) / 16777216.0f;
        mass[i] = 1.0f + (float)(i % (u32)7);
    }
    // Eight runs: the first carries one-off costs (a GPU builds its kernel
    // then), so the figure is the best run; the first is printed too. Auto
    // decides after its fourth (two on each device), and uses the rest.
    u32 right = (u32)0;
    i64 best = (i64)0;
    i64 first = (i64)0;
    for (u32 rep in 0..8)
    {
        right = (u32)0;
        i64 t0 = bench_now_us();
        par forces :reduce(+ right)
        {
            for (u32 i in 0..N)
            {
                float ax = 0.0f;
                for (u32 j in 0..N)
                {
                    float dx = px[j] - px[i];
                    float dy = py[j] - py[i];
                    float d2 = dx * dx + dy * dy + 0.0001f;
                    ax = ax + mass[j] * dx / (d2 * Math.sqrt(d2));
                }
                fx[i] = ax;
                if (ax > 0.0f)
                    right = right + (u32)1;
            }
        }
        i64 t1 = bench_now_us();
        if (rep == (u32)0)
            first = t1 - t0;
        if (rep == (u32)0 || t1 - t0 < best)
            best = t1 - t0;
    }
    Stdio.printf("%u %lld %lld\n", (right + (u32)50) / (u32)100, best, first);
    return 0;
}

perlin

Section titled “perlin”

Ken Perlin’s improved noise, 2D, four octaves, over a 2048x2048

Lines: 102.

// perlin — Ken Perlin's improved noise, 2D, four octaves, over a 2048x2048
// image: a permutation table read at data-dependent places, helper calls,
// and one store per pixel. Prints "<checksum> <best_us> <first_us>"; the checksum is
// the mean grey level to a tenth.
#import "Stdio.xc"
#import "Par.xc"
#import "../src/include/bench_time.xc"


#define SIZE (2048 * 2048)


u32 perm[512];
u8 img[SIZE];


float fade(float t) { return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f); }
float lerp(float t, float a, float b) { return a + t * (b - a); }
float grad(u32 h, float x, float y)
{
    u32 g = h & (u32)7;
    float u = g < (u32)4 ? x : y;
    float v = g < (u32)4 ? y : x;
    float a = (g & (u32)1) != (u32)0 ? 0.0f - u : u;
    float b = (g & (u32)2) != (u32)0 ? 0.0f - 2.0f * v : 2.0f * v;
    return a + b;
}


i32 main(void)
{
    u32 seed = (u32)12345;
    for (u32 i in 0..256)
        perm[i] = i;
    for (u32 i in 0..256)
    {
        seed = seed * (u32)1103515245 + (u32)12345;
        u32 j = i + (seed >> (u32)16) % ((u32)256 - i);
        u32 t = perm[i];
        perm[i] = perm[j];
        perm[j] = t;
    }
    for (u32 i in 0..256)
        perm[i + (u32)256] = perm[i];


    // Eight runs: the first carries one-off costs (a GPU builds its kernel
    // then), so the figure is the best run; the first is printed too. Auto
    // decides after its fourth (two on each device), and uses the rest.
    u32 total = (u32)0;
    i64 best = (i64)0;
    i64 first = (i64)0;
    for (u32 rep in 0..8)
    {
        total = (u32)0;
        i64 t0 = bench_now_us();
        par perlin :reduce(+ total)
        {
            for (u32 i in 0..SIZE)
            {
                float x = (float)(i % (u32)2048) / 256.0f;
                float y = (float)(i / (u32)2048) / 256.0f;
                float sum = 0.0f;
                float amp = 1.0f;
                float norm = 0.0f;
                for (u32 o in 0..4)
                {
                    u32 xi = (u32)x;
                    u32 yi = (u32)y;
                    float xf = x - (float)xi;
                    float yf = y - (float)yi;
                    u32 X = xi & (u32)255;
                    u32 Y = yi & (u32)255;
                    u32 aa = perm[perm[X] + Y];
                    u32 ab = perm[perm[X] + Y + (u32)1];
                    u32 ba = perm[perm[X + (u32)1] + Y];
                    u32 bb = perm[perm[X + (u32)1] + Y + (u32)1];
                    float u = fade(xf);
                    float v = fade(yf);
                    float n = lerp(v, lerp(u, grad(aa, xf, yf), grad(ba, xf - 1.0f, yf)),
                                   lerp(u, grad(ab, xf, yf - 1.0f), grad(bb, xf - 1.0f, yf - 1.0f)));
                    sum = sum + n * amp;
                    norm = norm + amp;
                    amp = amp * 0.5f;
                    x = x * 2.0f;
                    y = y * 2.0f;
                }
                float s = (sum / norm) * 0.5f + 0.5f;
                if (s < 0.0f)
                    s = 0.0f;
                if (s > 1.0f)
                    s = 1.0f;
                u32 p = (u32)(s * 255.0f);
                img[i] = (u8)p;
                total = total + p;
            }
        }
        i64 t1 = bench_now_us();
        if (rep == (u32)0)
            first = t1 - t0;
        if (rep == (u32)0 || t1 - t0 < best)
            best = t1 - t0;
    }
    u32 tenths = (total * (u32)10 + (u32)(SIZE / 2)) / (u32)SIZE;
    Stdio.printf("%u %lld %lld\n", tenths, best, first);
    return 0;
}

saxpy

Section titled “saxpy”

Y = a*x + y over 16M integers: one multiply-add per element and

Lines: 48.

// saxpy — y = a*x + y over 16M integers: one multiply-add per element and
// two arrays to move, so memory, not arithmetic, sets the pace. On a GPU the
// copies in and out cost more than the work: this is the block auto keeps on
// the CPU. Prints "<checksum> <best_us> <first_us>"; the checksum is exact.
#import "Stdio.xc"
#import "Par.xc"
#import "../src/include/bench_time.xc"


#define SIZE (16 * 1024 * 1024)


u32 xs[SIZE];
u32 ys[SIZE];


i32 main(void)
{
    for (u32 i in 0..SIZE)
    {
        xs[i] = i * (u32)2654435761;
        ys[i] = i;
    }
    // Eight runs: the first carries one-off costs (a GPU builds its kernel
    // then), so the figure is the best run; the first is printed too. Auto
    // decides after its fourth (two on each device), and uses the rest.
    u32 total = (u32)0;
    i64 best = (i64)0;
    i64 first = (i64)0;
    for (u32 rep in 0..8)
    {
        total = (u32)0;
        i64 t0 = bench_now_us();
        par saxpy :reduce(+ total)
        {
            for (u32 i in 0..SIZE)
            {
                u32 v = (u32)3 * xs[i] + ys[i];
                ys[i] = v;
                total = total + v;
            }
        }
        i64 t1 = bench_now_us();
        if (rep == (u32)0)
            first = t1 - t0;
        if (rep == (u32)0 || t1 - t0 < best)
            best = t1 - t0;
    }
    Stdio.printf("%u %lld %lld\n", total, best, first);
    return 0;
}