淺談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)很高，預分配往往是多此一舉，收效甚微。事實到底如何呢，性能問題光靠腦補是不能定位的，所以我們用實驗結果說話。
二、使用模板函數(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]。
關于自定義參數(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ù)，禁止移動賦值，同時被刻意設計成了非平凡復制，這樣的類型可以說是繞過了標準庫容器設計的大部分優(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上的結果，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上的測試結果：
和我們預期的一樣，多出來的一次內(nèi)存分配使reserve帶來的性能優(yōu)勢蕩然無存。
有意思的是Windows上的結果：
奇怪的事情發(fā)生了，雖說多出的一次分配縮小了性能差距，但reserve任然帶來了明顯的優(yōu)勢。
這里我就不賣關子了，我們直接看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是關鍵，定義在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。關鍵代碼在這里，push_back在內(nèi)存不夠的時候會調(diào)用_Emplace_reallocate，里面會調(diào)用_Calculate_growth計算重新分配的內(nèi)存大小：
_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; // 關鍵代碼
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)存里構建要插入的元素，再把其他元素移動到新內(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的運行結果:
v1: 138255
v2: 100000
v1: 138255
v2: 150000
GCC11.1.0的結果:
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)上面那樣測試結果的原因之一，兩個標準庫的allocator實現(xiàn)上的區(qū)別也可能是其中一個原因。不過msvc的分配器實現(xiàn)并不公開，所以最終是什么導致了上述的結果并不能輕易斷言。
六、總結
我們學習了如何使用模板和參數(shù)生成器創(chuàng)建大量測試用例，以提高編寫測試的效率。
我們還順便了解了vector.reserve對性能的影響，總結規(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)容，更多關于c++性能測試工具google benchmark的資料請關注腳本之家其它相關文章！
相關文章
這篇文章主要為大家詳細介紹了Qt實現(xiàn)計算器功能，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-08-08
本文主要介紹了Qt視頻播放器的實現(xiàn)示例,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2023-08-08
這篇文章主要介紹了C語言中大小端問題實例，總的來說這并不是一道難題，那為什么要拿出這道題介紹？拿出這道題真正想要傳達的是解題的思路，以及不斷優(yōu)化探尋最優(yōu)解的過程。希望通過這道題能給你帶來一種解題優(yōu)化的思路2023-02-02
C++如何解決rand()函數(shù)生成的隨機數(shù)每次都一樣的問題
這篇文章主要介紹了C++如何解決rand()函數(shù)生成的隨機數(shù)每次都一樣的問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-08-08
今天小編就為大家分享一篇關于C++標準模板庫string類的介紹與使用講解，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2018-12-12
詳解C++中typedef 和 #define 的區(qū)別
這篇文章主要介紹了C++中typedef 與 #define 的區(qū)別,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-09-09
這篇文章主要給大家介紹了關于Qt正則表達式使用的相關資料,Qt中的正則表達式模式匹配功能由QRegExp類實現(xiàn),它完全支持Unicode,并可以應用于字符串驗證、搜索、查找替換和分割等場景,需要的朋友可以參考下2024-02-02
這篇文章主要給大家介紹了關于C語言中.與->區(qū)別的相關資料,這雖然是個小問題,但有時候很容易讓人迷惑,因為有的時候用混淆了,程序編譯不通過,需要的朋友可以參考下2023-06-06
大家好，本篇文章主要講的是C++中兩種字符串定義方式和區(qū)別介紹，感興趣的同學趕快來看一看吧，對你有幫助的話記得收藏一下2022-01-01
這篇文章主要為大家詳細介紹了C++中指針的相關知識，文中的示例代碼講解詳細，對我們的學習或工作有一定的價值，感興趣的小伙伴可以了解一下2023-03-03