我目前正在进行一个性能至关重要的项目。以下是我对这个问题的一些疑问。

问题1

我的项目涉及大量 boost::shared_ptr .我知道使用 boost::make_shared 在运行时创建共享指针很慢，因为它需要跟踪引用，所以有很多开销。我想知道如果已经创建了 boost 共享指针，那么这两个语句是否具有相同的性能，或者一个比另一个更快。如果常规指针更快并且我已经有共享指针，我有哪些选项可以调用共享指针指向的方法？

 statement1: sharedptr->someMethod();  //here the pointer is a shared ptr created by boost::make_shared
 statement2: regularptr->someMethod(); //here the pointer is a regular one made with new

问题二

我有一个快速调用的实例方法，它创建了一个 std::vector<std::string>每次都在堆栈上。我决定将该 vector 指针存储在静态 std::map (即)std::map<std::String,std::vector<std::string>*> 中。 .如果键(可能是方法的名称)的映射中不存在 vector 。有效的 vector 地址已创建并添加到 map 中。所以我的问题是“是否值得在 map 上搜索 vector 地址并返回有效地址，而不是像 std::vector<std::string> somevector 这样在堆栈上创建一个地址。我还想要一个关于 std::map 查找性能的想法。

任何关于这些问题的想法都将不胜感激。

最佳答案

问题#1 的答案

If the regular pointers are faster and I already have shared pointers what options do I have in order to call a method that the shared pointer points to?

operator->在 boost::shared_ptr 内has assertion :

typename boost::detail::sp_member_access< T >::type operator-> () const 
{
    BOOST_ASSERT( px != 0 );
    return px;
}

因此，首先，请确保您拥有 NDEBUG已定义(通常在发布版本中它是自动完成的):

#define NDEBUG

我已经对 boost::shared_ptr 的取消引用进行了汇编程序比较和原始指针:

template<int tag,typename T>
NOINLINE void test(const T &p)
{
    volatile auto anti_opti=0;
    ASM_MARKER<tag+0>();
    anti_opti = p->data;
    anti_opti = p->data;
    ASM_MARKER<tag+1>();
    (void)anti_opti;
}

test<1000>(new Foo);

ASM test 代码什么时候T是Foo*是(别害怕，我下面有 diff):

_Z4testILi1000EP3FooEvRKT0_:
.LFB4088:
.cfi_startproc
pushq %rbx
.cfi_def_cfa_offset 16
.cfi_offset 3, -16
movq %rdi, %rbx
subq $16, %rsp
.cfi_def_cfa_offset 32
movl $0, 12(%rsp)
call _Z10ASM_MARKERILi1000EEvv
movq (%rbx), %rax
movl (%rax), %eax
movl %eax, 12(%rsp)
movl %eax, 12(%rsp)
call _Z10ASM_MARKERILi1001EEvv
movl 12(%rsp), %eax
addq $16, %rsp
.cfi_def_cfa_offset 16
popq %rbx
.cfi_def_cfa_offset 8
ret
.cfi_endproc

test<2000>(boost::make_shared<Foo>());

ASM test 代码什么时候T是boost::shared_ptr<Foo> :

_Z4testILi2000EN5boost10shared_ptrI3FooEEEvRKT0_:
.LFB4090:
.cfi_startproc
pushq %rbx
.cfi_def_cfa_offset 16
.cfi_offset 3, -16
movq %rdi, %rbx
subq $16, %rsp
.cfi_def_cfa_offset 32
movl $0, 12(%rsp)
call _Z10ASM_MARKERILi2000EEvv
movq (%rbx), %rax
movl (%rax), %eax
movl %eax, 12(%rsp)
movl %eax, 12(%rsp)
call _Z10ASM_MARKERILi2001EEvv
movl 12(%rsp), %eax
addq $16, %rsp
.cfi_def_cfa_offset 16
popq %rbx
.cfi_def_cfa_offset 8
ret
.cfi_endproc

这是 diff -U 0 foo_p.asm shared_ptr_foo_p.asm 的输出命令:

--- foo_p.asm   Fri Apr 12 10:38:05 2013
+++ shared_ptr_foo_p.asm        Fri Apr 12 10:37:52 2013
@@ -1,2 +1,2 @@
-_Z4testILi1000EP3FooEvRKT0_:
-.LFB4088:
+_Z4testILi2000EN5boost10shared_ptrI3FooEEEvRKT0_:
+.LFB4090:
@@ -11 +11 @@
-call _Z10ASM_MARKERILi1000EEvv
+call _Z10ASM_MARKERILi2000EEvv
@@ -16 +16 @@
-call _Z10ASM_MARKERILi1001EEvv
+call _Z10ASM_MARKERILi2001EEvv

如您所见，区别仅在于函数签名，而tag非类型模板参数值，其余代码为 IDENTICAL .

一般 - shared_ptr非常昂贵 - 它的引用计数在线程之间同步(通常通过原子操作)。如果你会使用 boost::intrusive_ptr 相反，您可以实现自己的 increment/decrement没有线程同步，这将 boost 引用计数。

如果您负担得起使用 unique_ptr或移动语义(通过 Boost.Move 或 C++11)——然后将没有任何引用计数——它会更快。

LIVE DEMO WITH ASM OUTPUT

#define NDEBUG

#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>

#define NOINLINE __attribute__ ((noinline))

template<int>
NOINLINE void ASM_MARKER()
{
    volatile auto anti_opti = 11;
    (void)anti_opti;
}

struct Foo
{
    int data;
};

template<int tag,typename T>
NOINLINE void test(const T &p)
{
    volatile auto anti_opti=0;
    ASM_MARKER<tag+0>();
    anti_opti = p->data;
    anti_opti = p->data;
    ASM_MARKER<tag+1>();
    (void)anti_opti;
}

int main()
{
    {
        auto p = new Foo;
        test<1000>(p);
        delete p;
    }
    {
        test<2000>(boost::make_shared<Foo>());
    }
}

问题 #2 的答案

I have an instance method(s) that is rapidly called that creates a std::vector on the stack every time.

通常，尝试重用 vector 是个好主意的容量，以防止代价高昂的重新分配。例如，最好替换为:

{
    for(/*...*/)
    {
        std::vector<value> temp;
        // do work on temp
    }
}

与:

{
    std::vector<value> temp;
    for(/*...*/)
    {
        // do work on temp
        temp.clear();
    }
}

但看起来由于类型 std::map<std::string,std::vector<std::string>*>你正在尝试执行某种 memoization .

正如已经建议的，而不是 std::map其中有 O(ln(N)) 查找/插入你可以尝试使用 boost::unordered_map / std::unordered_map 它具有 O(1) 平均和 O(N) 查找/插入的最坏情况复杂度，以及更好的局部性/紧凑性(缓存友好)。

此外，考虑尝试 Boost.Flyweight :

Flyweights are small-sized handle classes granting constant access to shared common data, thus allowing for the management of large amounts of entities within reasonable memory limits. Boost.Flyweight makes it easy to use this common programming idiom by providing the class template flyweight, which acts as a drop-in replacement for const T.

关于c++ - 智能指针环绕惩罚。使用 std::map 进行内存，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15963563/