Question

社区。我有这段代码可以找到欧几里得3D空间中最接近的一对点。这个问题既与算法无关，也与它的实现无关。问题在于，使用GCC而不是Clang编译时，它的运行速度明显变慢。最令人困惑的是，它在随机样本上的执行时间相当，而在某些特定样本上的执行时间却慢了100倍。我怀疑GCC中可能存在错误，因为我无法想到其他任何选择。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <fstream>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>

static std::mt19937 mmtw(std::chrono::steady_clock::now().time_since_epoch().count());
int64_t rng(int64_t x, int64_t y) {
  static std::uniform_int_distribution<int64_t> d;
  return d(mmtw) % (y - x + 1) + x;
}

constexpr static int MAXN = 1e5 + 10;

void solve(std::istream &in, std::ostream &out);

void generate(std::ostream &out) {
  constexpr int N = 1e5;
  out << N << '\n';
  int MIN = -1e6;
  int MAX = 1e6;
  for (int i = 0; i < N; ++i) {
    out << 0 << ' ';
    out << i << ' ';
    out << (i + 1) * int(1e4) << '\n';
  }
}

int main() {

  freopen("input.txt", "r", stdin);

  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.tie(nullptr);
  std::cerr.tie(nullptr);

  std::ofstream fout("input.txt");
  generate(fout);
  fout.close();

  solve(std::cin, std::cout);

  return 0;
}

struct point_t {
  int32_t x, y, z;
  int id;
  point_t() = default;
  point_t(int32_t x, int32_t y, int32_t z) : x(x), y(y), z(z) {}
  point_t operator +(const point_t &rhs) const {
    return point_t(x + rhs.x, y + rhs.y, z + rhs.z);
  }
  point_t operator -(const point_t &rhs) const {
    return point_t(x - rhs.x, y - rhs.y, z - rhs.z);
  }
  int64_t abs2() const {
    return 1LL * x * x + 1LL * y * y + 1LL * z * z;
  }
};

std::istream &operator >>(std::istream &in, point_t &pt) {
  return in >> pt.x >> pt.y >> pt.z;
}

inline bool cmp_x(const point_t &lhs, const point_t &rhs) {
  return lhs.x < rhs.x;
}

inline bool cmp_y(const point_t &lhs, const point_t &rhs) {
  return lhs.y < rhs.y;
}

inline bool cmp_z(const point_t &lhs, const point_t &rhs) {
  return lhs.z < rhs.z;
}

struct pair_t {
  int64_t distance_sq;
  point_t a {}, b {};
  pair_t() : distance_sq(std::numeric_limits<int64_t>::max()) {};
  pair_t(const point_t &a, const point_t &b) : distance_sq((a - b).abs2()), a(a), b(b) {}
  bool operator<(const pair_t &rhs) const {
    return distance_sq < rhs.distance_sq;
  }
};

template <typename T> inline T sqr(T arg) { return arg * arg; }

point_t pts[MAXN];

static pair_t ans = pair_t();

void recur_2D(point_t pts[], int size, int64_t threshold_sq) {
  if (size <= 3) {
    for (int i = 0; i < size; ++i) {
      for (int j = i + 1; j < size; ++j) {
        ans = std::min(ans, pair_t(pts[i], pts[j]));
      }
    }
    std::sort(pts, pts + size, cmp_y);
    return;
  }
  int mid = size / 2;
  int midx = pts[mid].x;
  recur_2D(pts, mid, threshold_sq);
  recur_2D(pts + mid, size - mid, threshold_sq);

  static point_t buffer[MAXN];
  std::merge(pts, pts + mid, pts + mid, pts + size, buffer, cmp_y);
  std::copy(buffer, buffer + size, pts);

  int buff_sz = 0;
  for (int i = 0; i < size; ++i) {
    if (sqr(pts[i].x - midx) >= threshold_sq) {
      continue;
    }
    int64_t x_sqr = sqr(pts[i].x - midx);
    for (int j = buff_sz - 1; j >= 0; --j) {
      if (sqr(pts[i].y - buffer[j].y) + x_sqr >= threshold_sq) {
        break;
      }
      ans = std::min(ans, pair_t(pts[i], buffer[j]));
    }
    buffer[buff_sz++] = pts[i];
  }
}

void recur_3D(point_t pts[], int size) {
  if (size <= 3) {
    for (int i = 0; i < size; ++i) {
      for (int j = i + 1; j < size; ++j) {
        ans = std::min(ans, pair_t(pts[i], pts[j]));
      }
    }
    std::sort(pts, pts + size, cmp_x);
    return;
  }

  int mid = size / 2;
  int midz = pts[mid].z;

  recur_3D(pts, mid);
  recur_3D(pts + mid, size - mid);

  static point_t buffer[MAXN];
  std::merge(pts, pts + mid, pts + mid, pts + size, buffer, cmp_x);
  std::copy(buffer, buffer + size, pts);

  int buff_sz = 0;
  for (int i = 0; i < size; ++i) {
    if (sqr(pts[i].z - midz) >= ans.distance_sq) {
      continue;
    }
    buffer[buff_sz++] = pts[i];
  }
  recur_2D(buffer, buff_sz, ans.distance_sq);
}

void solve(std::istream &in, std::ostream &out) {

  clock_t start = clock();

  int num_of_points;
  in >> num_of_points;

  for (int i = 0; i < num_of_points; ++i) {
    in >> pts[i];
    pts[i].id = i + 1;
  }

  std::sort(pts, pts + num_of_points, cmp_z);
  recur_3D(pts, num_of_points);
  out << ans.distance_sq << '\n';
  out << 1.0 * (clock() - start) / CLOCKS_PER_SEC << " s.\n";
}

此代码的链接：https://code.re/2yfPzjkD

它生成使代码非常慢的示例，然后测量算法执行时间。

我用

进行编译

g++ -DLOCAL -std=c++1z -O3 -Wno-everything main.cpp

并

clang++ -DLOCAL -std=c++1z -O3 -Wno-everything main.cpp

然后运行 ./main在同一目录中有input.txt。

Clang编译的二进制文件在0.053798 s.中运行，而GCC在12.4276 s.中运行。这些数字来自程序的输出，您可以看到该函数solve。

我还验证了不同编译器版本在https://wandbox.org/上的区别。 https://wandbox.org/permlink/YFEEWSKyos2dQf32-lang https://wandbox.org/permlink/XctarNHvd3I1B0x8-gcc

请注意，我压缩了输入，因此不得不稍微更改solve中的读数。

在我的本地计算机上，我有这些编译器。

clang++ --version clang version 7.0.0 (tags/RELEASE_700/final)

g++ --version g++ (GCC) 8.2.1 20180831

感觉就像我在没有编译器优化的情况下运行GCC代码。可能是什么原因？

UPD。

另外，有一个版本一开始只调用std::sort。 https://wandbox.org/permlink/i9Kd3GdewxSRwXsM

我还试图用-stdlib=libstdc++编译Clang，对数据进行混洗，并认为不是std::sort的不同实现。

Answer 1

这只是未定义的行为。由于在以下位置有符号整数溢出，您的代码具有未定义的行为：

template <typename T> inline T sqr(T arg) { return arg * arg; }

您可以将其替换为：

template <typename T>
inline T sqr(T arg)
{
    assert(double(arg)*arg <= std::numeric_limits<T>::max());
    assert(double(arg)*arg >= std::numeric_limits<T>::min());
    return arg * arg;
}

并在调试器中捕获错误。它失败，并且在行上从arg=-60000调用了recur_3D：

if (sqr(pts[i].z - midz) >= ans.distance_sq) {

pts[i] = {x = 0, y = 0, z = 10000, id = 1}和midz=70000会发生这种情况。

因为这是不守规矩的行为，所以所有赌注都关闭了。不同的编译采用了以下假设：“ 未定义的行为永远不会发生”。这就是clang和gcc表现不同的原因，它纯属“运气”。

请考虑使用UndefinedBehaviorSanitizer来捕获这些错误。在我的lang安装中没有安装，但是clang++ -fsanitize=signed-integer-overflow应该可以解决问题。

修复此功能后，clang和gcc的速度可比。

GCC和Clang代码性能的巨大差异

1 个答案: