Passe std segura C ++ :: set que suporta adicionar, remover e iteradores de vários segmentos

Question

Eu estou procurando algo semelhante ao CopyOnWriteSet em Java, um conjunto que suporta add, remove e algum tipo de iterators de vários segmentos.

Answer 1

não há um que eu conheço, o mais próximo é em blocos de construção de rosca que tem concurrent_unordered_map

Os contêineres STL permitir simultâneo acesso de leitura de vários segmentos contanto que você não fizer isso não está fazendo a modificação concorrente. Muitas vezes não é necessário iterate ao adicionar / remover.

A orientação sobre o fornecimento de um simples invólucro de classe é sã, eu ia começar com algo parecido com o trecho de código abaixo protegendo os métodos que você realmente precisa de acesso simultâneo a e, em seguida, fornecendo acesso 'inseguro' para o std :: set de base para que as pessoas pode optar para os outros métodos que não são seguros. Se necessário, você pode proteger o acesso, assim como para a aquisição de iteradores e colocá-los de volta, mas isso é complicado (ainda menos do que escrever o seu próprio bloqueio conjunto gratuito ou o seu próprio conjunto totalmente sincronizado).

Eu trabalho na biblioteca de padrões paralela então estou usando CRITICAL_SECTION de VS2010 beta boost :: mutex funciona muito bem também e o padrão RAII de usar um lock_guard é quase necessário independentemente de como você optar por fazer isso:

template <class T>
class synchronized_set
{
    //boost::mutex is good here too
    critical_section cs;
public:
    typedef set<T> std_set_type;
    set<T> unsafe_set;
    bool try_insert(...)
    {
        //boost has a lock_guard
        lock_guard<critical_section> guard(cs);
    }
};

Answer 2

Porque não basta usar um mutex compartilhada para proteger o acesso simultâneo? Certifique-se de usar RAII para bloquear e desbloquear o mutex:

{
   Mutex::Lock lock(mutex);
   // std::set manipulation goes here
}

onde Mutex :: Lock é uma classe que bloqueia o mutex no construtor e destrava-lo no processo de destruição, e mutex é um objeto mutex que é compartilhado por todas as threads. Mutex é apenas uma classe de invólucro que esconde qualquer sistema operacional primitivo específico que você está usando.

Eu sempre pensei que a concorrência e comportamento conjunto são conceitos ortogonais, por isso é melhor tê-los em classes separadas. Em minhas experiências, classes que tentam ser thread-safe em si não são muito flexíveis ou tão útil.

Answer 3

Você não quer travamento interno, como seus invariantes muitas vezes vai exigir várias operações sobre a estrutura de dados e bloqueio interno só evita os passos acontecendo ao mesmo tempo, ao passo que você precisa para manter as etapas de diferentes macro-operações de intercalação.

Answer 4

Você também pode dar uma olhada na biblioteca ACE que tem todos os recipientes segmento seguro que você nunca pode precisar.

Answer 5

Tudo o que posso pensar é usar OpenMP para paralelização, derivar uma classe conjunto de DST e colocar um escudo em torno de cada operação de conjunto critial que declara que a operação crítica usando #pragma omp crítica.

Answer 6

classe QDefina do Qt usa compartilhamento implícito (cópia em semântica gravação) e métodos semelhantes com std :: set, você pode olhar para a sua implementação, Qt é LGPL.

Answer 7

Segmento de segurança e cópia na semântica de escrita não são a mesma coisa. Dito isto ...

Se você está realmente depois semântica copy-on-write Bibliotecas Fonte Adobe tem um copy_on_write modelo que adiciona essa semântica para o que você instanciar com ele.