Performance 为什么不'；使用get_unchecked（）是否可以提高性能？

我尝试使用

get_unchecked（）

而不是

[]

索引操作符来提高我的

des

板条箱的性能

然而，即使在我的基准测试中调用了48亿次

[]

（或

get_unchecked（）

）函数，它也不会带来明显的性能改进。我原以为调用

get_unchecked（）

48亿次而不是

[]

，会使我的英特尔Core 2 Duo 2.4 GHz处理器在2秒钟内得到改进

我制作这个小基准是为了有一个小代码向您展示：

#![feature(test)]

extern crate test;

fn main() {
}

pub fn s(box_id: usize, block: u64) -> u64 {
    const TABLES: [[[u64; 16]; 4]; 8] =
        [[[ 14,  4, 13, 1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9, 0, 7]
        , [  0, 15,  7, 4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5, 3, 8]
        , [  4,  1, 14, 8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10, 5, 0]
        , [ 15, 12,  8, 2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0, 6, 13]
        ],
        [ [ 15,  1,  8, 14,  6, 11,  3,  4,  9, 7,  2, 13, 12, 0,  5, 10]
        , [  3, 13,  4,  7, 15,  2,  8, 14, 12, 0,  1, 10,  6, 9, 11,  5]
        , [  0, 14,  7, 11, 10,  4, 13,  1,  5, 8, 12,  6,  9, 3,  2, 15]
        , [ 13,  8, 10,  1,  3, 15,  4,  2, 11, 6,  7, 12,  0, 5, 14,  9]
        ],
        [ [ 10,  0,  9, 14, 6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8]
        , [ 13,  7,  0,  9, 3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1]
        , [ 13,  6,  4,  9, 8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7]
        , [  1, 10, 13,  0, 6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12]
        ],
        [ [  7, 13, 14, 3,  0,  6,  9, 10,  1, 2, 8,  5, 11, 12,  4, 15]
        , [ 13,  8, 11, 5,  6, 15,  0,  3,  4, 7, 2, 12,  1, 10, 14,  9]
        , [ 10,  6,  9, 0, 12, 11,  7, 13, 15, 1, 3, 14,  5,  2,  8,  4]
        , [  3, 15,  0, 6, 10,  1, 13,  8,  9, 4, 5, 11, 12,  7,  2, 14]
        ],
        [ [  2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13, 0, 14,  9]
        , [ 14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3, 9,  8,  6]
        , [  4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6, 3,  0, 14]
        , [ 11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10, 4,  5,  3]
        ],
        [ [ 12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11]
        , [ 10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8]
        , [  9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6]
        , [  4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13]
        ],
        [ [  4, 11,  2, 14, 15, 0,  8, 13,  3, 12, 9,  7,  5, 10, 6,  1]
        , [ 13,  0, 11,  7,  4, 9,  1, 10, 14,  3, 5, 12,  2, 15, 8,  6]
        , [  1,  4, 11, 13, 12, 3,  7, 14, 10, 15, 6,  8,  0,  5, 9,  2]
        , [  6, 11, 13,  8,  1, 4, 10,  7,  9,  5, 0, 15, 14,  2, 3, 12]
        ],
        [ [ 13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7]
        , [  1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2]
        , [  7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8]
        , [  2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11]
        ]];
        let i = ((block & 0x20) >> 4 | (block & 1)) as usize;
        let j = ((block & 0x1E) >> 1) as usize;
        unsafe { *TABLES.get_unchecked(box_id).get_unchecked(i).get_unchecked(j) }
        //TABLES[box_id][i][j]
}

#[cfg(test)]
mod bench {
    use test::{Bencher, black_box};

    use super::s;

    #[bench]
    fn bench_s(bencher: &mut Bencher) {
        bencher.iter(|| {
            let box_id = black_box(7);
            (0 .. 40_000_000).fold(0, |acc, block| acc + s(box_id, block))
        });
    }
}

我第一次使用

[]

运行这个基准测试时，它比使用

get\u unchecked（）

的版本花费的时间要少（尽管

get\u unchecked（）

的版本看起来平均快一点）。 我不确定它是否真的反映了我的真实基准（包括加密一个大文件），但它给出了一个想法

我检查了程序集，以确保编译器没有优化绑定检查

以下是带有

get\u unchecked（）

的版本：

我们可以看到

get_unchecked（）

版本更小，而

[]

检查边界的版本更小

这两个版本都是在发布模式下编译的

为什么

get\u unchecked（）

版本的速度不超过这个速度？ 我认为当

get_unchecked（）

/

[]

被调用48亿次时，它应该比

[]

版本至少快几秒钟

编辑：我使用

valgrind

分析了代码

带有

[]

的版本显示带有数组索引的行的成本为10，而带有

get_unchecked（）

的版本显示的成本小于1（请参见下图）。 然而，该功能的成本（见图片左侧）保持不变。这很奇怪。有人有解释吗

带有

未选中的版本（）

---

带有

[]

的版本我还没有学到很多东西，但我认为我仍然可以回答这个问题的性能部分

首先，您确定您的基准测试实际运行的是独立版本的函数吗？它可能将函数内联到调用站点，其中

box\u id

是编译时常量。除了消除较小的调用/ret开销外，表索引计算asm将大大简化。此外，如果在编译时知道没有超过边界检查，则可以省略边界检查

如果有人演示如何修改OP的示例以编译为实际的asm，我可以看一看并说更多。将其按原样放在godbolt上，可以编译为空的asm输出。我可能决定自己学习足够多的铁锈，但可能不会很快

---

查看该函数的独立版本： 选中版本中的额外说明仅为前4条：

9390:   50                      push   %rax        # align the stack in case we make a function call (wasted work for the common case)
9391:   48 89 f8                mov    %rdi,%rax   # compiler is dumb, could have checked the value in %rdi
9394:   48 83 f8 07             cmp    $0x7,%rax
9398:   77 30                   ja     93ca <_ZN3des7s_table17hbabdd9dee72331a5E+0x3a>

9390:50 push%rax#在我们进行函数调用时对齐堆栈（在常见情况下浪费了工作）
9391:48 89 f8 mov%rdi，%rax#编译器是哑的，可以检查%rdi中的值
9394:48 83 f8 07 cmp$0x7，%rax
9398:7730JA93CA

最后的

pop%rcx

将8添加到%rsp

在函数的开头有4个UOP。（Core2Duo无法在64位模式下进行宏融合。不过，Core2Duo可以在32位代码中对cmp/ja进行宏融合。（请参阅）。如果编译器更聪明，则在函数（cmp/ja）的快速路径上总共只需要2条额外指令/UOP，而另一个函数调用的堆栈对齐仅在实际进行调用的分支中完成

您可能会认为将这4个UOP问题作为函数的第一组将是一个问题，因为这会延迟CPU到达关键路径上的指令。但事实并非如此，因为显然您的代码在前端没有瓶颈。（您没有显示在循环中调用此函数的代码的asm）。因此，在实际执行的指令之前，将指令发送到无序内核中

当函数输入在%rdi中准备就绪时，调度程序可能已经有了等待它的关键路径指令。如果基准测试实际运行的是独立版本，则函数开头的4条额外指令实际上并没有延迟关键路径。因此，可能关键路径是瓶颈延迟，而不是吞吐量。（一个调用的输出是否构成下一次查找的索引？如果是，将防止对不同输入同时执行多个函数调用。核心2上的L1加载使用延迟为3个周期（根据）

但是，在从输入计算表索引的指令中有相当多的指令级并行性。有两个

mov

指令生成副本，然后指令对副本和原始文件执行不同的操作。而且这两个参数已经分开了。我想可能有足够的并行性lelism需要在输入准备就绪和表索引准备就绪之间的大部分时间内并行运行3条指令。因此，如果在有另一个输入之前，执行必须等待3个周期才能进行表查找，则需要运行额外的UOP。（不过，调度程序在第一个就绪的基础上运行UOP，而不是关键路径优先，因此您可能希望它们有时会因资源冲突而延长关键路径（从关键路径窃取执行端口）

TL:DR如果一个调用的输出是下一个调用的输入，那么L1负载使用延迟仍然很容易成为瓶颈，而不是uop吞吐量。否则，一定会有其他bott

0000000000009390 <_ZN3des7s_table17hbabdd9dee72331a5E>:
    9390:   50                      push   %rax
    9391:   48 89 f8                mov    %rdi,%rax
    9394:   48 83 f8 07             cmp    $0x7,%rax
    9398:   77 30                   ja     93ca <_ZN3des7s_table17hbabdd9dee72331a5E+0x3a>
    939a:   48 89 f1                mov    %rsi,%rcx
    939d:   48 c1 e9 04             shr    $0x4,%rcx
    93a1:   83 e1 02                and    $0x2,%ecx
    93a4:   89 f2                   mov    %esi,%edx
    93a6:   83 e2 01                and    $0x1,%edx
    93a9:   48 09 ca                or     %rcx,%rdx
    93ac:   48 c1 e0 09             shl    $0x9,%rax
    93b0:   48 8d 0d 99 57 04 00    lea    0x45799(%rip),%rcx        # 4eb50 <const10401>
    93b7:   48 01 c1                add    %rax,%rcx
    93ba:   48 c1 e2 07             shl    $0x7,%rdx
    93be:   48 01 ca                add    %rcx,%rdx
    93c1:   83 e6 1e                and    $0x1e,%esi
    93c4:   48 8b 04 b2             mov    (%rdx,%rsi,4),%rax
    93c8:   59                      pop    %rcx
    93c9:   c3                      retq   
    93ca:   48 8d 3d b7 a3 25 00    lea    0x25a3b7(%rip),%rdi        # 263788 <panic_bounds_check_loc10404>
    93d1:   ba 08 00 00 00          mov    $0x8,%edx
    93d6:   48 89 c6                mov    %rax,%rsi
    93d9:   e8 82 25 04 00          callq  4b960 <_ZN4core9panicking18panic_bounds_check17hb2d969c3cc11ed08E>
    93de:   66 90                   xchg   %ax,%ax

9390:   50                      push   %rax        # align the stack in case we make a function call (wasted work for the common case)
9391:   48 89 f8                mov    %rdi,%rax   # compiler is dumb, could have checked the value in %rdi
9394:   48 83 f8 07             cmp    $0x7,%rax
9398:   77 30                   ja     93ca <_ZN3des7s_table17hbabdd9dee72331a5E+0x3a>