Compiler Explorer

Source code

const Float4 = @Vector(4, f32);

/// Scalar dot product, as a baseline
export fn naiveScalarDot(vecA: [4]f32, vecB: [4]f32) f32 {
    return vecA[0] * vecB[0] + vecA[1] * vecB[1] + vecA[2] * vecB[2] + vecA[3] * vecB[3];
}

/// Naive SSE Dot function.  Returns a scalar, which would need to
/// be `@splat`ted to be usable with other vector math.  Named
/// accessors may encourage this sort of code.
export fn naiveSSEDot(vecA: Float4, vecB: Float4) f32 {
    const ab = vecA * vecB;
    return ab[0] + ab[1] + ab[2] + ab[3];
}

/// A SSE dot function that is a little better.  Returns a vector
/// with all four channels set to the dot product of the two inputs.
/// Avoids mixing scalar and vector code.
export fn tolerableSSEDot(vecA: Float4, vecB: Float4) Float4 {
    const Shuf = @Vector(4, i32);
    const ab = vecA * vecB;
    const abRot90 = @shuffle(f32, ab, ab, Shuf{ 1, 2, 3, 0 });
    const abRot180 = @shuffle(f32, ab, ab, Shuf{ 2, 3, 0, 1 });
    const abRot270 = @shuffle(f32, ab, ab, Shuf{ 3, 0, 1, 2 });
    return ab + abRot90 + abRot180 + abRot270;
}

/// A SSE dot function that will actually give the advertized 4x speedup
/// Requires x, y, z, w channels to be laid out in parallel, as is
/// usually recommended for SIMD.  Note that the individual channels
/// of a SIMD vector do not have individual meanings, and thus do not
/// need names.
export fn goodSSEDot(
    aX: Float4, aY: Float4, aZ: Float4, aW: Float4,
    bX: Float4, bY: Float4, bZ: Float4, bW: Float4,
) Float4 {
    return aX * bX + aY * bY + aZ * bZ + aW * bW;
}

// Misc. vector operations follow to show generated code

/// prevent optimization of data pointed to by p
inline fn escape(p: var) void {
    asm volatile("" : : [g]""(p) : "memory");
}

export fn miscChannelAccess() Float4 {
    var x: Float4 = @splat(4, @as(f32, 1));
    escape(&x); // force x to be saved and loaded from memory
    x = x; // godbolt will attribute the load to this statement
    x[3] = 1;
    const y = x[1];
    escape(&y); // force y to be stored to memory and not optimized
    return x;
}

export fn getElementDynamic(vec: Float4, index: u32) f32 {
    return vec[index];
}

export fn getElement0(vec: Float4) f32 {
    return vec[0];
}

export fn getElement1(vec: Float4) f32 {
    return vec[1];
}

export fn getElement2(vec: Float4) f32 {
    return vec[2];
}

export fn getElement3(vec: Float4) f32 {
    return vec[3];
}

export fn setElementDynamic(vec: Float4, index: u32, value: f32) Float4 {
    var mutVec = vec;
    mutVec[index] = value;
    return mutVec;
}

export fn setElement0(vec: Float4, value: f32) Float4 {
    var mutVec = vec;
    mutVec[0] = value;
    return mutVec;
}

export fn setElement1(vec: Float4, value: f32) Float4 {
    var mutVec = vec;
    mutVec[1] = value;
    return mutVec;
}

export fn setElement2(vec: Float4, value: f32) Float4 {
    var mutVec = vec;
    mutVec[2] = value;
    return mutVec;
}

export fn setElement3(vec: Float4, value: f32) Float4 {
    var mutVec = vec;
    mutVec[3] = value;
    return mutVec;
}