Add [Mojo]

[ShalokShalom]

Language Name

Mojo

Sample Implementation

fn compute_pi(var rounds: UInt32) -> Float64:
    comptime simd_width = simd_width_of[Float64]()
    comptime vector_indices = iota[DType.uint64, simd_width](0)

    var i: SIMD[DType.uint64, simd_width] = vector_indices
    var float_i: SIMD[DType.float64, simd_width] = vector_indices.cast[DType.float64]()
    var pi_acc: SIMD[DType.float64, simd_width] = {0.0}

    var rounds_cmp: SIMD[DType.uint64, simd_width] = {rounds}

    comptime x_mask: SIMD[DType.bool, simd_width] = (vector_indices & 1).eq(1)
    comptime ones: SIMD[DType.float64, simd_width] = {1.0}
    comptime negative_ones: SIMD[DType.float64, simd_width] = {-1.0}
    comptime x_values = x_mask.select(negative_ones, ones)

    while True:
        var mask = i.lt(rounds_cmp)

        if not any(mask):
            break

        var fmaed = float_i.fma[FastMathFlag.FAST](2.0, 1.0)
        var recip = inlined_assembly["vrcp14pd $0, $1;", SIMD[DType.float64, simd_width], constraints = "=v,v",](
            fmaed,
        )

        var tmp = recip.fma[FastMathFlag.FAST](x_values, pi_acc)
        pi_acc = mask.select(tmp, pi_acc)
        i += simd_width
        float_i += Float64(simd_width)
        
    var pi = pi_acc.reduce_add()
    return pi

Code provided by Owen Hilyard.

Why add this language?

Mojo is a high-performance language with a Python-like syntax that incorporates many interesting technologies, such as inherent SIMD use, MLIR, and other hot stuff.

Implementation Rules

• Single-threaded (no concurrency/parallelism)
• Uses the Leibniz formula for calculating pi
• Reads rounds from rounds.txt
• Outputs pi with 16 decimal places

[cyrusmsk]

The work is in progress
Please ignore this issue

[niklas-heer]

Thanks for opening this issue and providing a sample implementation! Mojo looks like an interesting addition to the benchmark.

I see @cyrusmsk is already working on this. Let me know if you need any help getting it integrated - happy to assist with the Earthfile setup or any other part of the process!

[ShalokShalom]

Owen Hilyard himself worked on an updated version, which is now reflected in the original post.

I originally stormed ahead and opened the issue, so it is tracked at all.

The updated implementation is now said to be 40% faster than the C++ one, by the way. 🙂

[niklas-heer]

Thanks @ShalokShalom for opening this and sharing the updated Mojo sample.

To keep the tracker focused and clean, we are closing items that do not currently have an active implementation PR. If you or collaborators want to continue this addition, please open a PR and reference this issue and we can reopen if needed.

[niklas-heer]

Thanks again for the proposal and implementation notes.

Keeping this issue open for community contributions. There is no active implementation PR right now, but this remains welcome: if you want to take it forward, open a PR and reference this issue and we will review.