小编Yan*_*hou的帖子

我无法想出一个适当的问题标题来描述问题.希望下面的细节清楚地解释了我的问题.

请考虑以下代码

#include <iostream>

template <typename Derived>
class Base
{
    public :

    void call ()
    {
        static_cast<Derived *>(this)->call_impl();
    }
};

class D1 : public Base<D1>
{
    public :

    void call_impl ()
    {
        data_ = 100;
        std::cout << data_ << std::endl;
    }

    private :

    int data_;
};

class D2 : public Base<D1> // This is wrong by intension
{
    public :

    void call_impl ()
    {
        std::cout << data_ << std::endl;
    }

    private :

    int data_;
};

int main ()
{
    D2 …

请考虑以下简单示例

struct C
{
    template <typename T> operator T () {return 0.5;}
    operator int () {return 1;}
    operator bool () {return false;}
};

int main ()
{
    C c;
    double x = c;
    std::cout << x << std::endl;
}

使用Clang编译时,会出现以下错误

test.cpp:11:12: error: conversion from 'C' to 'double' is ambiguous
    double x = c;
           ^   ~
test.cpp:4:5: note: candidate function
    operator int () {return 1;}
    ^
test.cpp:5:5: note: candidate function
    operator bool () {return false;}
    ^
test.cpp:3:27: note: candidate function [with …

简短的问题是,如果我有一个带两个向量的函数.一个是输入,另一个是输出(无别名).我只能调整其中一个,我应该选择哪一个？

更长的版本是,考虑一个功能,

void func(size_t n, void *in, void *out)
{
    __m256i *in256 = reinterpret_cast<__m256i *>(in);
    __m256i *out256 = reinterpret_cast<__m256i *>(out);
    while (n >= 32) {
         __m256i data = _mm256_loadu_si256(in256++);
         // process data
         _mm256_storeu_si256(out256++, data);
         n -= 32;
    }
    // process the remaining n % 32 bytes;
}

如果in和out都是32字节对齐,那么使用vmovdqu而不是代价vmovdqa.最糟糕的情况是两者都是未对齐的,并且四分之一的加载/存储将跨越缓存行边界.

在这种情况下,我可以通过在进入循环之前先处理几个元素将其中一个与高速缓存行边界对齐.但是,问题是我应该选择哪个？在未对齐的加载和存储之间,哪一个更糟？

我有一个相当复杂的程序,在MSVC 2010调试模式下使用OpenMP构建时会遇到奇怪的行为.我尽力构建以下最小的工作示例(虽然它并不是真正的最小化),这样可以简化真实程序的结构.

#include <vector>
#include <cassert>

// A class take points to the whole collection and a position Only allow access
// to the elements at that posiiton. It provide read-only access to query some
// information about the whole collection
class Element
{
    public :

    Element (int i, std::vector<double> *src) : i_(i), src_(src) {}

    int i () const {return i_;}
    int size () const {return src_->size();}

    double src () const {return (*src_)[i_];}
    double &src () {return (*src_)[i_];}

    private : …

我最近更新到Fedora 21 Beta,并更新了所有软件包.由于最终版本将在下个月初安排,我预计不会发生任何重大变化.所以我认为我面临的问题可能会持续到产品发布中.

问题是当使用一些基于终端的应用程序时,终端响应非常慢.例如,假设我在终端中使用Vim编辑文件,几分钟后,它变得越来越难以使用.每按一次键击,光标就会等待一秒钟响应.在GVim中编辑同一个文件(只有十几行),一切都按预期顺利进行.其他基于终端的应用程序显示相同的慢响应.但是,使用终端本身作为交互式shell完全没有问题.

我理解很难回答为什么它只是根据我模糊的描述来体验这种缓慢的反应.但是,如果任何人都可以指出我应该寻找问题的诊断,一些日志文件等,它将非常感激.

以下是该系统的更多细节.

该计算机是戴尔T3500工作站,配备Xeon W3550 CPU,NVIDIA Quadro 2000 GPU.我正在使用最新的NVIDIA二进制驱动程序(尝试了长版本340.58以及测试版系列346.16).卸载了开源驱动程序,其内核模块被列入黑名单(lsmod | grep nouveau没有显示任何内容,如预期的那样).桌面环境是GNOME Classic.

我不确定问题的标题是否合适.这是问题所在.我正在编写一个使用一些c ++ 11库特性的库.显然,并非所有实现都支持这些库,因此存在可移植性问题.这里关注哪个库并不重要.一种解决方案是使用boost,它已经提供了很多c ++ 11库.所以我的解决方案是定义一个宏,比如说USE_CXX11,并定义一个新的命名空间,并根据宏internal将名称引入这个内部命名空间.例如,假设我需要使用fooc ++库中的名称,该库<foo>也可以使用<boost/foo/foo.hpp>.我做的是

#ifdef USE_CXX11
#include <foo>
#else
#include <boost/foo/foo.hpp>
#endif

namespace internal {
#ifdef USE_CXX11
using std::foo;
#else
using boost::foo::foo;
#endif
}

在图书馆的其他部分我只使用internal::foo.使用此库的第三方代码可以定义适当的宏来指示它们是否具有有效的c ++ 11实现,或者它们只能使用boost.我的库将获取正确的标题和命名空间.这项工作到目前为止.希望我已经很好地解释了我的意图.

但上述解决方案对我来说似乎非常难看.对于这种事情有没有更好的做法？或者有任何可能的情况,这种方法不起作用？

我试着编写自己的clang格式样式文件.有两个方面我无法让他们正确.

我如何让它留着以后一个空行public:,private:,protected:？例如,我想拥有

public :

ctor () {} 

代替

public :
ctor () {}

第二个问题是,当它跟随并控制语句和函数定义时,有一种方法可以使它在括号前插入一个空格.但是在函数调用之前没有空格.例如,我想要,

void func () {}
func()

将SpaceBeforeParens只能是一个Never,Always,ControlStatements.最后一个最接近我想要的,但它仍然不能按我想要的方式工作.一个次要的相关问题是,如果它遵循一元运算符,它总是在括号之前删除空格

C &operator=(const C &);

我比较习惯

C &operator= (const C &);

从SIMD寄存器加载和存储生成目的寄存器的最佳方法是什么？到目前为止,我一直在使用堆栈作为临时.例如,

mov [rsp + 0x00], r8
mov [rsp + 0x08], r9
mov [rsp + 0x10], r10
mov [rsp + 0x18], r11
vmovdqa ymm0, [rsp] ; stack is properly aligned first.

我认为没有任何指令可以直接(或另一个方向)执行此操作,因为它意味着具有五个操作数的指令.但是,上面的代码对我来说似乎很愚蠢.有没有更好的方法呢？我只能想到一个替代方案,使用pinsrd相关说明.但它似乎没有任何好转.

动机是,有时候在AVX2中做一些事情会更快,而其他用于通用的注册事项.例如,在一小段代码中,有四个64位无符号整数,我将需要四个xor,两个mulx来自BMI2.这将是更快的做xor用vpxor,但是,mulx没有一个AVX2等同.由于包装和拆包过程,任何vpxor对比4 的增益xor都会丢失.

我发现类似的问题和答案像这一个.但是,正如我尝试的那样,如果测试成员直接在被测试的类中定义,则此SFINAE测试仅成功.例如以下,类B,D1打印HAS而另外两个打印NOT HAS.有没有一种方法来确定,如果一个类有一个成员,无论是由自己定义,或基类和基类的名称没有在这种情况下,已知的.我的动机是,我想编写一个泛型函数,如果它存在,将调用某个方法(从基础或不基础,参数的类型是通用的,留下其可能的基类型).

#include <iostream>

class HasFoo
{
    public :

    typedef char Small;
    typedef struct {char; char;} Large;

    template <typename C, void (C::*) ()> class SFINAE {};

    template <typename C> static Small test (SFINAE<C, &C::foo> *)
    {
        std::cout << "HAS" << std::endl;
    }

    template <typename C> static Large test (...)
    {
        std::cout << "NOT HAS" << std::endl;
    }
};

class B
{
    public :

    void foo () {}
};

class D1 …

我有一个简单的问题,C++ 11 thread_local可以与其他并行模型一起使用.

例如,我可以在使用OpenMP或Intel TBB并行执行任务时在函数内使用它.

大多数此类并行编程模型隐藏了更高级API背后的硬件线程.我的直觉是他们都必须将他们的任务调度程序映射到硬件线程中.我能指望C++ 11 thread_local会产生预期的效果吗？

一个简单的例子是,

void func ()
{
    static thread_local some_var = init_val;
#pragma omp parallel for [... clauses ...]
    for (int i = 0; i < N; ++i) {
        // access some_var somewhere within the loop
    }
}

我可以期望每个OpenMP线程都可以访问自己的副本some_var吗？

我知道大多数并行编程模型都有自己的线程局部存储结构.但是,能够使用C++ 11 thread_local(或编译器特定的关键字)是很好的.例如,考虑一下情况

// actually may implemented with a class with operator()
void func ()
{
     static thread_local some_var;
     // a quite complex function
}

void func_omp (int …