Implementazione sicura del buffer circolare

Question

Circular_buffer dalla libreria boost non è thread-safe. Quindi ho spostato l'oggetto boost :: circular_buffer in una classe come mostrato di seguito. L'esclusione reciproca tra i thread viene raggiunta (credo) utilizzando variabili condizionali, un mutex e un'acquisizione/rilascio di blocco. Questo thread di implementazione è sicuro?

#include <boost/thread/condition.hpp> 
#include <boost/thread/mutex.hpp> 
#include <boost/thread/thread.hpp> 
#include <boost/circular_buffer.hpp> 

// Thread safe circular buffer 
template <typename T> 
class circ_buffer : private boost::noncopyable 
{ 
public: 
    typedef boost::mutex::scoped_lock lock; 
    circ_buffer() {} 
    circ_buffer(int n) {cb.set_capacity(n);} 
    void send (T imdata) { 
     lock lk(monitor); 
     cb.push_back(imdata); 
     buffer_not_empty.notify_one(); 
    } 
    T receive() { 
     lock lk(monitor); 
     while (cb.empty()) 
      buffer_not_empty.wait(lk); 
     T imdata = cb.front(); 
     cb.pop_front(); 
     return imdata; 
    } 
    void clear() { 
     lock lk(monitor); 
     cb.clear(); 
    } 
    int size() { 
     lock lk(monitor); 
     return cb.size(); 
    } 
    void set_capacity(int capacity) { 
     lock lk(monitor); 
     cb.set_capacity(capacity); 
    } 
private: 
    boost::condition buffer_not_empty; 
    boost::mutex monitor; 
    boost::circular_buffer<T> cb; 
}; 

Modifica Questa è ora una classe template, che accetta un oggetto di qualsiasi tipo (non solo cv::Mat oggetto).

Answer 1

Sì.
Se si bloccano tutti i metodi pubblici con lo stesso blocco, sarà protetto da thread.

Si potrebbe considerare l'utilizzo di read-write locks, che può avere prestazioni migliori se si dispone di molti lettori concorrenti.

Se non si dispone di molti lettori, aggiungerà solo un sovraccarico, ma potrebbe essere opportuno verificare l'opzione e il test.

Answer 2

Sembra buono a prima vista, tranne che non si sta utilizzando la condizione buffer_not_full. Probabilmente vorrai aggiungere un codice simile al codice buffer_not_empty.

Answer 3

penso che sia a posto, tranne che ci sono alcune inutili copie di Mat realizzate in send. Non hai bisogno del nuovo, puoi direttamente spingere l'argomento di send al tuo cb.

Answer 4

L'implementazione è simile a quella mostrata da questo blogger. Dovresti leggere quel blog per vedere se hai perso qualcosa nella tua implementazione.

Se gli oggetti Mat sono costosi da creare/copiare, evitare di creare/copiare/eliminare continuamente. Invece, dovresti avere un pool (o lista libera) di oggetti Mat che ottengono continuamente riciclato in una sorta di architettura della pipeline. Descrivo questo tipo di architettura in questo answer in una domanda correlata.

In questa risposta, ho suggerito di utilizzare uno stack di blocco per implementare il pool, ma è anche possibile utilizzare il blocco circular_buffer. Il motivo per cui ho suggerito una pila è perché pensavo che potesse essere più facile da usare nella cache, ma non ho mai effettivamente misurato per vedere se avrebbe fatto la differenza.