Do tej pory używałem std::queue w swoim projekcie. Zmierzyłem średni czas, jakiego wymaga konkretna operacja w tej kolejce.

Czasy były mierzone na 2 maszynach: mojej lokalnej maszynie wirtualnej Ubuntu i zdalnym serwerze. Używając std::queue, średnia była prawie taka sama na obu maszynach: ~750 mikrosekund.

Potem "ulepszyłem" std::queue do boost::lockfree::spsc_queue, żeby pozbyć się muteksów chroniących kolejkę. Na moim lokalnym VM mogłem zobaczyć ogromny wzrost wydajności, średnia jest teraz na 200 mikrosekundy. Jednak na zdalnej maszynie średnia wzrosła do 800 mikrosekund, co jest wolniejsze niż wcześniej.

Najpierw pomyślałem, że może to być spowodowane tym, że zdalna maszyna może nie obsługiwać implementacji bez blokady:

Z doładowania.Strona Lockfree:

Nie wszystkie urządzenia obsługują ten sam zestaw instrukcji atomowych. Jeśli nie jest dostępny w sprzęcie, można go emulować w oprogramowaniu za pomocą strażników. Ma to jednak oczywistą wadę utrata własności bez blokady.

Aby dowiedzieć się, czy te instrukcje są obsługiwane, boost::lockfree::queue ma metodę o nazwie bool is_lock_free(void) const;. Jednak boost::lockfree::spsc_queue nie ma takiej funkcji, co dla mnie oznacza, że nie opiera się na sprzęcie, a to jest zawsze lockfree - na każdej maszynie.

Co może być przyczyną utraty wydajności?

Kod Exmple (Producent/konsument)

// 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;
}