使用 Boost.Lockfree 队列比使用互斥锁慢-C/C++问题

Using Boost.Lockfree queue is slower than using mutexes(使用 Boost.Lockfree 队列比使用互斥锁慢)

本文介绍了使用 Boost.Lockfree 队列比使用互斥锁慢的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

直到现在我在我的项目中使用 std::queue.我测量了此队列上的特定操作所需的平均时间.

Until now I was using std::queue in my project. I measured the average time which a specific operation on this queue requires.

时间是在 2 台机器上测量的:我的本地 Ubuntu VM 和远程服务器.使用 std::queue，两台机器上的平均值几乎相同:~750 微秒.

The times were measured on 2 machines: My local Ubuntu VM and a remote server. Using std::queue, the average was almost the same on both machines: ~750 microseconds.

然后我将std::queue升级"到boost::lockfree::spsc_queue，这样我就可以摆脱保护队列的互斥锁.在我的本地 VM 上，我可以看到巨大的性能提升，现在平均为 200 微秒.然而，在远程机器上，平均值上升到 800 微秒，比以前慢.

Then I "upgraded" the std::queue to boost::lockfree::spsc_queue, so I could get rid of the mutexes protecting the queue. On my local VM I could see a huge performance gain, the average is now on 200 microseconds. On the remote machine however, the average went up to 800 microseconds, which is slower than it was before.

首先我认为这可能是因为远程机器可能不支持无锁实现:

First I thought this might be because the remote machine might not support the lock-free implementation:

来自 Boost.Lockfree 页面:

并非所有硬件都支持相同的原子指令集.如果它在硬件中不可用，则可以使用防护在软件中进行模拟.然而，这有一个明显的缺点，即失去了无锁属性.

Not all hardware supports the same set of atomic instructions. If it is not available in hardware, it can be emulated in software using guards. However this has the obvious drawback of losing the lock-free property.

为了查明是否支持这些指令，boost::lockfree::queue 有一个名为 bool is_lock_free(void) const; 的方法.但是，boost::lockfree::spsc_queue 没有这样的功能，对我来说，这意味着它不依赖于硬件，并且始终是无锁的 - 在任何机器上.

To find out if these instructions are supported, boost::lockfree::queue has a method called bool is_lock_free(void) const;. However, boost::lockfree::spsc_queue does not have a function like this, which, for me, implies that it does not rely on the hardware and that is is always lockfree - on any machine.

性能下降的原因可能是什么?

What could be the reason for the performance loss?

// c++11 compiler and boost library required

#include <iostream>
#include <cstdlib>
#include <chrono>
#include <async>
#include <thread>
/* Using blocking queue:
 * #include <mutex>
 * #include <queue>
 */
#include <boost/lockfree/spsc_queue.hpp>


boost::lockfree::spsc_queue<int, boost::lockfree::capacity<1024>> queue;

/* Using blocking queue:
 * std::queue<int> queue;
 * std::mutex mutex;
 */

int main()
{
    auto producer = std::async(std::launch::async, [queue /*,mutex*/]() 
    {
        // Producing data in a random interval
        while(true)
        {
            /* Using the blocking queue, the mutex must be locked here.
             * mutex.lock();
             */

            // Push random int (0-9999)
            queue.push(std::rand() % 10000);

            /* Using the blocking queue, the mutex must be unlocked here.
             * mutex.unlock();
             */

            // Sleep for random duration (0-999 microseconds)
            std::this_thread::sleep_for(std::chrono::microseconds(rand() % 1000));
        }
    }

    auto consumer = std::async(std::launch::async, [queue /*,mutex*/]() 
    {
        // Example operation on the queue.
        // Checks if 1234 was generated by the producer, returns if found.

        while(true)
        {
            /* Using the blocking queue, the mutex must be locked here.
             * mutex.lock();
             */

            int value;
            while(queue.pop(value)
            {
                if(value == 1234)
                    return;
            }

            /* Using the blocking queue, the mutex must be unlocked here.
             * mutex.unlock();
             */

            // Sleep for 100 microseconds
            std::this_thread::sleep_for(std::chrono::microseconds(100));
        }
    }

    consumer.get();
    std::cout << "1234 was generated!" << std::endl;
    return 0;
}

使用 Boost.Lockfree 队列比使用互斥锁慢

问题描述

推荐答案

基础教程推荐