Linuxでのmemcpyパフォーマンスの低下

最近、いくつかの新しいサーバーを購入し、memcpyのパフォーマンスが低下しています。memcpyのパフォーマンスは、ラップトップに比べてサーバーで3倍遅くなります。

サーバースペック

• シャーシとモボ：SUPER MICRO 1027GR-TRF
• CPU：2x Intel Xeon E5-2680 @ 2.70 Ghz
• メモリ：8x 16GB DDR3 1600MHz

編集：私はわずかに高い仕様の別のサーバーでもテストしており、上記のサーバーと同じ結果が表示されています

サーバー2の仕様

• シャーシとモボ：SUPER MICRO 10227GR-TRFT
• CPU：2x Intel Xeon E5-2650 v2 @ 2.6 Ghz
• メモリ：8x 16GB DDR3 1866MHz

ノートパソコンの仕様

• シャーシ：Lenovo W530
• CPU：1x Intel Core i7 i7-3720QM @ 2.6Ghz
• メモリ：4GB 4GB DDR3 1600MHz

オペレーティング・システム

$ cat /etc/redhat-release
Scientific Linux release 6.5 (Carbon) 
$ uname -a                      
Linux r113 2.6.32-431.1.2.el6.x86_64 #1 SMP Thu Dec 12 13:59:19 CST 2013 x86_64 x86_64 x86_64 GNU/Linux

コンパイラー（すべてのシステム）

$ gcc --version
gcc (GCC) 4.6.1

@stefanの提案に基づいて、gcc 4.8.2でもテストされています。コンパイラ間のパフォーマンスの違いはありませんでした。

テストコード以下のテストコードは、本番用コードで見られる問題を再現するための定型テストです。このベンチマークは単純であることは知っていますが、問題を悪用して特定することができました。コードは2つの1GBバッファーとそれらの間のmemcpyを作成し、memcpy呼び出しのタイミングをとります。次のコマンドを使用して、コマンドラインで代替バッファサイズを指定できます。./big_memcpy_test [SIZE_BYTES]

#include <chrono>
#include <cstring>
#include <iostream>
#include <cstdint>

class Timer
{
 public:
  Timer()
      : mStart(),
        mStop()
  {
    update();
  }

  void update()
  {
    mStart = std::chrono::high_resolution_clock::now();
    mStop  = mStart;
  }

  double elapsedMs()
  {
    mStop = std::chrono::high_resolution_clock::now();
    std::chrono::milliseconds elapsed_ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(mStop - mStart);
    return elapsed_ms.count();
  }

 private:
  std::chrono::high_resolution_clock::time_point mStart;
  std::chrono::high_resolution_clock::time_point mStop;
};

std::string formatBytes(std::uint64_t bytes)
{
  static const int num_suffix = 5;
  static const char* suffix[num_suffix] = { "B", "KB", "MB", "GB", "TB" };
  double dbl_s_byte = bytes;
  int i = 0;
  for (; (int)(bytes / 1024.) > 0 && i < num_suffix;
       ++i, bytes /= 1024.)
  {
    dbl_s_byte = bytes / 1024.0;
  }

  const int buf_len = 64;
  char buf[buf_len];

  // use snprintf so there is no buffer overrun
  int res = snprintf(buf, buf_len,"%0.2f%s", dbl_s_byte, suffix[i]);

  // snprintf returns number of characters that would have been written if n had
  //       been sufficiently large, not counting the terminating null character.
  //       if an encoding error occurs, a negative number is returned.
  if (res >= 0)
  {
    return std::string(buf);
  }
  return std::string();
}

void doMemmove(void* pDest, const void* pSource, std::size_t sizeBytes)
{
  memmove(pDest, pSource, sizeBytes);
}

int main(int argc, char* argv[])
{
  std::uint64_t SIZE_BYTES = 1073741824; // 1GB

  if (argc > 1)
  {
    SIZE_BYTES = std::stoull(argv[1]);
    std::cout << "Using buffer size from command line: " << formatBytes(SIZE_BYTES)
              << std::endl;
  }
  else
  {
    std::cout << "To specify a custom buffer size: big_memcpy_test [SIZE_BYTES] \n"
              << "Using built in buffer size: " << formatBytes(SIZE_BYTES)
              << std::endl;
  }


  // big array to use for testing
  char* p_big_array = NULL;

  /////////////
  // malloc 
  {
    Timer timer;

    p_big_array = (char*)malloc(SIZE_BYTES * sizeof(char));
    if (p_big_array == NULL)
    {
      std::cerr << "ERROR: malloc of " << SIZE_BYTES << " returned NULL!"
                << std::endl;
      return 1;
    }

    std::cout << "malloc for " << formatBytes(SIZE_BYTES) << " took "
              << timer.elapsedMs() << "ms"
              << std::endl;
  }

  /////////////
  // memset
  {
    Timer timer;

    // set all data in p_big_array to 0
    memset(p_big_array, 0xF, SIZE_BYTES * sizeof(char));

    double elapsed_ms = timer.elapsedMs();
    std::cout << "memset for " << formatBytes(SIZE_BYTES) << " took "
              << elapsed_ms << "ms "
              << "(" << formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) << " bytes/sec)"
              << std::endl;
  }

  /////////////
  // memcpy 
  {
    char* p_dest_array = (char*)malloc(SIZE_BYTES);
    if (p_dest_array == NULL)
    {
      std::cerr << "ERROR: malloc of " << SIZE_BYTES << " for memcpy test"
                << " returned NULL!"
                << std::endl;
      return 1;
    }
    memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));

    // time only the memcpy FROM p_big_array TO p_dest_array
    Timer timer;

    memcpy(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));

    double elapsed_ms = timer.elapsedMs();
    std::cout << "memcpy for " << formatBytes(SIZE_BYTES) << " took "
              << elapsed_ms << "ms "
              << "(" << formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) << " bytes/sec)"
              << std::endl;

    // cleanup p_dest_array
    free(p_dest_array);
    p_dest_array = NULL;
  }

  /////////////
  // memmove
  {
    char* p_dest_array = (char*)malloc(SIZE_BYTES);
    if (p_dest_array == NULL)
    {
      std::cerr << "ERROR: malloc of " << SIZE_BYTES << " for memmove test"
                << " returned NULL!"
                << std::endl;
      return 1;
    }
    memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));

    // time only the memmove FROM p_big_array TO p_dest_array
    Timer timer;

    // memmove(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
    doMemmove(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));

    double elapsed_ms = timer.elapsedMs();
    std::cout << "memmove for " << formatBytes(SIZE_BYTES) << " took "
              << elapsed_ms << "ms "
              << "(" << formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) << " bytes/sec)"
              << std::endl;

    // cleanup p_dest_array
    free(p_dest_array);
    p_dest_array = NULL;
  }


  // cleanup
  free(p_big_array);
  p_big_array = NULL;

  return 0;
}

ビルドするCMakeファイル

project(big_memcpy_test)
cmake_minimum_required(VERSION 2.4.0)

include_directories(${CMAKE_CURRENT_SOURCE_DIR})

# create verbose makefiles that show each command line as it is issued
set( CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "Verbose" FORCE )
# release mode
set( CMAKE_BUILD_TYPE Release )
# grab in CXXFLAGS environment variable and append C++11 and -Wall options
set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -Wall -march=native -mtune=native" )
message( INFO "CMAKE_CXX_FLAGS = ${CMAKE_CXX_FLAGS}" )

# sources to build
set(big_memcpy_test_SRCS
  main.cpp
)

# create an executable file named "big_memcpy_test" from
# the source files in the variable "big_memcpy_test_SRCS".
add_executable(big_memcpy_test ${big_memcpy_test_SRCS})

試験結果

Buffer Size: 1GB | malloc (ms) | memset (ms) | memcpy (ms) | NUMA nodes (numactl --hardware)
---------------------------------------------------------------------------------------------
Laptop 1         | 0           | 127         | 113         | 1
Laptop 2         | 0           | 180         | 120         | 1
Server 1         | 0           | 306         | 301         | 2
Server 2         | 0           | 352         | 325         | 2

ご覧のとおり、サーバー上のmemcpysとmemsetsは、ラップトップ上のmemcpysとmemsetsよりもはるかに低速です。

さまざまなバッファサイズ

100MBから5GBまでのバッファーをすべて試しましたが、すべて同じような結果になります（サーバーはラップトップより遅い）

NUMAアフィニティ

NUMAでパフォーマンスの問題を抱えている人々について読んだので、numactlを使用してCPUとメモリのアフィニティを設定してみましたが、結果は同じままでした。

サーバーNUMAハードウェア

$ numactl --hardware                                                            
available: 2 nodes (0-1)                                                                     
node 0 cpus: 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23                                         
node 0 size: 65501 MB                                                                        
node 0 free: 62608 MB                                                                        
node 1 cpus: 8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31                                   
node 1 size: 65536 MB                                                                        
node 1 free: 63837 MB                                                                        
node distances:                                                                              
node   0   1                                                                                 
  0:  10  21                                                                                 
  1:  21  10 

ラップトップNUMAハードウェア

$ numactl --hardware
available: 1 nodes (0)
node 0 cpus: 0 1 2 3 4 5 6 7
node 0 size: 16018 MB
node 0 free: 6622 MB
node distances:
node   0 
  0:  10

NUMAアフィニティの設定

$ numactl --cpunodebind=0 --membind=0 ./big_memcpy_test

これを解決するための助けは大歓迎です。

編集：GCCオプション

コメントに基づいて、さまざまなGCCオプションでコンパイルしてみました。

-marchおよび-mtuneをネイティブに設定してコンパイルする

g++ -std=c++0x -Wall -march=native -mtune=native -O3 -DNDEBUG -o big_memcpy_test main.cpp 

結果：まったく同じパフォーマンス（改善なし）

-O3の代わりに-O2でコンパイルする

g++ -std=c++0x -Wall -march=native -mtune=native -O2 -DNDEBUG -o big_memcpy_test main.cpp

結果：まったく同じパフォーマンス（改善なし）

編集：NULLページを回避するためにmemsetを0ではなく0xFに書き込むように変更（@SteveCox）

0以外の値でmemsettingを実行しても、改善はありません（この場合は0xFを使用）。

編集：キャッシュベンチの結果

テストプログラムが単純すぎることを除外するために、実際のベンチマークプログラムLLCacheBench（http://icl.cs.utk.edu/projects/llcbench/cachebench.html）をダウンロードしました

アーキテクチャの問題を回避するために、各マシンで個別にベンチマークを構築しました。以下は私の結果です。

非常に大きな違いは、より大きなバッファーサイズでのパフォーマンスです。テストされた最後のサイズ（16777216）は、ラップトップでは18849.29 MB /秒、サーバーでは6710.40で実行されました。それはパフォーマンスの約3倍の違いです。また、サーバーのパフォーマンスの低下は、ラップトップの場合よりもかなり急です。

編集：memmove（）はサーバー上のmemcpy（）より2倍高速です

いくつかの実験に基づいて、テストケースでmemcpy（）の代わりにmemmove（）を使用してみましたが、サーバーで2倍の改善が見つかりました。ラップトップ上のMemmove（）はmemcpy（）よりも低速で実行されますが、奇妙なことに、サーバー上のmemmove（）と同じ速度で実行されます。これは疑問を投げかけます、なぜmemcpyはとても遅いのですか？

memcpyと共にmemmoveをテストするようにコードを更新しました。memmove（）を関数内にラップする必要があったのは、インラインで残した場合、GCCがそれを最適化し、me​​mcpy（）とまったく同じように実行したためです（場所が重複していないことがわかっているため、gccがmemcpyに最適化したと想定しています）。

更新された結果

Buffer Size: 1GB | malloc (ms) | memset (ms) | memcpy (ms) | memmove() | NUMA nodes (numactl --hardware)
---------------------------------------------------------------------------------------------------------
Laptop 1         | 0           | 127         | 113         | 161       | 1
Laptop 2         | 0           | 180         | 120         | 160       | 1
Server 1         | 0           | 306         | 301         | 159       | 2
Server 2         | 0           | 352         | 325         | 159       | 2

編集：Naive Memcpy

@Salgarからの提案に基づいて、私は自分の単純なmemcpy関数を実装してテストしました。

素朴なMemcpyソース

void naiveMemcpy(void* pDest, const void* pSource, std::size_t sizeBytes)
{
  char* p_dest = (char*)pDest;
  const char* p_source = (const char*)pSource;
  for (std::size_t i = 0; i < sizeBytes; ++i)
  {
    *p_dest++ = *p_source++;
  }
}

単純なMemcpyの結果とmemcpy（）の比較

Buffer Size: 1GB | memcpy (ms) | memmove(ms) | naiveMemcpy()
------------------------------------------------------------
Laptop 1         | 113         | 161         | 160
Server 1         | 301         | 159         | 159
Server 2         | 325         | 159         | 159

編集：アセンブリ出力

シンプルなmemcpyソース

#include <cstring>
#include <cstdlib>

int main(int argc, char* argv[])
{
  size_t SIZE_BYTES = 1073741824; // 1GB

  char* p_big_array  = (char*)malloc(SIZE_BYTES * sizeof(char));
  char* p_dest_array = (char*)malloc(SIZE_BYTES * sizeof(char));

  memset(p_big_array,  0xA, SIZE_BYTES * sizeof(char));
  memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));

  memcpy(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));

  free(p_dest_array);
  free(p_big_array);

  return 0;
}

アセンブリ出力：これはサーバーとラップトップの両方でまったく同じです。スペースを節約し、両方を貼り付けません。

        .file   "main_memcpy.cpp"
        .section        .text.startup,"ax",@progbits
        .p2align 4,,15
        .globl  main
        .type   main, @function
main:
.LFB25:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movl    $1073741824, %edi
        pushq   %rbx
        .cfi_def_cfa_offset 24
        .cfi_offset 3, -24
        subq    $8, %rsp
        .cfi_def_cfa_offset 32
        call    malloc
        movl    $1073741824, %edi
        movq    %rax, %rbx
        call    malloc
        movl    $1073741824, %edx
        movq    %rax, %rbp
        movl    $10, %esi
        movq    %rbx, %rdi
        call    memset
        movl    $1073741824, %edx
        movl    $15, %esi
        movq    %rbp, %rdi
        call    memset
        movl    $1073741824, %edx
        movq    %rbx, %rsi
        movq    %rbp, %rdi
        call    memcpy
        movq    %rbp, %rdi
        call    free
        movq    %rbx, %rdi
        call    free
        addq    $8, %rsp
        .cfi_def_cfa_offset 24
        xorl    %eax, %eax
        popq    %rbx
        .cfi_def_cfa_offset 16
        popq    %rbp
        .cfi_def_cfa_offset 8
        ret
        .cfi_endproc
.LFE25:
        .size   main, .-main
        .ident  "GCC: (GNU) 4.6.1"
        .section        .note.GNU-stack,"",@progbits

進捗！！！！asmlib

@tbensonからの提案に基づいて、memcpyのasmlibバージョンで実行してみました。私の結果は最初は貧弱でしたが、SetMemcpyCacheLimit（）を1GB（私のバッファーのサイズ）に変更した後、私は単純なforループと同等の速度で実行していました！

悪いニュースは、memoveのasmlibバージョンがglibcバージョンよりも遅いことです。現在、300msのマークで実行されています（memcpyのglibcバージョンと同等）。奇妙なことに、ラップトップでSetMemcpyCacheLimit（）を大きくすると、パフォーマンスが低下します...

以下の結果では、SetCacheでマークされた行のSetMemcpyCacheLimitが1073741824に設定されています。SetCacheがない結果は、SetMemcpyCacheLimit（）を呼び出しません。

asmlibの関数を使用した結果：

Buffer Size: 1GB  | memcpy (ms) | memmove(ms) | naiveMemcpy()
------------------------------------------------------------
Laptop            | 136         | 132         | 161
Laptop SetCache   | 182         | 137         | 161
Server 1          | 305         | 302         | 164
Server 1 SetCache | 162         | 303         | 164
Server 2          | 300         | 299         | 166
Server 2 SetCache | 166         | 301         | 166

キャッシュの問題に傾くようになりましたが、何が原因でしょうか？