【问题标题】:Why is writing to memory much slower than reading it?为什么写入内存比读取慢得多?
【发布时间】:2014-11-07 18:17:09
【问题描述】:

这是一个简单的memset 带宽基准测试:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main()
{
    unsigned long n, r, i;
    unsigned char *p;
    clock_t c0, c1;
    double elapsed;

    n = 1000 * 1000 * 1000; /* GB */
    r = 100; /* repeat */

    p = calloc(n, 1);

    c0 = clock();

    for(i = 0; i < r; ++i) {
        memset(p, (int)i, n);
        printf("%4d/%4ld\r", p[0], r); /* "use" the result */
        fflush(stdout);
    }

    c1 = clock();

    elapsed = (c1 - c0) / (double)CLOCKS_PER_SEC;

    printf("Bandwidth = %6.3f GB/s (Giga = 10^9)\n", (double)n * r / elapsed / 1e9);

    free(p);
}

在我的带有单个 DDR3-1600 内存模块的系统上(详情如下),它输出:

带宽 = 4.751 GB/s (千兆 = 10^9)

这是理论 RAM 速度的 37%:1.6 GHz * 8 bytes = 12.8 GB/s

另一方面,这里有一个类似的“读取”测试:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

unsigned long do_xor(const unsigned long* p, unsigned long n)
{
    unsigned long i, x = 0;

    for(i = 0; i < n; ++i)
        x ^= p[i];
    return x;
}

int main()
{
    unsigned long n, r, i;
    unsigned long *p;
    clock_t c0, c1;
    double elapsed;

    n = 1000 * 1000 * 1000; /* GB */
    r = 100; /* repeat */

    p = calloc(n/sizeof(unsigned long), sizeof(unsigned long));

    c0 = clock();

    for(i = 0; i < r; ++i) {
        p[0] = do_xor(p, n / sizeof(unsigned long)); /* "use" the result */
        printf("%4ld/%4ld\r", i, r);
        fflush(stdout);
    }

    c1 = clock();

    elapsed = (c1 - c0) / (double)CLOCKS_PER_SEC;

    printf("Bandwidth = %6.3f GB/s (Giga = 10^9)\n", (double)n * r / elapsed / 1e9);

    free(p);
}

它输出:

带宽 = 11.516 GB/s (千兆 = 10^9)

我可以接近读取性能的理论极限,例如对大型数组进行异或运算,但写入似乎要慢得多。为什么?

操作系统 Ubuntu 14.04 AMD64(我用gcc -O3编译。使用-O3 -march=native会使读取性能稍差,但不影响memset

CPU至强E5-2630 v2

RAM 单个“16GB PC3-12800 Parity REG CL11 240-Pin DIMM”(包装盒上写着什么)我认为拥有单个 DIMM 可以使性能更加可预测。我假设使用 4 个 DIMM,memset最多快 4 倍。

主板 Supermicro X9DRG-QF(支持4通道内存)

附加系统:一台配备 2 个 4GB DDR3-1067 RAM 的笔记本电脑:读写速度均约为 5.5 GB/s,但请注意它使用 2 个 DIMM。

P.S. 用这个版本替换 memset 得到完全相同的性能

void *my_memset(void *s, int c, size_t n)
{
    unsigned long i = 0;
    for(i = 0; i < n; ++i)
        ((char*)s)[i] = (char)c;
    return s;
}

【问题讨论】:

  • printf("%4d/%4ld\r", p[0], r); 在您的基准测试中意味着您很可能是在计时,而不是其他任何事情。 I/O 很慢。
  • @RetiredNinja 不! printf 在运行 20 秒的程序中被调用 101 次
  • 在您发布的代码中,它应该被调用 100 次。它没有理由出现在您进行基准测试的代码部分中。
  • 我在我的系统上尝试过,有无循环中的 printf。差异比我预期的要小(运行 3 次)。有,我得到 9.644、9.667 和 9.629,没有我得到 9.740、9.614 和 9.653
  • 我的 2010 年旧 MacBook 报告 1.937 GB/s 没有优化,173010.381 GB/s 使用发布的代码进行优化,未修改:-) memset 最有可能写入缓存行,该缓存行首先从RAM 要缓存以便被修改,然后刷新,因此每个缓存行都是读取 + 写入的,而不仅仅是读取。剩余的差异可能是由于在非连续位置的读/写。 PowerPC 有清除缓存行的指令,这会有所帮助。

标签: c performance memory hardware


【解决方案1】:

这可能就是它(整个系统)的执行方式。读取速度更快appears to be a common trend,具有宽范围的相对吞吐量性能。在对英特尔 DDR3 和列出的 DDR2 图表的快速分析中,作为(写入/读取)%的几个选择案例;

一些性能最好的 DDR3 芯片的写入速度约为读取吞吐量的 60-70%。然而,有一些内存模块(即 Golden Empire CL11-13-13 D3-2666)只有约 30% 的写入。

与读取相比,性能最高的 DDR2 芯片似乎只有约 50% 的写入吞吐量。但也有一些非常糟糕的竞争者(即 OCZ OCZ21066NEW_BT1G)下降到 ~20%。

虽然这可能无法解释 报告的约 40% 写入/读取的原因,因为使用的基准代码和设置可能不同(notes are vague),但这绝对是 因素。 (我会运行一些现有的基准程序,看看这些数字是否与问题中发布的代码一致。)


更新:

我从链接的站点下载了内存查找表并在 Excel 中进行了处理。虽然它仍然显示了一个宽范围的值,但它比上面的原始回复要少得多,上面的原始回复只查看了顶部读取的内存芯片和一些从图表中选择的“有趣”条目。我不确定为什么这些差异,尤其是在上面挑选出来的可怕竞争者中,没有出现在次要列表中。

但是,即使在新数字下,读取性能的差异仍然在 50%-100%(中位数 65,平均 65)之间。请注意,仅仅因为芯片在写入/读取比率方面的“100%”效率并不意味着它总体上更好......只是在两种操作之间更加平衡。

【讨论】:

  • 不清楚他们是否安装了 1 个 DIMM 或多个 DIMM。我相信这可以产生非常显着的差异。我的测试是“纯”的,因为我只有 1 个 DIMM。
  • @MaxB 这不是很清楚,但它确实显示了广泛的值。这就是为什么我的建议是查看其他基准程序是否会在特定机器上产生类似的值;如果是这样,如果发布的基准测试也适用于不同的硬件。
【解决方案2】:

缓存和局部性几乎可以肯定解释了您所看到的大部分效果。

写入没有任何缓存或局部性,除非您想要一个非确定性系统。大多数写入时间是根据数据一直到达存储介质(无论是硬盘驱动器还是内存芯片)所花费的时间来衡量的,而读取可以来自任何数量的缓存层,这些缓存层的速度比存储介质。

【讨论】:

  • 1 GB 数组比任何缓存大小都大得多(这就是我选择它的原因)。当do_xor 第二次运行时,任何以前缓存的值都将被清除。此外,缓存可以解释读取比 DRAM-> 缓存链接更快(如果是这种情况)。这并不能解释写作速度较慢。
  • 我希望不言而喻,你不需要1GB的缓存也能看到缓存效果。
  • +1 -- 我敢打赌预取与它有关;它不会帮助那些写入,但它会帮助读取。我也愿意打赌 GCC 不太愿意重新排序写入而不是读取。
  • 在 x86 上,普通存储(不是movnt)是强排序的。写入冷缓存行会触发所有权读取。据我了解,CPU 确实会从 DRAM(或较低级别的缓存)读取以填充缓存行。对于具有强排序内存的系统(如 x86),写入比读取更难,但不是因为您给出的原因。在同一个线程完成加载后,存储被允许被缓冲并成为全局可见的。 (MFENCE 是一个 StoreLoad 屏障...)为了简单起见,AMD 确实使用直写式缓存,但英特尔使用回写式缓存以获得更好的性能。
  • 在实践中,使用适合 L1 的缓冲区重复只写循环(如 memset)肯定比使用更大的缓冲区更快。部分原因是已经处于 M 状态(MESI)的行不需要驱逐任何其他行(如果被驱逐的行处于 M 状态并且必须首先写入 L2,这可能会停止,尤其是。如果 L2 然后将修改后的行等逐出到 DRAM)。但另一部分是避免当缓存线已经处于 E 或 M 状态时读取所有权。 movnt 和 Fast String rep movsb 弱序存储避免了 RFO。
【解决方案3】:

这是我的工作假设。如果正确,它解释了为什么写入比读取慢两倍:

尽管memset 只写入虚拟内存,而忽略其先前的内容,但在硬件级别,计算机无法对 DRAM 进行纯写入:它将 DRAM 的内容读入缓存,在那里修改它们,然后写入它们回到DRAM。因此,在硬件层面,memset 既读又写(尽管前者似乎没用)!因此,大约有两倍的速度差异。

【讨论】:

  • 您可以通过弱排序存储(movnt 或 Intel IvB 及以后的rep stos / rep movs“快速字符串操作”)避免这种读取所有权。糟糕的是,没有一种方便的方法可以在不绕过缓存的情况下进行弱排序存储(除了最近的 Intel CPU 上的 memset/memcpy)。我在其他一些答案上留下了类似的 cmets:正常写入触发读取的主要原因是 x86 的强排序内存模型。是否将您的系统限制为一个 DIMM 不应该是其中的一个因素。
  • 我希望其他一些架构,如 ARM,无需任何额外的努力就可以在完整的 DRAM 带宽下写入,因为无法保证存储对程序顺序中的其他线程是可见的。例如对热缓存行的存储可能会立即发生(或者至少在确保没有先前的指令可以出错或错误预测的分支之后),但是对冷缓存行的存储可能只是被缓冲,而其他内核无法看到在冷缓存行被完全重写并且存储缓冲区被刷新之前的值。
【解决方案4】:

性能的主要区别在于您的 PC/内存区域的缓存策略。当您从内存中读取并且数据不在缓存中时,必须首先通过内存总线将内存提取到缓存中,然后才能对数据执行任何计算。但是,当您写入内存时,会有不同的写入策略。您的系统很可能正在使用回写缓存(或更准确地说是“写分配”),这意味着当您写入不在缓存中的内存位置时,数据首先从内存中提取到缓存并最终写入当数据从缓存中被逐出时返回内存,这意味着数据的往返和写入时 2 倍的总线带宽使用。还有直写缓存策略(或“无写入分配”),这通常意味着在写入时缓存未命中时,数据不会被提取到缓存中,并且对于读取和读取应该提供更接近相同的性能写。

【讨论】:

  • 感谢您确认我之前的猜测(我提前 30 分钟发布了它)!我会接受它,直到/除非有人说服我它实际上是不准确的。
  • 在某些平台上,您实际上可以控制每次分配的缓存策略,写入性能是原因之一。
  • 传统架构会在某个时间点将所有脏数据写回内存。如今,许多平台都在尝试通过额外的缓存控制功能来提高性能。例如,像 Cavium Octeon 这样的平台提供了特殊的缓存控制策略,例如 DWB(不写回)选项,以不写回 L2 缓存数据。因此,可以避免不必要的 L2 数据写回内存。
【解决方案5】:

区别——至少在我的机器上,使用 AMD 处理器——是读取程序使用矢量化操作。将两者反编译为编写程序:

0000000000400610 <main>:
  ...
  400628:       e8 73 ff ff ff          callq  4005a0 <clock@plt>
  40062d:       49 89 c4                mov    %rax,%r12
  400630:       89 de                   mov    %ebx,%esi
  400632:       ba 00 ca 9a 3b          mov    $0x3b9aca00,%edx
  400637:       48 89 ef                mov    %rbp,%rdi
  40063a:       e8 71 ff ff ff          callq  4005b0 <memset@plt>
  40063f:       0f b6 55 00             movzbl 0x0(%rbp),%edx
  400643:       b9 64 00 00 00          mov    $0x64,%ecx
  400648:       be 34 08 40 00          mov    $0x400834,%esi
  40064d:       bf 01 00 00 00          mov    $0x1,%edi
  400652:       31 c0                   xor    %eax,%eax
  400654:       48 83 c3 01             add    $0x1,%rbx
  400658:       e8 a3 ff ff ff          callq  400600 <__printf_chk@plt>

但这对于阅读程序来说:

00000000004005d0 <main>:
  ....
  400609:       e8 62 ff ff ff          callq  400570 <clock@plt>
  40060e:       49 d1 ee                shr    %r14
  400611:       48 89 44 24 18          mov    %rax,0x18(%rsp)
  400616:       4b 8d 04 e7             lea    (%r15,%r12,8),%rax
  40061a:       4b 8d 1c 36             lea    (%r14,%r14,1),%rbx
  40061e:       48 89 44 24 10          mov    %rax,0x10(%rsp)
  400623:       0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)
  400628:       4d 85 e4                test   %r12,%r12
  40062b:       0f 84 df 00 00 00       je     400710 <main+0x140>
  400631:       49 8b 17                mov    (%r15),%rdx
  400634:       bf 01 00 00 00          mov    $0x1,%edi
  400639:       48 8b 74 24 10          mov    0x10(%rsp),%rsi
  40063e:       66 0f ef c0             pxor   %xmm0,%xmm0
  400642:       31 c9                   xor    %ecx,%ecx
  400644:       0f 1f 40 00             nopl   0x0(%rax)
  400648:       48 83 c1 01             add    $0x1,%rcx
  40064c:       66 0f ef 06             pxor   (%rsi),%xmm0
  400650:       48 83 c6 10             add    $0x10,%rsi
  400654:       49 39 ce                cmp    %rcx,%r14
  400657:       77 ef                   ja     400648 <main+0x78>
  400659:       66 0f 6f d0             movdqa %xmm0,%xmm2 ;!!!! vectorized magic
  40065d:       48 01 df                add    %rbx,%rdi
  400660:       66 0f 73 da 08          psrldq $0x8,%xmm2
  400665:       66 0f ef c2             pxor   %xmm2,%xmm0
  400669:       66 0f 7f 04 24          movdqa %xmm0,(%rsp)
  40066e:       48 8b 04 24             mov    (%rsp),%rax
  400672:       48 31 d0                xor    %rdx,%rax
  400675:       48 39 dd                cmp    %rbx,%rbp
  400678:       74 04                   je     40067e <main+0xae>
  40067a:       49 33 04 ff             xor    (%r15,%rdi,8),%rax
  40067e:       4c 89 ea                mov    %r13,%rdx
  400681:       49 89 07                mov    %rax,(%r15)
  400684:       b9 64 00 00 00          mov    $0x64,%ecx
  400689:       be 04 0a 40 00          mov    $0x400a04,%esi
  400695:       e8 26 ff ff ff          callq  4005c0 <__printf_chk@plt>
  40068e:       bf 01 00 00 00          mov    $0x1,%edi
  400693:       31 c0                   xor    %eax,%eax

另外,请注意,您的“本土”memset 实际上已优化为对memset 的调用:

00000000004007b0 <my_memset>:
  4007b0:       48 85 d2                test   %rdx,%rdx
  4007b3:       74 1b                   je     4007d0 <my_memset+0x20>
  4007b5:       48 83 ec 08             sub    $0x8,%rsp
  4007b9:       40 0f be f6             movsbl %sil,%esi
  4007bd:       e8 ee fd ff ff          callq  4005b0 <memset@plt>
  4007c2:       48 83 c4 08             add    $0x8,%rsp
  4007c6:       c3                      retq   
  4007c7:       66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
  4007ce:       00 00 
  4007d0:       48 89 f8                mov    %rdi,%rax
  4007d3:       c3                      retq   
  4007d4:       66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
  4007db:       00 00 00 
  4007de:       66 90                   xchg   %ax,%ax

我找不到任何关于memset 是否使用矢量化操作的参考资料,memset@plt 的反汇编在这里没有帮助:

00000000004005b0 <memset@plt>:
  4005b0:       ff 25 72 0a 20 00       jmpq   *0x200a72(%rip)        # 601028 <_GLOBAL_OFFSET_TABLE_+0x28>
  4005b6:       68 02 00 00 00          pushq  $0x2
  4005bb:       e9 c0 ff ff ff          jmpq   400580 <_init+0x20>

This question 建议由于memset 旨在处理每种情况,它可能会缺少一些优化。

This guy 似乎确信您需要滚动自己的汇编程序memset 以利用 SIMD 指令。 This question does, too

我将在黑暗中试一试,并猜测它没有使用 SIMD 操作,因为它无法判断它是否会在一个矢量化操作大小的倍数上进行操作,或者存在一些与对齐相关的问题。

但是,我们可以通过检查cachegrind 来确认这不是缓存效率问题。写入程序产生以下内容:

==19593== D   refs:       6,312,618,768  (80,386 rd   + 6,312,538,382 wr)
==19593== D1  misses:     1,578,132,439  ( 5,350 rd   + 1,578,127,089 wr)
==19593== LLd misses:     1,578,131,849  ( 4,806 rd   + 1,578,127,043 wr)
==19593== D1  miss rate:           24.9% (   6.6%     +          24.9%  )
==19593== LLd miss rate:           24.9% (   5.9%     +          24.9%  )
==19593== 
==19593== LL refs:        1,578,133,467  ( 6,378 rd   + 1,578,127,089 wr)
==19593== LL misses:      1,578,132,871  ( 5,828 rd   + 1,578,127,043 wr) << 
==19593== LL miss rate:             9.0% (   0.0%     +          24.9%  )

读取程序产生:

==19682== D   refs:       6,312,618,618  (6,250,080,336 rd   + 62,538,282 wr)
==19682== D1  misses:     1,578,132,331  (1,562,505,046 rd   + 15,627,285 wr)
==19682== LLd misses:     1,578,131,740  (1,562,504,500 rd   + 15,627,240 wr)
==19682== D1  miss rate:           24.9% (         24.9%     +       24.9%  )
==19682== LLd miss rate:           24.9% (         24.9%     +       24.9%  )
==19682== 
==19682== LL refs:        1,578,133,357  (1,562,506,072 rd   + 15,627,285 wr)
==19682== LL misses:      1,578,132,760  (1,562,505,520 rd   + 15,627,240 wr) <<
==19682== LL miss rate:             4.1% (          4.1%     +       24.9%  )

虽然读取程序的 LL 未命中率较低,因为它执行的读取次数更多(每个XOR 操作额外读取一次),但未命中的总数是相同的。所以不管是什么问题,它都不存在。

【讨论】:

  • 您是否也看到了 2 倍的带宽差异?你能发布你的数字和内存配置吗?
  • This guy definitely seems convinced ...他的缓冲区小了244000倍,适合各种缓存。
  • 你的 memset 几乎可以肯定在某种程度上是矢量化的;一些更智能的实现将在启动到矢量化版本之前运行一个小循环以对齐。我猜你在 Linux 上,可能使用 glibc,所以这里是its memset。 (稍微摆弄一下 GOT 或 GDB 中的几个 stepis,您应该能够自己找到实现。)
【解决方案6】:

有了你的程序,我明白了

(write) Bandwidth =  6.076 GB/s
(read)  Bandwidth = 10.916 GB/s

在具有六个 2GB DIMM 的桌面(Core i7、x86-64、GCC 4.9、GNU libc 2.19)机器上。 (抱歉,我没有比这更详细的信息了。)

然而,这个程序报告写带宽为12.209 GB/s

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <emmintrin.h>

static void
nt_memset(char *buf, unsigned char val, size_t n)
{
    /* this will only work with aligned address and size */
    assert((uintptr_t)buf % sizeof(__m128i) == 0);
    assert(n % sizeof(__m128i) == 0);

    __m128i xval = _mm_set_epi8(val, val, val, val,
                                val, val, val, val,
                                val, val, val, val,
                                val, val, val, val);

    for (__m128i *p = (__m128i*)buf; p < (__m128i*)(buf + n); p++)
        _mm_stream_si128(p, xval);
    _mm_sfence();
}

/* same main() as your write test, except calling nt_memset instead of memset */

神奇之处在于_mm_stream_si128,也就是机器指令movntdq,它将16字节的数量写入系统RAM,绕过缓存(官方术语是“@ 987654321@")。我认为这非常明确地表明性能差异都与缓存行为有关。

注意glibc 2.19 确实有一个精心手工优化的memset,它利用了向量指令。但是,它确实使用非临时存储。这可能是memset 的正确选择;通常,您会在使用它之前不久清除内存,因此您希望它在缓存中是热的。 (我想一个更聪明的memset 可能会切换到非临时存储以清除非常大块,理论上你不可能希望所有这些都在缓存中,因为缓存只是没那么大。)

Dump of assembler code for function memset:
=> 0x00007ffff7ab9420 <+0>:     movd   %esi,%xmm8
   0x00007ffff7ab9425 <+5>:     mov    %rdi,%rax
   0x00007ffff7ab9428 <+8>:     punpcklbw %xmm8,%xmm8
   0x00007ffff7ab942d <+13>:    punpcklwd %xmm8,%xmm8
   0x00007ffff7ab9432 <+18>:    pshufd $0x0,%xmm8,%xmm8
   0x00007ffff7ab9438 <+24>:    cmp    $0x40,%rdx
   0x00007ffff7ab943c <+28>:    ja     0x7ffff7ab9470 <memset+80>
   0x00007ffff7ab943e <+30>:    cmp    $0x10,%rdx
   0x00007ffff7ab9442 <+34>:    jbe    0x7ffff7ab94e2 <memset+194>
   0x00007ffff7ab9448 <+40>:    cmp    $0x20,%rdx
   0x00007ffff7ab944c <+44>:    movdqu %xmm8,(%rdi)
   0x00007ffff7ab9451 <+49>:    movdqu %xmm8,-0x10(%rdi,%rdx,1)
   0x00007ffff7ab9458 <+56>:    ja     0x7ffff7ab9460 <memset+64>
   0x00007ffff7ab945a <+58>:    repz retq 
   0x00007ffff7ab945c <+60>:    nopl   0x0(%rax)
   0x00007ffff7ab9460 <+64>:    movdqu %xmm8,0x10(%rdi)
   0x00007ffff7ab9466 <+70>:    movdqu %xmm8,-0x20(%rdi,%rdx,1)
   0x00007ffff7ab946d <+77>:    retq   
   0x00007ffff7ab946e <+78>:    xchg   %ax,%ax
   0x00007ffff7ab9470 <+80>:    lea    0x40(%rdi),%rcx
   0x00007ffff7ab9474 <+84>:    movdqu %xmm8,(%rdi)
   0x00007ffff7ab9479 <+89>:    and    $0xffffffffffffffc0,%rcx
   0x00007ffff7ab947d <+93>:    movdqu %xmm8,-0x10(%rdi,%rdx,1)
   0x00007ffff7ab9484 <+100>:   movdqu %xmm8,0x10(%rdi)
   0x00007ffff7ab948a <+106>:   movdqu %xmm8,-0x20(%rdi,%rdx,1)
   0x00007ffff7ab9491 <+113>:   movdqu %xmm8,0x20(%rdi)
   0x00007ffff7ab9497 <+119>:   movdqu %xmm8,-0x30(%rdi,%rdx,1)
   0x00007ffff7ab949e <+126>:   movdqu %xmm8,0x30(%rdi)
   0x00007ffff7ab94a4 <+132>:   movdqu %xmm8,-0x40(%rdi,%rdx,1)
   0x00007ffff7ab94ab <+139>:   add    %rdi,%rdx
   0x00007ffff7ab94ae <+142>:   and    $0xffffffffffffffc0,%rdx
   0x00007ffff7ab94b2 <+146>:   cmp    %rdx,%rcx
   0x00007ffff7ab94b5 <+149>:   je     0x7ffff7ab945a <memset+58>
   0x00007ffff7ab94b7 <+151>:   nopw   0x0(%rax,%rax,1)
   0x00007ffff7ab94c0 <+160>:   movdqa %xmm8,(%rcx)
   0x00007ffff7ab94c5 <+165>:   movdqa %xmm8,0x10(%rcx)
   0x00007ffff7ab94cb <+171>:   movdqa %xmm8,0x20(%rcx)
   0x00007ffff7ab94d1 <+177>:   movdqa %xmm8,0x30(%rcx)
   0x00007ffff7ab94d7 <+183>:   add    $0x40,%rcx
   0x00007ffff7ab94db <+187>:   cmp    %rcx,%rdx
   0x00007ffff7ab94de <+190>:   jne    0x7ffff7ab94c0 <memset+160>
   0x00007ffff7ab94e0 <+192>:   repz retq 
   0x00007ffff7ab94e2 <+194>:   movq   %xmm8,%rcx
   0x00007ffff7ab94e7 <+199>:   test   $0x18,%dl
   0x00007ffff7ab94ea <+202>:   jne    0x7ffff7ab950e <memset+238>
   0x00007ffff7ab94ec <+204>:   test   $0x4,%dl
   0x00007ffff7ab94ef <+207>:   jne    0x7ffff7ab9507 <memset+231>
   0x00007ffff7ab94f1 <+209>:   test   $0x1,%dl
   0x00007ffff7ab94f4 <+212>:   je     0x7ffff7ab94f8 <memset+216>
   0x00007ffff7ab94f6 <+214>:   mov    %cl,(%rdi)
   0x00007ffff7ab94f8 <+216>:   test   $0x2,%dl
   0x00007ffff7ab94fb <+219>:   je     0x7ffff7ab945a <memset+58>
   0x00007ffff7ab9501 <+225>:   mov    %cx,-0x2(%rax,%rdx,1)
   0x00007ffff7ab9506 <+230>:   retq   
   0x00007ffff7ab9507 <+231>:   mov    %ecx,(%rdi)
   0x00007ffff7ab9509 <+233>:   mov    %ecx,-0x4(%rdi,%rdx,1)
   0x00007ffff7ab950d <+237>:   retq   
   0x00007ffff7ab950e <+238>:   mov    %rcx,(%rdi)
   0x00007ffff7ab9511 <+241>:   mov    %rcx,-0x8(%rdi,%rdx,1)
   0x00007ffff7ab9516 <+246>:   retq   

(这是在libc.so.6 中,而不是程序本身——另一个试图为memset 转储程序集的人似乎只是找到了它的PLT 条目。获得真正的程序集转储的最简单方法memset 在 Unixy 系统上是

$ gdb ./a.out
(gdb) set env LD_BIND_NOW t
(gdb) b main
Breakpoint 1 at [address]
(gdb) r
Breakpoint 1, [address] in main ()
(gdb) disas memset
...

.)

【讨论】:

  • 很好的答案!当你的答案出现在我的浏览器中时,我已经接受了 JarkkoL 的答案。我想我会坚持这个决定,因为他的回答似乎是正确的。
  • 啊,我想我一定是错了memset,感谢发布正确的反汇编。很高兴知道 gdb 中的这个技巧!
  • movnt 存储可以为大型 memset 提供更好的写入带宽的主要原因是它们是弱有序的。在写入新的缓存行时,它们可以跳过读取所有权步骤,因为不能保证它们在彼此之间或相对于普通存储的顺序是全局可见的。在具有“快速字符串操作”(Intel IvB 及更高版本)的 CPU 上,rep stos 使用稍微弱排序的存储来获得相同的加速,但不会绕过缓存。据我了解文档,操作结束时有一个存储围栏,所以不要将标志存储为 memset/cpy 的一部分。
  • @PeterCordes 如果我理解您的评论,CPU 内核是否正在读取高速缓存行,即使它将被完全覆盖?有什么方法可以在其他写指令中强制这种“弱”行为? (我的意思是,有一种方法可以在不先读取内存的情况下写入内存,并将数据保存在缓存中?)
  • @Will:要让其他存储以这种方式工作,您必须写入使用 MTRR 或 PAT 设置的 WC(不可缓存写入组合)而不是普通 WB 的内存区域。在大多数操作系统下,通常不能以这种方式从用户空间轻松分配内存,这使得高效读取变得困难。另请参阅Enhanced REP MOVSB for memcpy,了解有关 NT 商店与常规商店的更多信息。是的,正常的强排序存储总是在将数据提交到处于修改状态的 L1d 缓存之前执行 RFO(读取所有权),而不是仅仅使其他缓存无效并进入 DRAM。
【解决方案7】:

因为要读取,您只需脉冲地址线并读出感应线上的核心状态。回写周期发生在数据传送到 CPU 之后,因此不会减慢速度。另一方面,要写入,您必须先执行假读取以重置内核,然后执行写入周期。

(以防万一不明显,这个答案是开玩笑的——描述了为什么在旧的核心内存盒上写比读慢。)

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2018-03-24
    • 1970-01-01
    • 2019-11-24
    • 2018-01-02
    • 2016-10-28
    • 2012-03-11
    相关资源
    最近更新 更多