Compiler Explorer

Source code

use std::rc::Rc;
use std::sync::atomic::{AtomicUsize, Ordering};

// Demonstrates the Rc 'trick'. Note `ud2` is how "abort()" is spelled.
// If you want evidence of this, feel free to set `opt-level=0` and look at Rc's 
// `inc_strong` disassembly.
#[no_mangle]
pub fn ex1() {
    let a = Rc::new(0);
    loop {
        std::mem::forget(a.clone());
    }
}

// There are two things I'd like to highlight enabling `ex1`'s codegen.
//
// **First**, there are no side-effects in the loop above, allowing an optimizing
// compiler to determine that all of the increments are just wasted cycles, and
// the entire loop can be optimized to its singular exit condition.
//
// `ex2` has a side-effect, and you can see in the asm that it's optimized to
// roughly:
// for i in 0..(usize::MAX - 2) {
//   side_effect();   
// }
// abort();
#[no_mangle]
pub fn ex2() {
    let a = Rc::new(0);
    loop {
        std::mem::forget(a.clone());
        side_effect();
    }
}

fn side_effect() {
    extern "C" {
        fn side_effect_impl();
    }
    unsafe { side_effect_impl() };
}

// **Second**, the compiler has to be sure that nothing else can actually observe
// or manipulate any intermediate state of `a`. If we take the same example and
// escape a pointer to `a`, the code looks a bit less optimal. After `escape(&a)`,
// the loop is optimized to roughly:
// for i in Rc::strong_count(&a)..(usize::MAX - 2) {
//   // do nothing lol
// }
// abort();
//
// In this case, the elimination of the loop is probably a missed optimization by
// LLVM?
#[no_mangle]
pub fn ex3() {
    let a = Rc::new(0);
    escape(&a);
    loop {
        std::mem::forget(a.clone());
    }
}

fn escape(r: &Rc<i32>) {
    extern "C" {
        fn escape_impl(_: *const i8);
    }
    unsafe { escape_impl(r as *const Rc<i32> as *const i8) };
}

// And **as an extension to the second**, if the pointer gets escaped and a
// side-effect happens in the loop, you can see that the loop is never
// guaranteed to terminate, as LLVM has to consider that `side_effect()` and
// `escape()` may be working together to keep the refcount down, somehow.
//
// Moreover, this loop is optimized to roughly:
// std::mem::forget(a.clone()); // (with the check that calls abort() if this fails)
// loop {
//   side_effect();
//   std::mem::forget(a.clone()); // (with the check that calls abort() if this fails)
// }
#[no_mangle]
fn ex4() {
    let a = Rc::new(0);
    escape(&a);
    loop {
        std::mem::forget(a.clone());
        side_effect();
    }
}