E ae pessoas, beleza?
Nosso grupo está com um problema na hora de paralelizar...
A gente está precisando criar um array dentro da função global que resolve o problema para que as threads não usem o mesmo array sempre. Tentando esclarecer mais, temos um int *tab que é mandado pra função __global__ resolve. Esse array é o tabuleiro das rainhas, e é atualizado quando uma rainha é colocada na posição n. Mas quando paralelizado, as threads usam ele ao mesmo tempo. Gostaria de criar um tab para cada thread, pra não melar. hehhehe
Quem souber responder ficaria grato.
Obrigado.
Poxa, estou me sentindo um desertor, mas vamos lá, pelo bem de todos e do aprendizado :P
É melhor você criar um vetor com <THREAD NUMBER> posições e cada thread escreve na sua própria posição do vetor.
É este o esquema que os exemplos aplicam.
Bom, isso que você falou é bem simples e acho que óbvio. Mas estou tratando de um tabuleiro.
Vou falar meu código pra explicar melhor:
int main(){
/* mallocs */
resolve<<<numBlocks,numThreads>>>(int N, int *tab, int *last);
}
dentro de resolve(), cada thread vai mexer apenas nesse *tab. Na minha paralelização(WTF?), a thread 0 vai começar a por uma rainha na coluna 0 da linha 0, a thread 1 vai começar a por uma rainha na coluna 1 da linha 0 e assim por diante. Mas a thread 0, nunca tenta colocar uma rainha na coluna 1 na linha 0, por isso é o que eu quero que a outra thread faça.
Pois bem, na teoria isso é muito lindo. Mas quando chamo a função, e as threads usam a mesma *tab, eles escrevem um em cima do outro e mela tudo. Por exemplo, a linha 0 da thread 0 fica assim num tabuleiro 4x4:
1 0 0 0 -> colocou na coluna 0
0 0 0 0
0 0 0 0
0 0 0 0
linha 0 da thread 1 fica:
1 1 0 0 -> colocou na coluna 1, mas a thread 0, tb colocou na coluna 0.
0 0 0 0
0 0 0 0
0 0 0 0
linha 0 da thread 2 fica:
1 1 1 0 -> colocou na coluna 2, mas a thread 0 e 1 também colocoram nas suas.
0 0 0 0
0 0 0 0
0 0 0 0
Então, eu queria criar um tabuleiro para cada thread. Acho que agora a gente explicou direitinho :> O Hugo é do meu grupo!
Vou falar meu código pra explicar melhor:
int main(){
/* mallocs */
resolve<<<numBlocks,numThreads>>>(int N, int *tab, int *last);
}
dentro de resolve(), cada thread vai mexer apenas nesse *tab. Na minha paralelização(WTF?), a thread 0 vai começar a por uma rainha na coluna 0 da linha 0, a thread 1 vai começar a por uma rainha na coluna 1 da linha 0 e assim por diante. Mas a thread 0, nunca tenta colocar uma rainha na coluna 1 na linha 0, por isso é o que eu quero que a outra thread faça.
Pois bem, na teoria isso é muito lindo. Mas quando chamo a função, e as threads usam a mesma *tab, eles escrevem um em cima do outro e mela tudo. Por exemplo, a linha 0 da thread 0 fica assim num tabuleiro 4x4:
1 0 0 0 -> colocou na coluna 0
0 0 0 0
0 0 0 0
0 0 0 0
linha 0 da thread 1 fica:
1 1 0 0 -> colocou na coluna 1, mas a thread 0, tb colocou na coluna 0.
0 0 0 0
0 0 0 0
0 0 0 0
linha 0 da thread 2 fica:
1 1 1 0 -> colocou na coluna 2, mas a thread 0 e 1 também colocoram nas suas.
0 0 0 0
0 0 0 0
0 0 0 0
Então, eu queria criar um tabuleiro para cada thread. Acho que agora a gente explicou direitinho :> O Hugo é do meu grupo!
A minha dica é: ao invés de um int * tab, crie uma struct chamada tabuleiro que contenha várias posições, e dê para cada thread uma posição, ou seja, um tabuleiro diferente =)
Foi o que eu quis dizer na primeira resposta, mas acho que não fui muito claro =P
Mas isso não pode ficar absurdamente grande ? A gente pensou nisso mas descartou na hora que vimos quantas soluções tem um tabuleiro de 20 uaehuehueh
Mais ou menos, pois vc pretende armazenar a resposta neste tabuleiro? Pelo que eu entendi do seu programa, ele apenas será utilizado para calcular a resposta em cada thread, assim sendo, não é tão grande, porém, se for pra armazenar todos os resultados, a coisa fica grande sim, aí é problema!
Infelizmente, não sei como dar a solução pro espaço ainda :P
Como não dá para imprimir dentro de uma função global, esse tabuleiro armazena a resposta e depois volta pra main para ser impresso. Não existe nenhum jeito, na minha cabeça, de usar 1 tabuleiro só com diversas threads, pq todas usam o mesmo tab.
Todos os exemplos (mais simples) que vi na pasta do CUDA, o global recebe arrays e matrices constantes e ele retorna um resultado. Não vi nenhum desses exemplos retornando uma coisa que veio da main, foi modificada na funcao global, e depois voltou na main. No forum do CUDA, tem um N-Queens Solver que resolve mas apenas mostra a quantidade de soluções. Isso é bem fácil de fazer. Mas retornar o tabuleiro pro host e imprimir é o problema que não temos a menor idéia de como resolver.
Todos os exemplos (mais simples) que vi na pasta do CUDA, o global recebe arrays e matrices constantes e ele retorna um resultado. Não vi nenhum desses exemplos retornando uma coisa que veio da main, foi modificada na funcao global, e depois voltou na main. No forum do CUDA, tem um N-Queens Solver que resolve mas apenas mostra a quantidade de soluções. Isso é bem fácil de fazer. Mas retornar o tabuleiro pro host e imprimir é o problema que não temos a menor idéia de como resolver.
Tenta olhar aqui:
http://forums.nvidia.com/index.php?showtopic=78429&st=0&p=445325&#entry445325
Aparentemente é uma discussão sobre esse assunto.
http://forums.nvidia.com/index.php?showtopic=78429&st=0&p=445325&#entry445325
Aparentemente é uma discussão sobre esse assunto.
O número de soluções é enorme mesmo. Por outro lado, o número de threads que vocês criam (e portanto de memória que vocês alocam) é controlável. Aí o problema é conseguir criar um buffer que será consumido pela CPU para escrever os resultados.