Como testar e comparar implementações mutex

Como o título diz: Como você testa e compara adequadamente diferentes implementações de mutexes em c ++?

Essencialmente, eu escrevi minha própria classe std :: mutex like para um projeto rodando em um núcleo 2, armv7, com o objetivo de minimizar a sobrecarga no caso não contestado. Agora, estou pensando em usar o referido mutex em mais lugares e também em arquiteturas diferentes, mas antes de fazer isso, gostaria de garantir que

• está realmente correto
• não há nenhum caso patológico em que ele tenha um desempenho muito pior do que um std :: mutex padrão.

Obviamente, escrevi alguns testes de unidade básicos e micro-benchmarks e tudo parece funcionar, mas no código multiencadeado "parece funcionar" não me dá grande conforto.

• Então, existem técnicas de análise estática ou dinâmica estabelecidas?
• Quais são as armadilhas comuns ao escrever testes de unidade para classes mutex?
• Quais são os casos típicos que devemos observar (em termos de desempenho)?

Só estou usando tipos de biblioteca padrão para a implementação, que inclui operações de carregamento e armazenamento não-consistentes e consistentes em atômicas. No entanto, estou interessado principalmente em conselhos agnósticos de implementação, pois também gostaria de usar o mesmo equipamento de teste para outras implementações.

A questão é complexa:

Algumas fontes de complexidade incluem:

• Quantas alternâncias de contexto estão ocorrendo: isso é muito importante, dependendo da plataforma em que esses testes são executados. Algumas plataformas lidam com isso melhor do que outras
• São as funções em que os mutexes são testados de forma embutida ou não. ou seja, o mutex tem bom desempenho apenas em códigos bem otimizados ou otimizáveis.
• Esses mutexes são projetados para a localidade do cache. As falhas no cache reduzem significativamente o desempenho ou causam mais alternâncias de contexto. antes e depois da inserção do mutex.
• O próprio mutex causará perda da localidade do cache. ou seja, os dados do estado mutex são alocados dinamicamente.
• Esses mutexes terão bom desempenho onde as alternâncias de contexto estiverem contidas no mutex. ie io, malloc etc.
• O mutex terá bom desempenho se o tempo do kernel estiver contido na alocação e desalocação de memória dinâmica mutex.ie.
• O desempenho é mantido quando executado nas VMs
• A destruição ou construção do mutex é cara, ou seja, os dados do estado estão localizados na memória dinâmica

Sua ideia é muito interessante: uma referência de conformidade contra a qual uma implementação mutex poderia ser testada.

Infelizmente, até onde pude ver, não há um padrão de conformidade amplamente conhecido para implementações de mutex. Então, acho que você tem em suas mãos o problema muito interessante de criar uma proposta para esse benchmark de conformidade.

E, desde que você se envolveu na criação de uma implementação de benchmark, você é o cara.

Se você me der uma sugestão, talvez possa começar esta pesquisa com o padrão POSIX para encadeamentos de um lado e com algum estudo da literatura teórica do processamento simultâneo, como CSP ou Communicating Sequential Processes. Esse tipo de artigo geralmente lida com os problemas concorrentes clássicos, como os Filósofos do Jantar.

Uma implementação deles pode ser uma parte interessante do seu benchmark de conformidade, eu acho.