小编Tho*_*ell的帖子

我正在阅读Anthony Williams的"行动中的C++并发"和第5章,其中讨论了新的多线程感知内存模型和原子操作,并指出:

为了std::atomic<UDT>用于某些用户定义的UDT类型,此类型必须具有普通的复制赋值运算符.

据我了解,这意味着std::atomic<UDT>如果以下内容返回true ,我们可以使用:

std::is_trivially_copyable<UDT>::value

通过这种逻辑,我们不应该使用它std::string作为模板参数std::atomic并使其正常工作.

但是,以下代码使用预期输出进行编译和运行:

#include <atomic>
#include <thread>
#include <iostream>
#include <string>

int main()
{
    std::atomic<std::string> atomicString;

    atomicString.store( "TestString1" );

    std::cout << atomicString.load() << std::endl;

    atomicString.store( "TestString2" );

    std::cout << atomicString.load() << std::endl;

    return 0;
}

这是一个未定义的行为,恰好按预期行事吗？

提前致谢!

有人告诉我,当编写Microsoft特定的C++代码时,写入Sleep(1)比自动Sleep(0)锁定要好得多,因为它Sleep(0)会占用更多的CPU时间,而且只有在等待运行的另一个等优先级线程时才会产生.

但是,对于C++ 11线程库,没有太多文档(至少我已经能够找到)关于std::this_thread::yield()vs 的效果std::this_thread::sleep_for( std::chrono::milliseconds(1) ); 第二当然是更冗长,但他们都同样有效的自旋锁呢,还是从潜在受影响相同遭遇的陷阱Sleep(0)主场迎战Sleep(1)？

一个示例循环,其中任何一个std::this_thread::yield()或std::this_thread::sleep_for( std::chrono::milliseconds(1) )可以接受:

void SpinLock( const bool& bSomeCondition )
{
    // Wait for some condition to be satisfied
    while( !bSomeCondition )
    {
         /*Either std::this_thread::yield() or 
           std::this_thread::sleep_for( std::chrono::milliseconds(1) ) 
           is acceptable here.*/
    }

    // Do something!
}

为了给出一些背景信息,我正在处理一个保存的文件,在使用正则表达式将文件拆分成它的组件对象之后,我需要根据它的对象类型来处理对象的数据.

我目前的想法是使用并行性来获得一点性能提升,因为加载每个对象是相互独立的.所以我要定义一个LoadObject函数接受一个std::string我将要处理的每种类型的对象,然后调用std::async如下:

void LoadFromFile( const std::string& szFileName )
{
     static const std::regex regexObject( "=== ([^=]+) ===\\n((?:.|\\n)*)\\n=== END \\1 ===", std::regex_constants::ECMAScript | std::regex_constants::optimize );

     std::ifstream inFile( szFileName );
     inFile.exceptions( std::ifstream::failbit | std::ifstream::badbit );

     std::string szFileData( (std::istreambuf_iterator<char>(inFile)), (std::istreambuf_iterator<char>()) );

     inFile.close();

     std::vector<std::future<void>> vecFutures;

     for( std::sregex_iterator itObject( szFileData.cbegin(), szFileData.cend(), regexObject ), end; itObject != end; ++itObject )
     {
          // Determine what type of object we're loading:
          if( (*itObject)[1] == "Type1" )
          {
               vecFutures.emplace_back( std::async( LoadType1, (*itObject)[2].str() ) ); …

我正在观看Herb Sutter在C++和Beyond 2012关于Concurrency的会议上的演讲,他谈到创建一个非阻塞的包装类,他称之为concurrent<T>C++ 11函数.

他的实现相当简单(除了需要concurrent_queue像微软的PPL中存在的那样):

template <class T>
class concurrent {
private:
    mutable T t;
    mutable concurrent_queue<std::function<void()>> q;
    bool done = false;
    std::thread thread;

public:
    concurrent( T t_ = T{} ) : t{t_}, thread{ [=]{ while( !done ) q.pop()(); }} {}

    ~concurrent() { q.push( [=]{ done = true; } ); thread.join(); }

    template <typename F>
    void operator()( F f ) const { q.push( [=]{ f(t); } ); }

};

这看起来很简单,但是,我很困惑为什么他已经捕获了成员变量done和q值而不是通过引用？我的理解是,如果它们被值捕获,那么它们将被复制到线程中,因此当队列更新时,工作线程将不会收到更新？ …

是否有可能使用std::regex在多线程使用的所有对象std::sregex_iterator,std::regex_match等等？

例如,以下是否会产生逻辑行为:

bool SomeFunc( const std::string& szString1, const std::string& szString2 ) 
{
     static const std::regex regexTest( "=== ([\\w]+) ===", std::regex_constants::optimize );

     std::future<bool> f = std::async( []( std::string szString ) {
        return std::regex_match( szString, regexTest );  
     }, szString1 );

     bool b = std::regex_match( szString2, regexTest );

     return (b && f.get());
}

我找不到任何说明是否const std::regex同时使用未定义行为的状态.据我所知,没有对正则表达式对象进行编辑,因此同时使用它不会导致未定义的行为？

提前致谢!

继上一个问题:ECMAScript Regex的多行字符串,我实现了以下加载过程:

void Load( const std::string& szFileName )
{
     static const std::regex regexObject( "=== ([^=]+) ===\\n((?:.|\\n)*)\\n=== END \\1 ===", std::regex_constants::ECMAScript | std::regex_constants::optimize );
     static const std::regex regexData( "<([^>]+)>:([^<]*)\\n", std::regex_constants::ECMAScript | std::regex_constants::optimize );

     std::ifstream inFile( szFileName );
     inFile.exceptions( std::ifstream::badbit );

     std::string szFileData( (std::istreambuf_iterator<char>(inFile)), (std::istreambuf_iterator<char>()) );

     inFile.close();

     std::vector<std::future<void>> vecFutures;

     for( std::sregex_iterator itObject( szFileData.cbegin(), szFileData.cend(), regexObject ), end; itObject != end; ++itObject )
     {
          if( (*itObject)[1] == "OBJECT1" )
          {
               vecFutures.emplace_back( std::async( []( std::string szDataString ) {
                    for( std::sregex_iterator itData( szDataString.cbegin(), …

我想知道是否有可能将一个变量添加到卷积神经网络的密集层中(以及来自先前卷积层的连接,还有一个可用于歧视目的的附加功能集)？如果这是可能的,有人可以给我一个示例/文档解释如何这样做吗？

我希望使用Keras,但如果Keras限制太多,我很乐意使用TensorFlow.

编辑:在这种情况下,我认为这应该工作的方式是我提供一个包含图像和相关功能集的列表到神经网络(并在训练期间相关的分类).

EDIT2:我想要的架构看起来像:

              ___________      _________      _________      _________     ________    ______
              | Conv    |     | Max    |     | Conv    |     | Max    |    |       |   |     |
    Image --> | Layer 1 | --> | Pool 1 | --> | Layer 2 | --> | Pool 2 | -->|       |   |     |
              |_________|     |________|     |_________|     |________|    | Dense |   | Out |
                                                                           | Layer |-->|_____|
   Other      ------------------------------------------------------------>|       |
   Data                                                                    |       |
                                                                           |_______|

我正在使用std::regex,在阅读中定义的各种常量时std::regex_constants,我遇到了std::optimize,阅读它,听起来它在我的应用程序中很有用(我只需要一个正则表达式的实例,在开头初始化,但它是在整个装载过程中多次使用).

据该工作文件n3126(第1077), std::regex_constants::optimize:

指定正则表达式引擎应该更加关注正则表达式匹配的速度,并且更少关注正则表达式对象的构造速度.否则它对程序输出没有可检测的影响.

我很好奇将会执行什么类型的优化,但似乎没有太多关于它的文献(事实上,它似乎是未定义的),我发现的唯一的事情之一是在cppreference.com,声明std::regex_constants::optimize:

指示正则表达式引擎更快地进行匹配,以及使构造变慢的潜在成本.例如,这可能意味着将非确定性FSA转换为确定性FSA.

但是,我没有计算机科学的正式背景,虽然我知道FSA是什么的基础知识,并且理解确定性FSA(每个州只有一个可能的下一个状态)和非确定性FSA(具有多个潜在的下一个状态); 我不明白这是如何改善匹配时间的.另外,我很想知道在各种C++标准库实现中是否还有其他优化.

我正在使用Microsoft Visual Studio 2012,并且正在查看使用std::put_time,因此我创建了以下示例:

int main()
{
    std::time_t t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());

    std::locale::global( std::locale("en-GB") );

    std::cout << std::put_time( std::localtime( &t ), "%x" ) << std::endl;
}

这会产生以下输出:

06/25/2013

这不是我期望从en-GB语言环境中获得的日期格式.我也尝试过:

std::cout.imbue( std::locale("en-GB") );

但同样,输出相同.这是我应该为这个语言环境获取的输出,还是我在某个地方犯了错误？

如标题中所述:

SAL(源注释语言)的目的是什么？SAL 1和SAL 2之间有什么区别？

我理解使用的基础知识,这有助于突出传递给函数的每个变量的目的以及静态代码分析的各种其他内容,但它实际上有多大差异(忽略了参数要求的增加清晰度)该项目的其他程序员)？

如果我有以下原型:

_Success_(return == 1) 
int TestFunction( _In_ int* pTest, _Inopt_ char* pOptional );

这应该"告诉"静态分析器该函数在成功操作时将返回1,这pTest是一个必须不是指针,nullptr而且pOptional指针可能是也可能不是nullptr.但是,静态分析器不能从函数定义本身获取此信息吗？此外,它如何处理获得的信息,例如成功标准？

此外,为什么会出现SAL 1和SAL 2,为什么微软决定改变他们命名了他们的宏的方式之间的差异(即从__out到_Out_和__success到_Success_？)

我很抱歉,如果在MSDN上详细描述了这一点,但我无法在StackOverflow上找到它或任何其他问题并提供详细的答案,所以我想我会问我希望能满足我的好奇心.

在此先感谢您的时间!