Exclusão mútua entre todos os encadeamentos e processos do Linux [closed]

Question

Estou tentando escrever um código que não deveria ser executado simultaneamente nem por threads do mesmo processo, nem por processos diferentes. Em outras palavras, eu preciso que o mecanismo de sincronização global garanta exclusão mútua absoluta no GNU / Linux.

Quais estratégias eu tentei até agora:

1. Mutexes simples ( std::mutex , mutexes pthread, etc.). O problema é que essas primitivas fornecem sincronização apenas entre os threads dentro de um processo, não diferentes.
2. Bloqueios de arquivos ( lockf , fcntl ). De acordo com o homem, eles fornecem bloqueio entre diferentes processos, mas os threads de um processo herdam o bloqueio e não podem ser sincronizados. De qualquer forma eu tentei, não me ajudou.
3. POSIX no nível do kernel com nome de semáforos ( sem_open , sem_wait , sem_post ), usando-os com o valor init 1 como exclusões mútuas. Parece sincronizado ambos os casos com sucesso, mas o problema é - se o processo foi morto enquanto segura o semáforo, o semáforo se torna ainda vivo porque tem persistência no kernel. Como resultado, quando o processo é reiniciar está esperando pelo sem sempre.
4. Eu li sobre bloqueios de descrição de arquivos abertos ( F_OFD_SETLK ...) desde a minha última tentativa. Parece que eles poderiam me ajudar (eu não entendê-lo completamente). Mas eles estão disponíveis desde o kernel v.3.15, e eu preciso construir minhas fontes para o kernel v. 3.10.
5. Também tentei combinar exclusões mútuas simples para obter sincronização por thread com bloqueios de arquivo para obter um processo por processo sincronização. Por razões desconhecidas - não funciona (não deadlocks ou algo parecido ocorreu - só não pode sincronizar completamente e o código parece ser executado simultaneamente).

Então a questão é: que abordagem será relevante para essa tarefa? Devo continuar tentando combinar diferentes combinações primitivas diferentes ou usar qualquer outro - estou preso e não tenho idéias o que fazer a seguir.

P.S. A razão pela qual eu não postei nenhum exemplo de código - não faz sentido aqui (e também devido ao NDA). Em poucas palavras - é um bug (causando SIGSEGV) em um produto grande que inclui vários threads e processos, muitas vezes chamando alguns métodos de tempo de execução CUDA simultaneamente.

Sim, é absolutamente um problema relacionado ao CUDA - mas descobrimos que restringir a execução paralela pode ser uma solução temporária para isso. Como eu disse, o problema está em organizar exclusão mútua global e segura para encadeamentos e processos.