Синхронизированный производитель и потребитель с циркулярным буфером

Question

У меня есть производитель и потребитель. Производитель записывает фиксированные элементы размера в заданную область разделяемой памяти, и потребитель извлекает их.

Производитель может быть заметно медленнее или быстрее, чем потребитель, случайным образом.

То, что мы хотим, чтобы

1. Если производитель работает быстрее, чем потребитель, когда он заполняет кольцевой буфер, он продолжает писать на старых кадрах (кроме того, что потребитель потребляет Конечно, я подчеркиваю, что производитель и потребитель должны быть синхронизированы в решении, потому что это несвязанные процессы).

2. Если вместо этого потребитель быстрее производителя, он должен ждать нового кадра и потреблять его, когда он есть.

Я нашел реализации производителя/потребитель кольцевых буферов, но только те, которые не уважают первый запрос (то есть, если кольцевой буфер заполнен, они ждут для потребителя, чтобы закончить, в то время как то, что я хотите перезаписать самые старые кадры).

Я бы предпочел не откатывать мое собственное (подверженное ошибкам) ​​решение, но использовать предварительно подготовленный, проверенный. Может ли кто-нибудь указать мне на хорошую реализацию C? (C++ тоже нормально).

Большое спасибо.

Answer 1

Похоже, вы хотите использовать double ended queue, который предоставляется на C++ Standard Template Library (STL).. Но это использует C++, а не C. Если ваш производитель и потребитель - разные потоки, вам также понадобится мьютекс для защиты структуры очереди.

Answer 2

В основном, когда потребители работают медленно, это означает, что никто не использует буфер, поэтому нет никакой разницы между сбросом новых кадров и переопределением старых кадров. Поэтому, возможно, следующий код может помочь. ПроизводительRTLock не может заблокировать буфер, потому что есть потребители, использующие bufffer, и поэтому на уровне приложения вы можете указать, что нужно удалить кадры.

class SampleSynchronizer { 

    mutex mux; 

    condition_variable con_cond; 
    unsigned int con_num; 

    condition_variable pro_cond; 
    bool prod; 

public: 

    SampleSynchronizer(): con_num(0), prod(false) { 
    } 

    void consumerLock() { 
    unique_lock<mutex> locker(mux); 
    while(prod) 
     pro_cond.wait(locker); 

    con_num++; 
    } 

    void consumerUnlock() { 
    lock_guard<mutex> locker(mux); 
    con_num--; 
    con_cond.notify_one(); 
    } 

    void producerLock() { 
    unique_lock<mutex> locker(mux); 
    while(con_num > 0) 
     con_cond.wait(locker); 

    prod = true; 
    } 

    bool producerRTLock() { 
    lock_guard<mutex> locker(mux); 
    if(con_num > 0) 
     return false; 

    prod = true; 
    return true; 
    } 

    void producerUnlock() { 
    lock_guard<mutex> locker(mux); 
    prod = false; 
    pro_cond.notify_all(); 
    } 

};