Use relaxed accesses instead

Oct 13, 2025 by thesweetdesigns.com 68 views

Introduction

The Rust compiler's intrinsics, specifically atomic_load_unordered and atomic_store_unordered, have been a subject of discussion among developers. These intrinsics generate LLVM IR that cannot be mapped to the Rust Abstract Machine (AM) and, as such, there's no well-defined way to use them in a Rust program. In this article, we will delve into the reasons behind the existence of these intrinsics, their usage, and potential alternatives.

The Issue with Atomic Load and Store Unordered

The atomic_load_unordered and atomic_store_unordered intrinsics are part of the Rust compiler's API, which provides a way to interact with the underlying hardware. However, these intrinsics have a significant limitation: they generate LLVM IR that cannot be represented in the C++ concurrency memory model. This makes it challenging to use them in a Rust program, as the language's memory model is based on the C++ concurrency memory model.

Ideally, the Rust compiler should remove these intrinsics, as they are not well-defined in the context of the Rust AM. However, this is currently blocked by the issue that the compiler-builtins crate uses these intrinsics. This crate provides various intrinsics, including __llvm_memcpy_element_unordered_atomic_1, which seems to be the primary reason for the existence of atomic_load_unordered and atomic_store_unordered.

Why Do Unordered Atomics Exist?

The existence of unordered atomics may seem counterintuitive, given that Rust cannot use unordered atomics. However, the reason behind their existence lies in the fact that some hardware architectures, such as ARM, provide unordered atomic operations. These operations allow for more flexibility in memory access patterns, which can be beneficial in certain scenarios.

The compiler-builtins crate provides a way to access these unordered atomic operations, which are not available in the Rust standard library. This is why atomic_load_unordered and atomic_store_unordered intrinsics exist in the first place.

Alternative Solutions

While atomic_load_unordered and atomic_store_unordered intrinsics are not ideal, there are alternative solutions that can be used in certain situations. For example, in the src/arm_linux.rs and src/mem/impls.rs files, the code uses these intrinsics. However, these uses seem to be problematic, and alternative solutions can be explored.

One potential alternative is to use "relaxed" accesses instead. Relaxed accesses are a type of memory access that allows for more flexibility in memory access patterns, similar to unordered atomics. However, relaxed accesses are well-defined in the context of the Rust AM, making them a more suitable choice.

Conclusion

In conclusion, the atomic_load_unordered and atomic_store_unordered intrinsics are not ideal and should be avoided in Rust programs. While they may seem necessary for certain hardware architectures, alternative solutions can be used in their place. The compiler-builtins crate should be reviewed to ensure that it does not rely on these intrinsics, and the Rust compiler should be updated to remove them.

Recommendations

Remove atomic_load_unordered and atomic_store_unordered intrinsics: The Rust compiler should remove these intrinsics, as they are not well-defined in the context of the Rust AM.
Review compiler-builtins crate: The compiler-builtins crate should be reviewed to ensure that it does not rely on atomic_load_unordered and atomic_store_unordered intrinsics.
Use relaxed accesses instead: In situations where atomic_load_unordered and atomic_store_unordered intrinsics are used, relaxed accesses can be used as an alternative.
Update Rust compiler: The Rust compiler should be updated to remove atomic_load_unordered and atomic_store_unordered intrinsics and provide alternative solutions for unordered atomic operations.

Future Work

The removal of atomic_load_unordered and atomic_store_unordered intrinsics is a complex task that requires careful consideration of the Rust compiler's API and the compiler-builtins crate. Future work should focus on:

Updating compiler-builtins crate: The compiler-builtins crate should be updated to remove its reliance on atomic_load_unordered and atomic_store_unordered intrinsics.
Providing alternative solutions: Alternative solutions, such as relaxed accesses, should be provided for unordered atomic operations.
Updating Rust compiler: The Rust compiler should be updated to remove atomic_load_unordered and atomic_store_unordered intrinsics and provide alternative solutions for unordered atomic operations.

Q: What are atomic load and store unordered intrinsics?

A: Atomic load and store unordered intrinsics are a type of intrinsic function provided by the Rust compiler. They allow for atomic operations on memory locations, but with a relaxed memory model. This means that the operations are not guaranteed to be executed in a specific order, and the compiler may reorder them.

Q: Why are atomic load and store unordered intrinsics not recommended?

A: Atomic load and store unordered intrinsics are not recommended because they generate LLVM IR that cannot be mapped to the Rust Abstract Machine (AM). This makes it challenging to use them in a Rust program, as the language's memory model is based on the C++ concurrency memory model.

Q: What are the implications of using atomic load and store unordered intrinsics?

A: Using atomic load and store unordered intrinsics can lead to undefined behavior in certain situations. This is because the operations are not guaranteed to be executed in a specific order, and the compiler may reorder them. This can result in unexpected behavior or crashes.

Q: What are the alternatives to atomic load and store unordered intrinsics?

A: The alternatives to atomic load and store unordered intrinsics are relaxed accesses. Relaxed accesses are a type of memory access that allows for more flexibility in memory access patterns, similar to unordered atomics. However, relaxed accesses are well-defined in the context of the Rust AM, making them a more suitable choice.

Q: Can I use relaxed accesses instead of atomic load and store unordered intrinsics?

A: Yes, you can use relaxed accesses instead of atomic load and store unordered intrinsics. Relaxed accesses are a more suitable choice because they are well-defined in the context of the Rust AM. However, you should carefully consider the implications of using relaxed accesses and ensure that they meet your requirements.

Q: What are the benefits of using relaxed accesses?

A: The benefits of using relaxed accesses include:

Improved performance: Relaxed accesses can provide better performance than atomic load and store unordered intrinsics because they allow for more flexibility in memory access patterns.
Simplified code: Relaxed accesses can simplify code by eliminating the need for atomic operations.
Better compatibility: Relaxed accesses are well-defined in the context of the Rust AM, making them more compatible with other Rust code.

Q: What are the limitations of using relaxed accesses?

A: The limitations of using relaxed accesses include:

Limited flexibility: Relaxed accesses are not as flexible as atomic load and store unordered intrinsics because they are well-defined in the context of the Rust AM.
Potential for undefined behavior: Relaxed accesses can lead to undefined behavior in certain situations, such as when used with non-atomic operations.

Q: How can I determine whether to use atomic load and store unordered intrinsics or relaxed accesses?

A: To determine whether to use atomic load and store unordered intrinsics or relaxed accesses, you should carefully consider the requirements of your code. If you need atomic operations with a relaxed memory model, you may need to use atomic load and store unordered intrinsics. However, if you can use relaxed accesses instead, you may be able to simplify your code and improve performance.

Q: What is the future of atomic load and store unordered intrinsics in Rust?

A: The future of atomic load and store unordered intrinsics in Rust is uncertain. The Rust compiler is currently being updated to remove these intrinsics and provide alternative solutions for unordered atomic operations. However, the exact timeline for this update is not yet known.

Q: How can I contribute to the development of Rust's atomic operations?

A: You can contribute to the development of Rust's atomic operations by:

Reporting issues: If you encounter issues with atomic operations, you can report them to the Rust team.
Providing feedback: You can provide feedback on the Rust compiler's API and suggest improvements.
Contributing code: You can contribute code to the Rust compiler and provide alternative solutions for unordered atomic operations.

By following these guidelines and contributing to the development of Rust's atomic operations, you can help improve the language and provide better support for unordered atomic operations.