Support for #[derive(Equivalence)] to allow Rust structs to be sent directly over MPI

[AndrewGaspar]

NOTE: This PR should be merged after #49 and #51.

This adds a crate that provides a custom derive for Equivalence, allowing a user to mark a complex struct with #[derive(Equivalence)] to be able to safely send that type via MPI without having to manually serialize the data.

E.g.

#[derive(Equivalence, Default)]
struct MyDataRust {
    b: bool,
    f: f64,
    i: u16,
}

let mut my_data = if world.rank() == root_rank {
    MyDataRust { b: true, f: 3.4, i: 7 }
} else {
    MyDataRust::default()
};

root_process.broadcast_into(&mut my_data);
// all ranks should have MyDataRust { b: true, f: 3.4, i: 7 }

This should work with any struct in Rust that is composed of fundamental types (or arrays of fundamental types) that implement Equivalence. I believe I've tested all forms of structs (with named fields, unnamed fields, and no fields).

[benruijl]

This is great feature that I'd love to use right now! Is there any timeline for when this can be merged?

[AndrewGaspar]

Oh, I was originally hoping for a review... I should probably just update it and merge it.

[fzyzcjy]

Wow this is really helpful and can reduce boilerplate! Looking forward to seeing it merged :)

[AndrewGaspar]

Haha, ok, I've been convinced, let me get this done...

[AndrewGaspar]

I was working on this last night - mainly the issue is that the diff was a little gnarly. However, I did run into another issue of significance - the Equivalence derive requires doing a bunch of "offset_of"s to get the offset of each field in the struct. The problem with this is that it requires UB to do (and was also using the deprecated mem::uninitialized, but switching to MaybeUninit doesn't fix the UB).

There's discussion of this issue in the memoffset crate (which we don't use, but we accomplish the task in a similar way): Gilnaa/memoffset#24

Of note, there's an implicit promise that even though the code in memoffset is technically UB, the compiler team will ensure that the code continues to work as expected: Gilnaa/memoffset#24 (comment)

So there are two options:

• Take Ralf at his word that this pattern won't be broken by the compiler ("defined" UB)
• Just require the user to #[derive(Default)], which would eliminate all UB (we can construct a default object to get the field offsets)

Any thoughts?

[adamreichold]

Any thoughts?

I would suggest deferring to the memoffset crate as a community-wide solution should eventually materialise there. Until it does we will have working code without a future maintenance burden. It does certainly seem worth the dependency...

[AndrewGaspar]

Can't be merged until Gilnaa/memoffset#48 is merged and a new release of memoffset is cut.

[AndrewGaspar]

@adamreichold Look good?

[adamreichold]

@adamreichold Look good?

I admittedly did not have time yet to look over your latest changes. Could you give me until the middle of the week? I think I will be able to schedule a more comprehensive review until then.

[adamreichold]

@adamreichold Look good?

@AndrewGaspar Besides the cosmetic question of whether to use examples or tests, this looks good to me now.