性能文章>【全网首发】性能优化利器之constexpr>

【全网首发】性能优化利器之constexpr原创

366457

你好,我是雨乐!

最近在升级系统和进行一些性能优化,业余时间也看一些技术书籍和视频,看了下上次更新文章的时间,大致在一个月前了,确实有点久了,所以赶紧拾起来,不能让大伙忘了我不是😁。

今天,聊聊在升级过程中的一个比较重要的优化点-编译期优化。

概述

说明符constexpr是自C++11引入,我相信很多人跟我一样,在第一次接触这个的时候,会很容易和const混淆。

从概念上理解的话,constexpr即常量表达式,重点在表达式字段,用于指定变量或函数可以在常量表达式中使用,可以(或者说一定)在编译时求值的表达式,而const则为了约束变量的访问控制,表示运行时不可以直接被修改,其往往可以在编译期和运行时进行初始化。

前面提到了constexpr是在编译阶段进行求值,那么也就是说在程序运行之前,就已经计算完成,这种无疑大大提升了程序的运行效率。因此提升运行效率就是C++11引入constexpr说明符的目的,也就是说能在编译阶段做的事情就绝不放在运行期做。

变量

代码如下:

example1.cc

int main() {
    const int val = 1 + 2;
    return 0;
}

上述代码汇编结果如下:

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 3
        mov     eax, 0
        pop     rbp
        ret

从上述汇编结果可以看出,在编译阶段就将val赋值成3,也就是说在编译阶段完成了求值操作。

再看另外一个示例2:

example2.cc

int Add(const int a, const int b) {
    return a + b;
}

int main() {
    const int val = Add(1, 2);
    return 0;
}

同样的,其汇编如下:

Add(int, int):
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     edx, DWORD PTR [rbp-4]
        mov     eax, DWORD PTR [rbp-8]
        add     eax, edx
        pop     rbp
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     esi, 2
        mov     edi, 1
        call    Add(int, int)
        mov     DWORD PTR [rbp-4], eax
        mov     eax, 0
        leave
        ret

分析上述汇编,发现并没有在编译阶段进行求值,所以也就是说上述的求值过程将会延后至编译期进行。

好了,既然示例一(使用const)可以在编译期进行求值,而constexpr也可以在编译期求值,那么直接用constexpr替换示例一种的const是否可行?

example3.cc

int main() {
    constexpr int val = 1 + 2;
    return 0;
}

接着看下汇编代码:

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 3
        mov     eax, 0
        pop     rbp
        ret

呃😓,与示例一完全一样。。。

在上面示例2中,通过汇编代码发现其是在运行期求值,那么有没有办法在编译期求值呢?那就是使用constexpr表达式:

example4.cc

constexpr int Add(const int a, const int b) {
    return a + b;
}

int main() {
    const int val = Add(1, 2);
    return 0;
}

汇编如下:

main:
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], 3
        mov     eax, 0
        pop     rbp
        ret

有没有发现很眼熟,对,跟示例1和示例3的结果一样,该代码较示例2的唯一区别是多了个constexpr说明符,但将求值时期从运行期放到了编译期,可想而知,效率提升那是杠杠的。。。😁

函数

constexpr也可以修饰普通函数或者成员函数,其实这块在上一节已经有提过,示例如下:

constexpr int Add(const int a, const int b) {
    return a + b;
}

int main() {
    const int val = Add(1, 2);
    int val1 = 3;
    int val2 = Add(val, val1);
    return 0;
}

如下:

Add(int, int):
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     edx, DWORD PTR [rbp-4]
        mov     eax, DWORD PTR [rbp-8]
        add     eax, edx
        pop     rbp
        ret
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-4], 3
        mov     DWORD PTR [rbp-8], 3
        mov     eax, DWORD PTR [rbp-8]
        mov     esi, eax
        mov     edi, 3
        call    Add(int, int)
        mov     DWORD PTR [rbp-12], eax
        mov     eax, 0
        leave
        ret

从上述汇编代码可以看出,val的求值是在编译阶段,而val2的求值则是在运行阶段,这是因为其引入了一个非const变量val1。

通过本示例,可以看出,将函数声明为constexpr可以提示效率,让编译器来决定是在编译阶段还是运行阶段来进行求值,当然了,如果想了解在编译阶段求值的各种细节规则,请参考constexpr in cppreference

if语句

如果您目前使用C++11进行编码,那么需要仔细阅读本节,这样可以为将来的版本升级打好基础;如果您正在使用C++17进行编码,那么更得阅读本节,相信读完本节后,会有一个不一样的认识😁。

自C++17起,引入了if constexpr语句,在本节中,将借助SFINAE 和 std::enable_if来实现一个简单的Square功能,最后借助if constexpr对代码进行优化(如果对SFINAE 和 std::enable_if不是很了解的,建议自行阅读哈)。

如果有个需求,实现一个Add函数,其既支持算术类型又支持用户自定义类型:

template <typename T>
struct Number {
    Number(const T& _val) :
        value(_val) {}

    T value;
};

template<typename T>
T Square(const T& t) {
    return t + t;
}

int main() {
  int i = 5;
  float f = 5.0;
  bool b = true;
  Number<int> n(5);

  auto res = Square(i); // 调用int Add(int);
  auto res2 = Square(f); // 调用 float Add(float);
  auto res3 = Square(b);  // call bool Square(bool);
  auto res4 = Square(n); //编译失败,因为Number<>没有提供operator*操作
}

上述代码编译出错,因为Number<>没有提供operator*操作,所以这个时候第一个想法是修改Square函数,如下:

template<typename T>
T Square(const T& t) {
    if (std::is_arithmetic<T>::value) {
        return t * t;
    } else {
        return t.value * t.value;
    }
}

上述代码中,如果T是算数类型,则直接进行*操作,否则取其value进行*操作。

将上述代码进行编译,报错如下:

example5.cc: In instantiation of ‘T Square(const T&) [with T = int]’:
example5.cc:26:20:   required from here
example5.cc:16:18: error: request for member ‘value’ in ‘t’, which is of non-class type ‘const int’
   16 |         return t.value * t.value;
      |                ~~^~~~~
example5.cc:16:28: error: request for member ‘value’ in ‘t’, which is of non-class type ‘const int’
   16 |         return t.value * t.value;
      |                          ~~^~~~~
....

以Square(i)为例,这是因为在编译的时候,会尝试int.value操作,显然int.value不存在,这就导致了上述的错误输出,为了更为清楚的显示本错误,将Square()修改如下:

int Square(const int& t) {
    if (true) {
        return t * t;
    } else {
        return t.value * t.value;
    }
}

这样就能很清楚的知道为什么编译失败了,因为在代码中存在t.value * t.value操作,而对于一个int来说并没有value这个变量,所以编译失败。

为了解决这个问题,我们尝试引入std::enable_if操作,如下:

template<typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type Square(const T& t) {
    return t * t;
}

template<typename T>
typename std::enable_if<! std::is_arithmetic<T>::value, T>::type Square(const T& t) {
    return t.value * t.value;
}

现在有两个函数模板,如果是算术类型,则调用第一个,否则调用第二个,完整代码如下:

#include <type_traits>

template<typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type Square(const T& t) {
    return t * t;
}

template<typename T>
typename std::enable_if<! std::is_arithmetic<T>::value, T>::type Square(const T& t) {
    return t.value * t.value;
}

template <typename T>
struct Number {
    Number(const T& _val) :
        value(_val) {}

    T value;
};

int main() {
  int i = 5;
  float f = 5.0;
  bool b = true;
  Number<int> n(5);

  auto res = Square(i); // 调用int Add(int);
  auto res2 = Square(f); // 调用 float Add(float);
  auto res3 = Square(b);  // call bool Square(bool);
  auto res4 = Square(n); // 成功
  
  return 0;
}

上述代码编译成功。

在上述代码中,为了编译成功,我们引入了两个Square()模板函数借助std::enable_if来实现,代码上多少有点冗余,在这个时候,本节的主角if constexpr 出场,完整代码如下:

#include <type_traits>
template<typename T>
T Square(const T& t) {
    if constexpr (std::is_arithmetic<T>::value) {
        return t * t;
    } else {
        return t.value * t.value;
    }
}

template <typename T>
struct Number {
    Number(const T& _val) :
        value(_val) {}

    T value;
};

int main() {
  int i = 5;
  float f = 5.0;
  bool b = true;
  Number<int> n(5);

  auto res = Square(i); // 调用int Add(int);
  auto res2 = Square(f); // 调用 float Add(float);
  auto res3 = Square(b);  // call bool Square(bool);
  auto res4 = Square(n); // 成功
  
  return 0;
}

编译成功。

我们借助一个Square()函数模板以及更加符合编码习惯的if语句就能解决上面的问题,且比使用std::enable_if方式更为优雅和符合阅读习惯,进而提高代码的可阅读性。

今天的文章就到这,我们下期见!

推荐阅读   点击标题可跳转

1、我们通常说的POD到底是什么?

2、心心念念的优化完成了,虽然不是很完美

3、从一次字符串拼接失败说起

你好,我是雨乐,从业十二年有余,历经过传统行业网络研发、互联网推荐引擎研发,目前在广告行业从业8年。 目前任职某互联网公司高级技术专家一职,负责广告引擎的架构和研发。

 

点赞收藏
高性能架构探索

公众号《高性能架构探索》

请先登录,查看5条精彩评论吧
快去登录吧,你将获得
  • 浏览更多精彩评论
  • 和开发者讨论交流,共同进步
7
5