4

我正在尝试重现处理器缓存效果库的示例 6 。

文章以这个函数（在 C# 中）为例如何测试虚假共享：

private static int[] s_counter = new int[1024];
private void UpdateCounter(int position)
{
    for (int j = 0; j < 100000000; j++)
    {
        s_counter[position] = s_counter[position] + 3;
    }
}

如果我们创建传递给这个函数 0、1、2、3 个参数的线程，计算将需要很长时间才能完成（作者得到了 4.3 秒）。例如，如果我们通过 16、32、48、64，我们会得到更好的结果（0.28 秒）。

我在 Rust 中提出了以下函数：

pub fn cache_line_sharing(arr: [i32; 128], pos: usize) -> (i32, i32) {
    let arr = Arc::new(arr);
    let handles: Vec<_> = (0..4).map(|thread_number| {
        let arr = arr.clone();
        let pos = thread_number * pos;
        thread::spawn(move || unsafe {
            let p = (arr.as_ptr() as *mut i32).offset(pos as isize);
            for _ in 0..1_000_000 {
                *p = (*p).wrapping_add(3);
            }
        })
    }).collect();

    for handle in handles {
        handle.join().unwrap();
    }

    (arr[0], arr[1])
}

用两组参数（0、1、2、3 和 0、16、32、48）对其进行基准测试，得到了几乎相同的结果：108.34 和 105.07 微秒。

我使用标准箱作为基准。我有一台配备 Intel i5-5257U CPU (2.70GHz) 的 MacBook Pro 2015。我的系统报告有64B缓存行大小。

如果有人想查看我的完整基准测试代码，请点击以下链接：- lib.rs - cache_lines.rs

我想了解问题并找到重现文章中类似结果的方法。

4

1 回答 1

6

您的第一个问题是*p.wrapping_add(3)对指针而不是整数进行算术运算。循环的第一次迭代是在三个空格之后加载值p并将其存储在p，Rust 正在优化循环的其他 999999 次迭代作为冗余。你的意思是(*p).wrapping_add(3)。

在该更改之后，Rust 将 1000000 个加法优化 3 为一个加法 3000000。您可以使用read_volatileandwrite_volatile来避免这种优化。

尽管这两个更改足以证明您在我的测试中寻找的效果，但请注意，使用不安全操作来改变不可变借用的数组是未定义的行为。假设unsafe代码支持某些不变量，则允许 Rust 进行优化，而此代码不支持，因此 Rust 完全有权用它感觉的任何东西替换您的代码。

您可能使用不可变借用来绕过在线程之间复制可变引用和可变指针的限制。我认为，这是绕过该限制的一种不太明确的方法（尽管老实说，如果有人回复指出这仍然是错误的某种方式，我不会太惊讶）。

pub fn cache_line_sharing(arr: [i32; 128], pos: usize) -> (i32, i32) {
    struct SyncWrapper(UnsafeCell<[i32; 128]>);
    unsafe impl Sync for SyncWrapper {}

    assert_ne!(pos, 0);
    let arr = Arc::new(SyncWrapper(UnsafeCell::new(arr)));
    let handles: Vec<_> = (0..4)
        .map(|thread_number| {
            let arr = arr.clone();
            let pos = thread_number * pos;
            thread::spawn(move || unsafe {
                let p: *mut i32 = &mut (*arr.0.get())[pos];
                for _ in 0..1_000_000 {
                    p.write_volatile(p.read_volatile().wrapping_add(3));
                }
            })
        })
        .collect();

    for handle in handles {
        handle.join().unwrap();
    }

    let arr = unsafe { *arr.0.get() };
    (arr[0], arr[1])
}
于 2019-01-11T05:59:05.583 回答