Pergunta

Eu estive implementando esta pequena ideia de jogo, que é (de alguma forma?) Semelhante ao jogo de vida do Conway:

0) Você tem uma matriz de pontos coloridos (valores de RGB) 1) Se a célula adjacente tiver um valor X inferior do que você, colocar Y= 0 nessa célula (Onde x e y são vermelhos || verde || azul) 2) Red Beats Green Beats Blue Beats Vermelho

O que estou fazendo agora é só ir celular por célula, verificando se as regras acima são atendidas.No entanto, o comportamento não é bem o que eu pretendia, já que às vezes as células nas primeiras linhas têm vantagem sobre as linhas finais.

Multithreading impede isso (digamos, lançando dois segmentos, um iniciando na primeira célula e outro no último)?Por favor, perdoe minha ignorância na concorrência, mas eu senti que isso era uma boa maneira de começar a trabalhar com ele.

Foi útil?

Solução

Meu palpite é que você está atualizando o Matrix Inplace, enquanto que você deve copiar manter uma faixa do antigo estado da matriz, atualizando um novo, substituindo o original pelo atualizado. Dessa forma, você não atualizará algumas células, então na próxima linha testar seus valores. Assim, seria um problema de algoritmo, não relacionado com a programação (e, portanto, multithreading não pode ajudar).

Outras dicas

não.Seu problema é uma falha inerente.O problema que você tem é que você está usando resultados intermediários, isto é, a mudança em uma célula afeta a próxima célula imediatamente, nesta atualização.Não deveria.Você deve criar uma nova matriz, armazenar os valores alterados lá e troque-os para que os novos valores sejam carregados.Repita.

Você será melhor adaptar seu algoritmo para evitar isso.

Confiando em multithreading para mudar o comportamento não é uma coisa boa.Isto é, em essência, tentando introduzir uma condição de corrida em seu código.Normalmente, ao adicionar multi-threading a um algoritmo, a primeira prioridade é impedir qualquer alteração no comportamento.

Ao tentar usar uma condição de corrida para mudar o comportamento, você está tornando isso muito não determinístico, mas não de uma maneira.Você seria muito melhor tentar criar uma solução diferente para isso (potencialmente usando um gerador de números pseudo-aleatórios, etc) e, em seguida, introduzindo multi-threading para torná-lo mais rápido (esperançosamente sem afetar os resultados).

.

Depende de que parte do processamento você escolhe para multithread. O prototípico Exemplo multithreading é o multiplicador de matriz. Você pode basicamente quebrar em quadrantes e calcular um quadrante em cada linha, sem compartilhamento de informações, exceto a matriz original. Observe que o jogo da vida é uma matriz esparsa, no entanto, e pode ou não beneficiar de multithreading.

No entanto, se você decidir fazê-lo, tenha em mente que tudo deve calcular o que ele precisa para o "próximo turno" e coloque-o em uma nova matriz, quando trocar a matriz (preferencialmente não copiar, basta mudar um ponteiro em algum lugar) no final do turno, para que um thread não esteja alterando os valores que os outros precisam fazer seus cálculos. Então o thread não pode ser permitido "obter uma vez à frente" de cada outro. Isso pode significar que é ineficiente para fazer com vários segmentos - sua milhagem pode variar.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top