淺談c++性能測試工具google benchmark
一、測試對象
這次測試的對象是標準庫的vector，我們將會在vs2019 16.10和Linux + GCC 11.1上進行測試。為了代碼寫著方便，我還會啟用c++17支持。
這次的疑問來自于《A Tour of C++》這本書，最近在重新翻閱本書的時候發(fā)現(xiàn)書里第九章給出了一個很有意思的建議：盡量少用reserve方法。
我們都知道reserve會提前分配足夠大的內(nèi)存來容納元素，這樣在push_back時可以減少內(nèi)存分配和元素移動的次數(shù)，從而提高性能。所以習慣上如果我們知道vector中存儲元素的大致數(shù)量，就會使用reserve提前進行內(nèi)存分配，這是典型的“空間換時間”。
而書中給出的理由僅僅是說vector的內(nèi)存分配器性能已經(jīng)很高，預分配往往是多此一舉，收效甚微。事實到底如何呢，性能問題光靠腦補是不能定位的，所以我們用實驗結(jié)果說話。
二、使用模板函數(shù)生成測試
測試用例的設(shè)計很簡單，我們定義普通vector和reserve過的vector，然后分別對其添加一定數(shù)量的元素（逐步從少到多）測試性能。
同時vector本身是泛型容器，所以為了測試的全面性我們需要測試兩至三種類型參數(shù)。
如果針對每一種情況寫測試函數(shù)，顯然違反了DRY原則，因為除了vector的類型參數(shù)不同，其他代碼幾乎是完全一樣的。
對于上面的需求，就需要模板測試函數(shù)登場了：
template <typename T, std::size_t length, bool is_reserve = true>
void bench_vector_reserve(benchmark::State& state)
{
for (auto _ : state) {
std::vector<T> container;
if constexpr (is_reserve) {
container.reserve(length);
}
for (std::size_t i = 0; i < length; ++i) {
container.push_back(T{});
}
}
}
非常的簡單，我們通過length控制插入的元素個數(shù)；is_reserve則負責控制是否預分配內(nèi)存，通過if constexpr可以生成reserve和不進行任何操作的兩種代碼。
然后我們像往常一樣定義一個測試用例：
BENCHMARK(bench_vector_reserve<std::string,100>);
可是等我們編譯的時候卻報錯了！
$ g++ test.cpp -lpthread -lbenchmark -lbenchmark_main
test.cpp:19:48: 錯誤：宏“BENCHMARK”傳遞了 2 個參數(shù)，但只需要 1 個
19 | BENCHMARK(bench_vector_reserve<std::string,100>);
| ^
In file included from a.cpp:1:
/usr/local/include/benchmark/benchmark.h:1146: 附注：macro "BENCHMARK" defined here
1146 | #define BENCHMARK(n) \
|
test.cpp:19:1: 錯誤：‘BENCHMARK'不是一個類型名
19 | BENCHMARK(bench_vector_reserve<std::string,100>);
原因是這樣的，在編譯器處理宏的時候?qū)嶋H上不會考慮c++語法，所以分割模板參數(shù)的逗號被識別成了分割宏參數(shù)的逗號，因此在宏處理器的眼里我們像是傳了兩個參數(shù)。這也說明了BENCHMARK是處理不了模板的。
不過別擔心，Google早就想到這種情況了，所以提供了BENCHMARK_TEMPLATE宏，我們只需要把模板名字和需要的類型參數(shù)依次傳給宏即可：
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 100); BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 1000); BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 10000); BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 100000); BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 100, false); BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 1000, false); BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 10000, false); BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, 100000, false);
現(xiàn)在就可以正常編譯運行了：
可以看到reserve過的容器性能幾乎比默認的快了一倍。
不過在揭曉為什么書上不推薦reserve的謎底之前，我們的代碼還有可以簡化的地方。
三、定制測試參數(shù)
首當其沖的問題其實還是違反了DRY原則——除了數(shù)字，其他內(nèi)容都是重復的。
看到這種代碼直覺就告訴我該做些改進了。
Ranges接受start和end兩個int64_t類型的參數(shù)，默認從start起每次累乘8，一直達到end。
通過RangeMultiplier我們可以改變乘數(shù)，比如從8改成10。
在這里我們的length參數(shù)其實是不必要的，所以代碼可以這樣改：
template <typename T, bool is_reserve = true>
void bench_vector_reserve(benchmark::State& state)
{
for (auto _ : state) {
std::vector<T> container;
if constexpr (is_reserve) {
// 通過range方法獲取傳入的參數(shù)
container.reserve(state.range(0));
}
for (std::size_t i = 0; i < state.range(0); ++i) {
container.push_back(T{});
}
}
}
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string)->RangeMultiplier(10)->Range(10, 10000 * 10);
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, false)->RangeMultiplier(10)->Range(10, 10000 * 10);
現(xiàn)在我們測試的元素數(shù)量是[10, 100, 1000, 10^4, 10^5]。
除此之外還有另一種叫“密集參數(shù)”的Ranges。google benchmark提供了DenseRange方法。
這個方法的原型如下：
DenseRange(int64_t start, int64_t end, int64_t step);
Ranges是累乘，而DenseRange是累加，因為累乘會導致幾何級數(shù)的增長，在數(shù)軸上的分布越來越稀疏，累加則看上去像是均勻分布的，因此累加的參數(shù)生成器被叫做密集參數(shù)生成器。
如果我們把測試用例這么改：
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string)->DenseRange(1000, 100 * 100, 1000);
現(xiàn)在我們的length就是這樣一個序列：[1000，2000，3000， ...，9000，10000]。
關(guān)于自定義參數(shù)最后一個知識點是ArgsProduct。看名字就知道這是一個參數(shù)工廠。
ArgsProduct(const std::vector< std::vector<int64_t> >& arglists);
std::vector<int64_t>實際上就是一組參數(shù)，arglists就是多組參數(shù)的合集，他們之間會被求笛卡爾積，舉個例子：
BENCHMARK(BM_test)->ArgsProduct({ {"a", "b", "c", "d"}, {1, 2, 3, 4} });
// 等價于下面的
BENCHMARK(BM_test)->Args({"a", 1})
->Args({"a", 2})
->Args({"a", 3})
->Args({"a", 4})
->Args({"b", 1})
->Args({"b", 2})
->Args({"b", 3})
...
->Args({"d", 3})
->Args({"d", 4})
我們可以看到參數(shù)工廠其實得自己手寫所有參數(shù)，那如果我想配合工廠使用Ranges呢？
沒問題，benchmark的開發(fā)者們早就想到了，所以提供了下面這些幫助函數(shù)：
benchmark::CreateRange(8, 128, /*multi=*/2) // 生成：[8, 16, 32, 64, 128] benchmark::CreateDenseRange(1, 6, /*step=*/1) // 生成：[1, 2, 3, 4, 5, 6]
如果換成我們的例子，就可以這樣寫：
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, false)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
借助僅僅兩行代碼我們就能生成數(shù)量可觀的測試用例：
當然，這只是一個類型參數(shù)，實際上我們還有另外兩個類型需要測試。另外這是1.5.5新增的功能，如果你想嘗鮮得先升級google benchmark。
四、進一步簡化
通常做到上面那一步就足夠了，然而在這里我們還有優(yōu)化空間，因為如果我們把其他兩個測試用的類型加上，代碼是這樣的，MyClass的定義后面會給出：
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
BENCHMARK_TEMPLATE(bench_vector_reserve, std::string, false)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
BENCHMARK_TEMPLATE(bench_vector_reserve, std::size_t)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
BENCHMARK_TEMPLATE(bench_vector_reserve, std::size_t, false)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
BENCHMARK_TEMPLATE(bench_vector_reserve, MyClass)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
BENCHMARK_TEMPLATE(bench_vector_reserve, MyClass, false)->ArgsProduct({
benchmark::CreateRange(10, 10000*10, 10)
});
你看見了什么？沒錯，重復重復重復！我們又違背了DRY原則。
重復說不上什么十惡不赦，但能避免還是要避免的，所以我準備用宏來簡化這些代碼：
#define generate_test(type) \
BENCHMARK_TEMPLATE(bench_vector_reserve, type)->ArgsProduct({benchmark::CreateRange(10, 100000, 10)}); \
BENCHMARK_TEMPLATE(bench_vector_reserve, type, false)->ArgsProduct({benchmark::CreateRange(10, 100000, 10)});
generate_test(std::string);
generate_test(std::size_t);
generate_test(MyClass);
這下舒服多了。
接著來看我們的MyClass，我們的MyClass包含幾個虛函數(shù)，禁止移動賦值，同時被刻意設(shè)計成了非平凡復制，這樣的類型可以說是繞過了標準庫容器設(shè)計的大部分優(yōu)化措施，算是個妥妥的反面教材，希望你的項目里盡量不要出現(xiàn)這種東西：
class MyClass {
public:
long i = 2L;
MyClass() { i = 2L; }
virtual ~MyClass() {}
virtual long get() { return i; }
MyClass& operator=(MyClass&&) = delete;
MyClass(const MyClass& obj) {
i = obj.i;
}
MyClass& operator=(const MyClass& obj) {
i = obj.i;
}
};
這個類其實就是針對內(nèi)存分配器實現(xiàn)的，vector在重新進行內(nèi)存分配后很可能靠移動語義或者memmove來移動數(shù)據(jù)，這兩者將導致重新分配內(nèi)存導致的性能損失變小，不利于我們觀察vector的行為，所以我定制了這個類。
這是Windows上的結(jié)果，Linux上也差不多，到目前為止我們看到reserve過的vector有著驚人的性能，那書里說的到底是怎么回事呢？
五、揭曉答案
實際上上面測試的都是我們明確知道vector一定會被插入N個元素不多不少的情況。
然而這種情況其實在開發(fā)中是不多見的，更多的時候我們只能得到vector里元素數(shù)量的平均數(shù)、眾數(shù)，甚至是一個沒什么可靠依據(jù)的經(jīng)驗值。
所以試想一下這種情況，reserve給的參數(shù)是1000，而我的vector總是會插入1001~1005個參數(shù)，顯然1000是不夠的，除了reserve外還會進行一次內(nèi)存分配，而且這次分配后很可能還需要把原先的元素都轉(zhuǎn)移過去（realloc不是總能找到合適的位置擴展已有內(nèi)存，而且像MyClass那樣的類在c++17中是不能bitwise復制的），那么這樣的開銷究竟如何呢？我們還是拿測試說話。
篇幅有限，所以我只能簡單模擬一下上述情況：
template <typename T, bool is_reserve = true>
void bench_vector_reserve(benchmark::State& state)
{
for (auto _ : state) {
std::vector<T> container;
if constexpr (is_reserve) {
container.reserve(state.range(0));
}
// 每次多插入兩個元素，這樣多半會導致一次內(nèi)存分配（當然不保證一定會）
for (std::size_t i = 0; i < state.range(0)+2; ++i) {
container.push_back(T{});
}
}
}
編譯均使用Release模式和默認的優(yōu)化級別，這是Linux上的測試結(jié)果：
和我們預期的一樣，多出來的一次內(nèi)存分配使reserve帶來的性能優(yōu)勢蕩然無存。
有意思的是Windows上的結(jié)果：
奇怪的事情發(fā)生了，雖說多出的一次分配縮小了性能差距，但reserve任然帶來了明顯的優(yōu)勢。
這里我就不賣關(guān)子了，我們直接看vector的源碼。
首先是GCC11.1的，代碼在/usr/include/c++/11.1.0/bits目錄下，分散在vector.tcc和stl_vector.h中，其中push_back在容器內(nèi)存不夠的時候會用_M_realloc_insert重新分配足夠的內(nèi)存，這個函數(shù)在vector.tcc的432行有定義，使用_M_check_len計算重新分配的內(nèi)存大小。
_M_check_len是關(guān)鍵，定義在stl_vector.h的1756行：
// Called by _M_fill_insert, _M_insert_aux etc.
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
__n在push_back的時候是1，所以不難看出GCC的vector的擴容策略是每次擴容一倍。
vs2019的stl實現(xiàn)開源在了github。關(guān)鍵代碼在這里，push_back在內(nèi)存不夠的時候會調(diào)用_Emplace_reallocate，里面會調(diào)用_Calculate_growth計算重新分配的內(nèi)存大?。?/p>
_CONSTEXPR20_CONTAINER size_type _Calculate_growth(const size_type _Newsize) const {
// given _Oldcapacity and _Newsize, calculate geometric growth
const size_type _Oldcapacity = capacity();
const auto _Max = max_size();
if (_Oldcapacity > _Max - _Oldcapacity / 2) {
return _Max; // geometric growth would overflow
}
const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2; // 關(guān)鍵代碼
if (_Geometric < _Newsize) {
return _Newsize; // geometric growth would be insufficient
}
return _Geometric; // geometric growth is sufficient
}
_Newsize相當于前面GCC的__n，在push_back的時候是1，所以不難看出vs2019的vector增長策略是每次擴容0.5倍。
除此之外兩者的剩余部分大同小異，都是先分配新內(nèi)存，然后在新內(nèi)存里構(gòu)建要插入的元素，再把其他元素移動到新內(nèi)存里，就連移動元素的方式也差不多，都是先嘗試memmove，接著試試移動語義，最后讓復制操作兜底。
那么兩者肉眼可見的區(qū)別就只有擴容策略這一條了。所以這會帶來什么影響呢？看個例子：
#include <iostream>
#include <vector>
void test1(std::size_t len)
{
std::vector<int> v1, v2;
v2.reserve(len);
for (std::size_t i = 0; i < len; ++i) {
v1.push_back(1);
v2.push_back(1);
}
std::cout << "v1: " << v1.capacity() << '\n';
std::cout << "v2: " << v2.capacity() << '\n';
}
void test2(std::size_t len)
{
std::vector<int> v1, v2;
v2.reserve(len);
for (std::size_t i = 0; i < len + 1; ++i) {
v1.push_back(1);
v2.push_back(1);
}
std::cout << "v1: " << v1.capacity() << '\n';
std::cout << "v2: " << v2.capacity() << '\n';
}
int main()
{
test1(100000);
test2(100000);
}
/*
vs2019的運行結(jié)果:
v1: 138255
v2: 100000
v1: 138255
v2: 150000
GCC11.1.0的結(jié)果:
v1: 131072
v2: 100000
v1: 131072
v2: 200000
*/
如果是一個有10萬個元素的vector想要擴容，GCC就會比vs多分配50000個元素需要的內(nèi)存，分配如此多的內(nèi)存需要花費更多的時間，即使reserve帶來了性能優(yōu)勢在這一步也都揮霍的差不多了。
激進的擴容策略讓GCC出現(xiàn)了明顯的性能波動，不過這只是出現(xiàn)上面那樣測試結(jié)果的原因之一，兩個標準庫的allocator實現(xiàn)上的區(qū)別也可能是其中一個原因。不過msvc的分配器實現(xiàn)并不公開，所以最終是什么導致了上述的結(jié)果并不能輕易斷言。
六、總結(jié)
我們學習了如何使用模板和參數(shù)生成器創(chuàng)建大量測試用例，以提高編寫測試的效率。
我們還順便了解了vector.reserve對性能的影響，總結(jié)規(guī)律有幾條：
1.如果明確知道vector要存放元素的具體數(shù)量，推薦reserve，性能提升是有目共睹的；
2.否則你不應該使用reserve，一來有提前優(yōu)化之嫌，二是在使用libstdc++的程序上會產(chǎn)生較大的性能波動；
3.接上一條，reserve使用不當還會造成內(nèi)存的浪費。
看來《A Tour of C++》的作者只說對了一半，這也證明了性能問題不能靠臆斷，一定要靠測試來定位、解決。
以上就是淺談c++性能測試工具google benchmark的詳細內(nèi)容，更多關(guān)于c++性能測試工具google benchmark的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
結(jié)構(gòu)體是一些值的集合，這些值稱為成員變量，結(jié)構(gòu)體的每個成員可以是不同類型的變量。本文將通過示例為大家詳細講講C語言中結(jié)構(gòu)體的使用，需要的可以參考一下2022-07-07
回調(diào)函數(shù)就是函數(shù)指針變量作為另外一個函數(shù)的參數(shù)而使用的一種應用情形。本文就詳細的介紹一下C語言回調(diào)函數(shù)的簡單運用，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-09-09
昨天在使用Visual Studio 2022編寫C語言程序時遇到了scanf問題,對于vs的編譯器來說scanf是不安全的,編譯器通過不了scanf,本文就來介紹一下解決方法,感興趣的可以了解一下2023-12-12
C++實現(xiàn)八個常用的排序算法 插入排序、冒泡排序、選擇排序、希爾排序等
這篇文章主要介紹了C++如何實現(xiàn)八個常用的排序算法：插入排序、冒泡排序、選擇排序、希爾排序 、快速排序、歸并排序、堆排序和LST基數(shù)排序,需要的朋友可以參考下2015-07-07
詳解C/C++中const關(guān)鍵字的用法及其與宏常量的比較
簡單的說const關(guān)鍵字修飾的變量具有常屬性，也就是說它所修飾的變量不能被修改，下文給大家介紹C/C++中const關(guān)鍵字的用法及其與宏常量的比較,需要的朋友可以參考下2017-07-07
本篇文章是對字符串移位包含的問題的解決方法進行了詳細的分析介紹，需要的朋友參考下2013-05-05
C++ explicit構(gòu)造函數(shù)實例解析
這篇文章主要介紹了C++ explicit構(gòu)造函數(shù),需要的朋友可以參考下2014-07-07
這篇文章主要介紹了C語言實現(xiàn)輸入ascii碼，輸出對應的字符方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-01-01
C 語言是一種通用的、面向過程式的計算機程序設(shè)計語言。1972 年，為了移植與開發(fā) UNIX 操作系統(tǒng)，丹尼斯·里奇在貝爾電話實驗室設(shè)計開發(fā)了 C 語言。C 語言是一種廣泛使用的計算機語言，它與 Java 編程語言一樣普及，二者在現(xiàn)代軟件程序員之間都得到廣泛使用2022-04-04
這篇文章主要介紹了C++?左值引用與?const?關(guān)鍵字,左值引用是已定義的變量的別名，其主要用途是用作函數(shù)的形參，將?const?關(guān)鍵字用于左值引用時，其在初始化時可接受的賦值形式變得更加廣泛了，這里來總結(jié)一下，需要的朋友可以參考下2022-09-09