Guardando per l'attuazione buffer circolare a destra in C

Question

Sto cercando un'implementazione buffer circolare (o pseudo) in C con le seguenti caratteristiche:

• produttore modello multiplo singolo consumatore (MPSC)
• blocchi di consumo sulla vuoti
• produttori bloccare sul pieno
• (mi aspetto di alta contesa)

Finora ho' gratis lock- Ho lavorato solo con i buffer SPSC - uno per produttore - ma vorrei evitare la rotazione continua del consumatore per verificare la presenza di nuovi dati su tutti i suoi buffer di input (e forse per eliminare alcuni thread di marshalling nel mio sistema).

Sviluppo per Linux su macchine Intel.

Answer 1

Penso di avere quello che stai cercando. Si tratta di un'implementazione del buffer circolare senza blocco che blocca il produttore/consumatore. Hai solo bisogno di accedere alle primitive atomiche - in questo esempio userò le funzioni di gcc sync.

Ha un bug noto: se si supera il buffer di oltre il 100% non è garantito che la coda rimanga FIFO (continuerà a elaborarli tutti alla fine).

Questa implementazione si basa sulla lettura/scrittura degli elementi del buffer come un'operazione atomica (che è praticamente garantita per i puntatori)

struct ringBuffer 
{ 
    void** buffer; 
    uint64_t writePosition; 
    size_t size; 
    sem_t* semaphore; 
} 

//create the ring buffer 
struct ringBuffer* buf = calloc(1, sizeof(struct ringBuffer)); 
buf->buffer = calloc(bufferSize, sizeof(void*)); 
buf->size = bufferSize; 
buf->semaphore = malloc(sizeof(sem_t)); 
sem_init(buf->semaphore, 0, 0); 

//producer 
void addToBuffer(void* newValue, struct ringBuffer* buf) 
{ 
    uint64_t writepos = __sync_fetch_and_add(&buf->writePosition, 1) % buf->size; 

    //spin lock until buffer space available 
    while(!__sync_bool_compare_and_swap(&(buf->buffer[writePosition]), NULL, newValue)); 
    sem_post(buf->semaphore); 
}  

//consumer 
void processBuffer(struct ringBuffer* buf) 
{ 
    uint64_t readPos = 0; 
    while(1) 
    { 
     sem_wait(buf->semaphore); 

     //process buf->buffer[readPos % buf->size] 
     buf->buffer[readPos % buf->size] = NULL; 
     readPos++; 
    } 
} 

Answer 2

Vedi liblfds, un free-blocco MPMC ringbuffer. Non bloccherà affatto le strutture di dati senza lock — non tendono a farlo, perché il punto di non blocco è di evitare il blocco; è necessario gestirlo quando la struttura dati viene restituita con un NULL — restituisce NULL se si tenta di leggere su vuoto, ma non corrisponde al requisito quando si scrive su pieno; qui, getterà via l'elemento più antico e te lo darà per la tua scrittura.

Tuttavia, sarebbe necessario solo una piccola modifica per ottenere tale comportamento.

Ma potrebbe esserci una soluzione migliore. La parte difficile di un ringbuffer è quando si ottiene pieno il più vecchio elemento precedente e riutilizzandolo. Non hai bisogno di questo. Penso che si possa prendere il buffer circolare con memoria SPSC solo circolare e riscriverlo usando operazioni atomiche. Quello sarà un lotto più performante che il buffer di chiamata MPMC in liblfds (che è una combinazione di una coda e uno stack).