Question

我需要读取一个由许多基本类型组成的二进制文件，例如int，double，UTF8字符串等。例如，想一个包含n对（int，double）的文件，一个接一个，没有与n的任何对齐大约为数千万。我需要非常快速地访问该文件。我使用fread调用和我自己的缓冲区读取文件，该缓冲区长度约为16 kB。

分析器显示我的主要瓶颈恰好是从内存缓冲区复制到最终目标。编写从缓冲区复制到double的函数最明显的方法是：

// x: a pointer to the final destination of the data
// p: a pointer to the buffer used to read the file
//
void f0(double* x, const unsigned char* p) {
  unsigned char* q = reinterpret_cast<unsigned char*>(x);
  for (int i = 0; i < 8; ++i) {
    q[i] = p[i];
  }
}

我使用以下代码，在x86-64

上获得了巨大的加速

void f1(double* x, const unsigned char* p) {
  double* r = reinterpret_cast<const double*>(p);
  *x = *r;
}

但是，据我所知，如果p不是8字节对齐，程序将在ARM上崩溃。

以下是我的问题：

第二个程序是否可以在x86和x86-64上运行？
如果你需要尽可能快的话，你会如何在ARM上编写这样的函数？

这是在您的机器上测试的小基准

#include <chrono>
#include <iostream>

void copy_int_0(int* x, const unsigned char* p) {
  unsigned char* q = reinterpret_cast<unsigned char*>(x);
  for (std::size_t i = 0; i < 4; ++i) {
    q[i] = p[i];
  }
}

void copy_double_0(double* x, const unsigned char* p) {
  unsigned char* q = reinterpret_cast<unsigned char*>(x);
  for (std::size_t i = 0; i < 8; ++i) {
    q[i] = p[i];
  }
}

void copy_int_1(int* x, const unsigned char* p) {
  *x = *reinterpret_cast<const int*>(p);
}

void copy_double_1(double* x, const unsigned char* p) {
  *x = *reinterpret_cast<const double*>(p);
}

int main() {
  const std::size_t n = 10000000;
  const std::size_t nb_times = 200;
  unsigned char* p = new unsigned char[12 * n];
  for (std::size_t i = 0; i < 12 * n; ++i) {
    p[i] = 0;
  }
  int* q0 = new int[n];
  for (std::size_t i = 0; i < n; ++i) {
    q0[i] = 0;
  }
  double* q1 = new double[n];
  for (std::size_t i = 0; i < n; ++i) {
    q1[i] = 0.0;
  }

  const auto begin_0 = std::chrono::high_resolution_clock::now();
  for (std::size_t k = 0; k < nb_times; ++k) {
    for (std::size_t i = 0; i < n; ++i) {
      copy_int_0(q0 + i, p + 12 * i);
      copy_double_0(q1 + i, p + 4 + 12 * i);
    }
  }
  const auto end_0 = std::chrono::high_resolution_clock::now();
  const double time_0 =
      1.0e-9 *
      std::chrono::duration_cast<std::chrono::nanoseconds>(end_0 - begin_0)
          .count();
  std::cout << "Time 0: " << time_0 << " s" << std::endl;

  const auto begin_1 = std::chrono::high_resolution_clock::now();
  for (std::size_t k = 0; k < nb_times; ++k) {
    for (std::size_t i = 0; i < n; ++i) {
      copy_int_1(q0 + i, p + 12 * i);
      copy_double_1(q1 + i, p + 4 + 12 * i);
    }
  }
  const auto end_1 = std::chrono::high_resolution_clock::now();
  const double time_1 =
      1.0e-9 *
      std::chrono::duration_cast<std::chrono::nanoseconds>(end_1 - begin_1)
          .count();
  std::cout << "Time 1: " << time_1 << " s" << std::endl;
  std::cout << "Prevent optimization: " << q0[0] << " " << q1[0] << std::endl;

  delete[] q1;
  delete[] q0;
  delete[] p;

  return 0;
}

我得到的结果是

clang++ -std=c++11 -O3 -march=native copy.cpp -o copy
./copy
Time 0: 8.49403 s
Time 1: 4.01617 s

g++ -std=c++11 -O3 -march=native copy.cpp -o copy
./copy
Time 0: 8.65762 s
Time 1: 3.89979 s

icpc -std=c++11 -O3 -xHost copy.cpp -o copy
./copy
Time 0: 8.46155 s
Time 1: 0.0278496 s

我还没有检查程序集，但我想英特尔编译器在这里愚弄我的基准。

Answer 1

第二个程序是否可以在x86和x86-64上运行？

没有

当您取消引用double*编译器is free to assume时，内存位置实际上包含一个double，这意味着它必须与alignof(double)对齐。

许多x86指令可以安全地用于未对齐数据，但不是全部。具体来说，有SIMD指令需要正确对齐，编译器可以自由使用。

这不仅仅是理论上的; LZ4过去常常使用与你发布的东西非常相似的东西（它是C，而不是C ++，所以它是一个C风格的演员而不是reinterpret_cast，但这并不重要），并且一切都按预期工作。然后使用vmovdqa释放GCC 5，it auto-vectorized the code in question在-O3，这需要正确对齐。最终结果是，当GCC≥5时，在GCC≤4.9中正常工作的代码在运行时开始崩溃。

换句话说，即使您的程序今天正常运行，如果您依赖于未对齐访问（或其他未定义的行为），它明天也很容易停止工作。不要这样做。

如果你需要尽可能快的话，你会如何在ARM上编写这样的函数？

答案不是特定于ARM的。在LZ4事件发生后，Yann Collet（LZ4的作者）做a lot of research回答了这个问题。没有一个选项能够在每个架构上为每个编译器生成最佳代码。

使用memcpy()是最安全的选择。如果在编译时已知大小，编译器通常会优化memcpy()调用...对于更大的缓冲区，您可以通过在循环中调用memcpy()来利用它;你通常会得到一个快速指令循环，而不需要调用memcpy()的额外开销。

如果您感觉更冒险，可以使用压缩联盟来“强制转换”而不是reinterpret_cast。这是特定于编译器的，但是在支持时它应该是安全的，可能比memcpy()更快。

FWIW，我有some code试图根据各种因素（编译器，编译器版本，架构等）找到最佳方法。对于我没有测试的平台，它有点保守，但它应该在人们实际使用的绝大多数平台上取得良好的效果。

快速memcpy用于小的未对齐数据

1 个答案: