Comment Boost Interprocess et Lockfree peuvent-ils être utilisés pour obtenir une synchronisation sans verrouillage dans un scénario de mémoire partagée avec un grand tampon circulaire ?

Synchronisation IPC de mémoire partagée sans verrouillage

Dans un scénario de mémoire partagée avec plusieurs processus et un grand tampon circulaire, réaliser une synchronisation efficace pose un défi. Cet article explore une approche sans verrouillage utilisant Boost Interprocess et Boost Lockfree pour résoudre ce problème.

Boost Interprocess et Lockfree

Boost Interprocess prend en charge la mémoire partagée, tandis que Boost Lockfree propose un producteur- implémentation de la file d'attente consommateur (spsc_queue). Cette file d'attente est analogue à un tampon circulaire.

Implémentation d'une file d'attente partagée

Considérez l'exemple suivant utilisant Boost Interprocess et Lockfree :

<code class="cpp">// Shared Memory Types
namespace shm
{
    using shared_string = bip::basic_string<char, std::char_traits<char>, char_alloc>;
    using ring_buffer = boost::lockfree::spsc_queue<
        shared_string, 
        boost::lockfree::capacity<200> 
    >;
}</code>

Cela définit un type de chaîne partagée qui alloue de la mémoire à partir du segment partagé et un tampon en anneau partagé d'une capacité de 200 éléments.

Implémentation du consommateur

<code class="cpp">// Consumer Side
int main()
{
    // Open or create shared memory segment
    bip::managed_shared_memory segment(bip::open_or_create, "MySharedMemory", 65536);
    
    // Find or construct shared queue
    shm::ring_buffer *queue = segment.find_or_construct<shm::ring_buffer>("queue")();
    
    // Infinite loop to process messages
    while (true)
    {
        // Sleep for 10ms
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        
        // Allocate shared string to receive message
        shm::shared_string v(char_alloc);
        
        // Pop message from queue
        if (queue->pop(v))
            std::cout << "Processed: '" << v << "'\n";
    }
}</code>

Le consommateur surveille en permanence la file d'attente partagée pour les messages et les traite avec un intervalle de veille de 10 ms.

Implémentation du producteur

<code class="cpp">// Producer Side
int main()
{
    // Open or create shared memory segment
    bip::managed_shared_memory segment(bip::open_or_create, "MySharedMemory", 65536);
    
    // Find or construct shared queue
    shm::ring_buffer *queue = segment.find_or_construct<shm::ring_buffer>("queue")();
    
    // Produce messages
    for (const char* s : { "hello world", "the answer is 42", "where is your towel" })
    {
        // Sleep for 250ms
        std::this_thread::sleep_for(std::chrono::milliseconds(250));
        
        // Push message to queue
        queue->push({s, char_alloc});
    }
}</code>

Le producteur envoie trois messages à la file d'attente partagée avec un intervalle de 250 ms.

Synchronisation sans verrouillage

En utilisant spsc_queue de Boost Lockfree, le producteur et le consommateur peuvent communiquer sans mécanismes de verrouillage. L'implémentation de la file d'attente garantit que les écritures dans le tampon sont immédiatement visibles pour le consommateur, résolvant ainsi le problème de visibilité rencontré avec les barrières du compilateur utilisant GCC.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!