最近我尝试做一些性能基准测试，比较std::stack<int, std::vector<int>>和我自己的简单堆栈实现（使用预先分配的内存）。现在我遇到了一些奇怪的行为。
我想问的第一件事是这一行的堆栈基准代码：
// std::vector<int> magicVector(10);
当我取消注释此行时，性能上升约17％（基准时间从6.5秒下降到5.4秒）。但该行应该对该程序的其余部分没有影响，因为它不会修改任何其他成员。此外，无论是int的向量还是双向的向量都无关紧要
我要问的第二件事是我的堆栈实现与std::stack之间的巨大性能差异。我被告知std::stack应该和我的堆栈一样快，但结果表明我的“FastStack”速度是我的两倍。
结果（使用未注释的效果增加线）：
堆栈5.38979
堆栈5.34406
堆栈5.32404
堆栈5.30519
FastStack 2.59635
FastStack 2.59204
FastStack 2.59713
FastStack 2.64814
这些结果来自VS2010的发布版本，带有/ O2，/ Ot，/ Ob2和其他默认优化。我的CPU是Intel i5 3570k，默认时钟（一个线程为3.6 GHz）。
我将所有代码放在一个文件中，以便任何人都可以轻松测试它。
#define _SECURE_SCL 0
#include <iostream>
#include <vector>
#include <stack>
#include <Windows.h>
using namespace std;
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
// Purpose: High Resolution Timer
//---------------------------------------------------------------------------------
class HRTimer
{
public:
HRTimer();
double GetFrequency(void);
void Start(void) ;
double Stop(void);
double GetTime();
private:
LARGE_INTEGER start;
LARGE_INTEGER stop;
double frequency;
};
HRTimer::HRTimer()
{
frequency = this->GetFrequency();
}
double HRTimer::GetFrequency(void)
{
LARGE_INTEGER proc_freq;
if (!::QueryPerformanceFrequency(&proc_freq))
return -1;
return proc_freq.QuadPart;
}
void HRTimer::Start(void)
{
DWORD_PTR oldmask = ::SetThreadAffinityMask(::GetCurrentThread(), 0);
::QueryPerformanceCounter(&start);
::SetThreadAffinityMask(::GetCurrentThread(), oldmask);
}
double HRTimer::Stop(void)
{
DWORD_PTR oldmask = ::SetThreadAffinityMask(::GetCurrentThread(), 0);
::QueryPerformanceCounter(&stop);
::SetThreadAffinityMask(::GetCurrentThread(), oldmask);
return ((stop.QuadPart - start.QuadPart) / frequency);
}
double HRTimer::GetTime()
{
LARGE_INTEGER time;
::QueryPerformanceCounter(&time);
return time.QuadPart / frequency;
}
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
// Purpose: Should be faster than std::stack
//---------------------------------------------------------------------------------
template <class T>
class FastStack
{
public:
T* st;
int allocationSize;
int lastIndex;
public:
FastStack(int stackSize);
~FastStack();
inline void resize(int newSize);
inline void push(T x);
inline void pop();
inline T getAndRemove();
inline T getLast();
inline void clear();
};
template <class T>
FastStack<T>::FastStack( int stackSize )
{
st = NULL;
this->allocationSize = stackSize;
st = new T[stackSize];
lastIndex = -1;
}
template <class T>
FastStack<T>::~FastStack()
{
delete [] st;
}
template <class T>
void FastStack<T>::clear()
{
lastIndex = -1;
}
template <class T>
T FastStack<T>::getLast()
{
return st[lastIndex];
}
template <class T>
T FastStack<T>::getAndRemove()
{
return st[lastIndex--];
}
template <class T>
void FastStack<T>::pop()
{
--lastIndex;
}
template <class T>
void FastStack<T>::push( T x )
{
st[++lastIndex] = x;
}
template <class T>
void FastStack<T>::resize( int newSize )
{
if (st != NULL)
delete [] st;
st = new T[newSize];
}
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
// Purpose: Benchmark of std::stack and FastStack
//---------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
#if 1
for (int it = 0; it < 4; it++)
{
std::stack<int, std::vector<int>> bStack;
int x;
for (int i = 0; i < 100; i++) // after this two loops, bStack's capacity will be 141 so there will be no more reallocating
bStack.push(i);
for (int i = 0; i < 100; i++)
bStack.pop();
// std::vector<int> magicVector(10); // when you uncomment this line, performance will magically rise about 18%
HRTimer timer;
timer.Start();
for (int i = 0; i < 2000000000; i++)
{
bStack.push(i);
x = bStack.top();
if (i % 100 == 0 && i != 0)
for (int j = 0; j < 100; j++)
bStack.pop();
}
double totalTime = timer.Stop();
cout << "stack " << totalTime << endl;
}
#endif
//------------------------------------------------------------------------------------
#if 1
for (int it = 0; it < 4; it++)
{
FastStack<int> fstack(200);
int x;
HRTimer timer;
timer.Start();
for (int i = 0; i < 2000000000; i++)
{
fstack.push(i);
x = fstack.getLast();
if (i % 100 == 0 && i != 0)
for (int j = 0; j < 100; j++)
fstack.pop();
}
double totalTime = timer.Stop();
cout << "FastStack " << totalTime << endl;
}
#endif
cout << "Done";
cin.get();
return 0;
}
。
编辑：由于每个人都在谈论我的堆栈实现非常糟糕，我想把事情做好。我在几分钟内创建了该堆栈，并且我实现了我目前需要的一些功能。它从来没有打算成为std :: stack :)的替代品，或保存在所有情况下使用。唯一的目标是实现最大速度和正确的结果。我对这种误解感到抱歉......我只是想知道几个答案......
答案 0 :(得分：4)
你的方法实现都破了。忽略复制构造函数和其他缺少的操作，如果你推得太多，push会调用UB，而resize明显被破坏，因为它不会复制先前的数据和它不是例外安全和你的推送不是异常安全和你调用太多副本和你的{{1没有异常安全和你不会破坏弹出的元素和你没有正确构建新元素，只能分配它们< em>和你在创建时不必要地默认构造，并且可能还有更多我找不到。
基本上，你的班级在每一个可以想象的方面都非常安全地不安全，一塌就摧毁用户的数据，调用getAndRemove上的所有错误功能，并且会在在任何地方抛出异常的瞬间。
这是一大堆坏事，事实上它更快＆＃34;比T更完全无关紧要，因为你所证明的是，如果你不必满足要求，你可以尽可能快地去，我们都已经知道
从根本上说，正如sbi所说，你显然不了解std::stack的语义，也不了解异常安全等重要的C ++方面，以及代码无法正常工作的方式是使其执行的原因快点。我的朋友，你还有很长的路要走。
答案 1 :(得分：4)
与使用std::stack的{{1}}相反，你的筹码在空间不足时不会重新分配，只会炸毁地球。然而，分配是对性能的巨大消耗，因此跳过它肯定会获得性能。
然而，在你的位置，我会抓住一个年龄很大的std::vector实施floating on the web并将其填入static_vector代替std::stack。这样，你就可以跳过所有渴望性能的动态内存处理，但是你有一个有效的堆栈实现，下面有一个用于内存处理的容器，非常可能比你想出的要好得多。
答案 2 :(得分：2)
许多评论（甚至答案）都关注实施中的风险。然而问题是。
正如下面直接演示的那样，纠正感知代码的缺点不会改变任何有关性能的重要信息。
这是OP的代码被修改为（A）安全，（B）支持与std::stack相同的操作，（C）也为std::stack保留缓冲区空间，以便为那些错误地认为这些东西对表现很重要的人澄清一些事情：
#define _SECURE_SCL 0
#define _SCL_SECURE_NO_WARNINGS
#include <algorithm> // std::swap
#include <iostream>
#include <vector>
#include <stack>
#include <stddef.h> // ptrdiff_t
#include <type_traits> // std::is_pod
using namespace std;
#undef UNICODE
#define UNICODE
#include <Windows.h>
typedef ptrdiff_t Size;
typedef Size Index;
template< class Type, class Container >
void reserve( Size const newBufSize, std::stack< Type, Container >& st )
{
struct Access: std::stack< Type, Container >
{
static Container& container( std::stack< Type, Container >& st )
{
return st.*&Access::c;
}
};
Access::container( st ).reserve( newBufSize );
}
class HighResolutionTimer
{
public:
HighResolutionTimer();
double GetFrequency() const;
void Start() ;
double Stop();
double GetTime() const;
private:
LARGE_INTEGER start;
LARGE_INTEGER stop;
double frequency;
};
HighResolutionTimer::HighResolutionTimer()
{
frequency = GetFrequency();
}
double HighResolutionTimer::GetFrequency() const
{
LARGE_INTEGER proc_freq;
if (!::QueryPerformanceFrequency(&proc_freq))
return -1;
return static_cast< double >( proc_freq.QuadPart );
}
void HighResolutionTimer::Start()
{
DWORD_PTR oldmask = ::SetThreadAffinityMask(::GetCurrentThread(), 0);
::QueryPerformanceCounter(&start);
::SetThreadAffinityMask(::GetCurrentThread(), oldmask);
}
double HighResolutionTimer::Stop()
{
DWORD_PTR oldmask = ::SetThreadAffinityMask(::GetCurrentThread(), 0);
::QueryPerformanceCounter(&stop);
::SetThreadAffinityMask(::GetCurrentThread(), oldmask);
return ((stop.QuadPart - start.QuadPart) / frequency);
}
double HighResolutionTimer::GetTime() const
{
LARGE_INTEGER time;
::QueryPerformanceCounter(&time);
return time.QuadPart / frequency;
}
template< class Type, bool elemTypeIsPOD = !!std::is_pod< Type >::value >
class FastStack;
template< class Type >
class FastStack< Type, true >
{
private:
Type* st_;
Index lastIndex_;
Size capacity_;
public:
Size const size() const { return lastIndex_ + 1; }
Size const capacity() const { return capacity_; }
void reserve( Size const newCapacity )
{
if( newCapacity > capacity_ )
{
FastStack< Type >( *this, newCapacity ).swapWith( *this );
}
}
void push( Type const& x )
{
if( size() == capacity() )
{
reserve( 2*capacity() );
}
st_[++lastIndex_] = x;
}
void pop()
{
--lastIndex_;
}
Type top() const
{
return st_[lastIndex_];
}
void swapWith( FastStack& other ) throw()
{
using std::swap;
swap( st_, other.st_ );
swap( lastIndex_, other.lastIndex_ );
swap( capacity_, other.capacity_ );
}
void operator=( FastStack other )
{
other.swapWith( *this );
}
~FastStack()
{
delete[] st_;
}
FastStack( Size const aCapacity = 0 )
: st_( new Type[aCapacity] )
, capacity_( aCapacity )
{
lastIndex_ = -1;
}
FastStack( FastStack const& other, int const newBufSize = -1 )
{
capacity_ = (newBufSize < other.size()? other.size(): newBufSize);
st_ = new Type[capacity_];
lastIndex_ = other.lastIndex_;
copy( other.st_, other.st_ + other.size(), st_ ); // Can't throw for POD.
}
};
template< class Type >
void reserve( Size const newCapacity, FastStack< Type >& st )
{
st.reserve( newCapacity );
}
template< class StackType >
void test( char const* const description )
{
for( int it = 0; it < 4; ++it )
{
StackType st;
reserve( 200, st );
// after this two loops, st's capacity will be 141 so there will be no more reallocating
for( int i = 0; i < 100; ++i ) { st.push( i ); }
for( int i = 0; i < 100; ++i ) { st.pop(); }
// when you uncomment this line, std::stack performance will magically rise about 18%
// std::vector<int> magicVector(10);
HighResolutionTimer timer;
timer.Start();
for( Index i = 0; i < 1000000000; ++i )
{
st.push( i );
(void) st.top();
if( i % 100 == 0 && i != 0 )
{
for( int j = 0; j < 100; ++j ) { st.pop(); }
}
}
double const totalTime = timer.Stop();
wcout << description << ": " << totalTime << endl;
}
}
int main()
{
typedef stack< Index, vector< Index > > SStack;
typedef FastStack< Index > FStack;
test< SStack >( "std::stack" );
test< FStack >( "FastStack" );
cout << "Done";
}
这款速度为糖蜜的三星RC530笔记本电脑的结果：
[D:\dev\test\so\12704314] > a std::stack: 3.21319 std::stack: 3.16456 std::stack: 3.23298 std::stack: 3.20854 FastStack: 1.97636 FastStack: 1.97958 FastStack: 2.12977 FastStack: 2.13507 Done [D:\dev\test\so\12704314] > _
类似于Visual C ++。
现在让我们看一下std::vector::push_back的典型实现，由std::stack<T, std::vector<T>>::push调用（顺便说一句，我知道只有3个曾经使用过这种缩进风格的程序员，即PJP，Petzold和我自己我现在，自1998年以来，认为这太可怕了！）：
void push_back(const value_type& _Val)
{ // insert element at end
if (_Inside(_STD addressof(_Val)))
{ // push back an element
size_type _Idx = _STD addressof(_Val) - this->_Myfirst;
if (this->_Mylast == this->_Myend)
_Reserve(1);
_Orphan_range(this->_Mylast, this->_Mylast);
this->_Getal().construct(this->_Mylast,
this->_Myfirst[_Idx]);
++this->_Mylast;
}
else
{ // push back a non-element
if (this->_Mylast == this->_Myend)
_Reserve(1);
_Orphan_range(this->_Mylast, this->_Mylast);
this->_Getal().construct(this->_Mylast,
_Val);
++this->_Mylast;
}
}
我怀疑所测量的低效率至少部分在于那里发生的所有事情，也许它也是自动生成安全检查的问题。
对于调试版本，std::stack表现非常糟糕，我放弃了等待任何结果。
编辑：根据下面的Xeo评论，我更新了push，以便在缓冲区重新分配的情况下检查“自推”，将其作为一个单独的函数进行分解：
void push( Type const& x )
{
if( size() == capacity() )
{
reserveAndPush( x );
}
st_[++lastIndex_] = x;
}
神秘的是，虽然在此测试中reserveAndPush 从未被称为，但它会影响性能 - 由于代码大小不适合缓存？
[D:\dev\test\so\12704314] > a std::stack: 3.21623 std::stack: 3.30501 std::stack: 3.24337 std::stack: 3.27711 FastStack: 2.52791 FastStack: 2.44621 FastStack: 2.44759 FastStack: 2.47287 Done [D:\dev\test\so\12704314] > _
<小时/> 编辑2 ：DeadMG显示代码必须是错误的。我认为问题是缺少
return，加上计算新大小的表达式（两次零仍为零）。他还指出我忘了展示reserveAndPush。应该是：
void reserveAndPush( Type const& x )
{
Type const xVal = x;
reserve( capacity_ == 0? 1 : 2*capacity_ );
push( xVal );
}
void push( Type const& x )
{
if( size() == capacity() )
{
return reserveAndPush( x ); // <-- The crucial "return".
}
st_[++lastIndex_] = x;
}