c++ - 试图减少几乎但不完全是整数类的速度开销

Question

我已经实现了一个 C++ 类，它的行为与标准 int 非常相似。类型。不同之处在于它有一个额外的概念“epsilon”，它表示一些远小于 1 但大于 0 的微小值。一种认为它的方式是一个非常宽的定点数，具有 32 个 MSB(整数部分)，32 个 LSB(epsilon 部分)和中间的大量零点。 (注意:此类与普通定点数的一个很大区别是有两个符号，而不是一个:“value”和“epsilon”可以相互独立地为负数，而对于定点数，有一个符号表示整个数字。)

下面的类有效，但在整个程序中引入了大约 2 倍的速度损失。 (该程序包含与该类无关的代码，因此该类的实际速度损失可能远大于 2 倍。)我无法粘贴使用该类的代码，但我可以说以下内容:

+, -, +=, <, >和 >=是唯一被大量使用的运算符。使用setEpsilon()和 getInt()极为罕见。 *也很少见，甚至根本不需要考虑 epsilon 值。

这是类:

#include <limits>

struct int32Uepsilon {
typedef int32Uepsilon Self;

int32Uepsilon () { _value = 0;
                   _eps   = 0; }
int32Uepsilon (const int &i) { _value = i;
                               _eps   = 0; }
void setEpsilon() { _eps = 1; }
Self operator+(const Self &rhs) const { Self result = *this;
                                      result._value += rhs._value;
                                      result._eps   += rhs._eps;
                                      return result; }
Self operator-(const Self &rhs) const { Self result = *this;
                                      result._value -= rhs._value;
                                      result._eps   -= rhs._eps;
                                      return result; }
Self operator-(               ) const { Self result = *this;
                                      result._value = -result._value;
                                      result._eps   = -result._eps;
                                      return result; }
Self operator*(const Self &rhs) const { return this->getInt() * rhs.getInt(); } // XXX: discards epsilon

bool operator<(const Self &rhs) const { return (_value < rhs._value) ||
                                             (_value == rhs._value && _eps < rhs._eps); }
bool operator>(const Self &rhs) const { return (_value > rhs._value) ||
                                             (_value == rhs._value && _eps > rhs._eps); }
bool operator>=(const Self &rhs) const { return (_value >= rhs._value) ||
                                             (_value == rhs._value && _eps >= rhs._eps); }

Self &operator+=(const Self &rhs) { this->_value += rhs._value;
                                  this->_eps   += rhs._eps;
                                  return *this; }
Self &operator-=(const Self &rhs) { this->_value -= rhs._value;
                                  this->_eps   -= rhs._eps;
                                  return *this; }
int getInt() const { return(_value); }

private:
  int _value;
  int _eps;
};

namespace std {
template<>
struct numeric_limits<int32Uepsilon> {
  static const bool is_signed  = true;
  static int max() { return 2147483647; }
}
};

上面的代码可以工作，但是速度很慢。有没有人对如何提高性能有任何想法？我可以提供一些可能有用的提示/细节:

• 32 位绝对不足以同时保存 _value 和 _eps。在实践中，高达 24 ~ 28 位的使用 _value 并使用最多 20 位的 _eps。
• 我无法衡量使用 int32_t 之间的显着性能差异和 int64_t ,所以内存开销本身可能不是这里的问题。
• 在 _eps 上进行饱和加法/减法会很酷，但并不是必须的。
• 请注意_value 和_eps 的符号不一定相同!这打破了我的第一次尝试加快这门课的速度。
• 内联汇编没有问题，只要它在运行 Linux 的 Core i7 系统上与 GCC 一起工作即可!

Answer 1

要尝试的一件事是定义例如的规范实践。 operator+ 在 operator+= 方面:

Self operator+(const Self &rhs) const { return Self(*this) += rhs; }

这有助于 return-value optimization ，这消除了按值返回所需的复制构造函数。

此外，它还减少了代码维护!