A maneira mais rápida de encontrar pares automáticos de uma pequena matriz não simétrica em uma GPU na memória compartilhada

Eu tenho um problema em que preciso encontrar todos os pares de autovalores positivos (como o valor próprio é positivo) de uma matriz não simétrica pequena (geralmente menor que 60x60). Posso parar de calcular quando o valor próprio é menor que um determinado limite. Eu sei que os autovalores são reais. Alguma sugestão sobre algoritmos que eu poderia usar para tentar extrair o melhor desempenho? Eu tenho que fazer vários milhares dessas decomposições, então a velocidade é importante.

Agradeço antecipadamente.

EDIT: Eu preciso fazer isso na GPU na memória compartilhada. As matrizes também não são necessariamente do mesmo tamanho. Não conheço nenhuma biblioteca que faça isso no momento. Sugestões de algoritmos que seriam bem adequados ao problema seriam apreciadas.

performance eigensystem gpu

— Kantoku
fonte

Se eu entendi direito, você tem um kernel CUDA que calcula milhares de matrizes pequenas na memória compartilhada e não deseja copiá-las para a memória global. Antes de tentar responder, há alguns pontos a serem esclarecidos. No CUDA, a vida útil da memória compartilhada é obrigada a bloquear a vida útil: quantos threads você tem para cada matriz decompor? O desempenho extremo é realmente importante? (Como os tempos de extração esperados de valor próprio se comparam aos tempos de geração da matriz?) Com base em que argumento você sabe que o sistema próprio é real? O sistema eletrônico pode estar com defeito?

— Stefano M

Olá Stefano e obrigado pelo seu comentário. Por enquanto, terei o múltiplo mais próximo do tamanho da urdidura para a dimensão da matriz que gostaria de decompor. Os tempos de geração de matrizes variam muito e há casos em que o tempo de geração de matrizes é mais caro, mas há muitas situações em que o tempo de geração de matrizes é menor que a decomposição. Eu sei que os autovalores são reais por causa da maneira como a matriz é gerada. Prefiro não entrar em detalhes aqui, pois isso prejudicaria a pergunta original. Finalmente, sim, o sistema pode estar com defeito.

— Kantoku 02/09/12

Respostas:

Sem fazer muita pesquisa, recomendo que você analise a biblioteca MAGMA . Código disponível gratuitamente com suporte contínuo. A NVIDIA reconheceu o MAGMA como "Um avanço em solventes para problemas de autovalor".

Há também a biblioteca CULA , que geralmente é um produto comercial, embora recentemente tenha sido disponibilizado gratuitamente para uso acadêmico (veja detalhes aqui ).

— Alexander
fonte

Obrigado pela sua resposta Alexander. Examinei as duas bibliotecas antes e, até onde sei, as funções são chamadas do host e a memória precisa estar na memória global. Acredito que a sobrecarga seria demais para justificar o uso. Todas essas matrizes são geradas na memória compartilhada, usadas no kernel e depois descartadas. Eu gostaria de mantê-los lá sem precisar colocá-los de volta na memória global. Mesmo se eu os enviasse lá, ainda haveria o problema de chamar muitas funções do kernel do host (embora em vários fluxos).

— Kantoku

@ Kantoku, sim, essas bibliotecas são mais gerais e armazenam toda a matriz na memória global. Se suas matrizes estão na memória compartilhada, apenas um SM pode trabalhar nelas, não é? A implementação do EVD, portanto, deve ser bastante direta.

— Alexander

Sim, eu imagino que sim, e é por isso que eu estava buscando algoritmos que seriam apropriados para a situação. Eu não estou muito familiarizado com evd não simétrico, então estava procurando sugestões.

— Kantoku

@ Kantoku (e Alexander). EVD não simétricos estão longe de ser diretos, mesmo no caso seqüencial. Ainda é uma área ativa de pesquisa.

— Jack Poulson

@JackPoulson Ah, sim, você está certo, mas eu (e também presumo que Alexander) quis dizer que seria fácil aplicar um algoritmo estabelecido ao problema, considerando que existem muitas simplificações que podem ser feitas quando consideramos o tamanho e a natureza da matriz em consideração. O problema é: qual algoritmo.

— Kantoku

Use as funções no LAPACK, é improvável que você possa vencê-las em sua própria implementação.

— Wolfgang Bangerth
fonte

Oi Wolfgang. Obrigado pela resposta, mas pretendo implementar isso em uma GPU usando CUDA e por vários milhares dessas pequenas matrizes (onde cada bloco lida com a decomposição de uma única matriz), e as matrizes não são necessariamente do mesmo tamanho, portanto, implementando algo que usa memória compartilhada parece ser minha única opção. Alguma idéia de qual algoritmo seria mais adequado para esses tipos de matrizes? PS: Obrigado pelo acordo. II palestras que você deu na KAUST no semestre passado. Eu gostava deles :)

— Kantoku

@ Kantoku Você deve adicionar esses detalhes em sua pergunta, caso contrário, é enganador.

— Alexander Alexander

@ Alexander Atualizei a pergunta com mais detalhes. Obrigado pela sugestão!

— Kantoku

@ Kantoku: As GPUs estão um pouco além do meu domínio, mas tenho certeza de que já existem bibliotecas que fazem o que você deseja (e, de fato, vejo que outras respostas já estão relacionadas a elas). Fico feliz em saber que você gostou das minhas aulas!

— Wolfgang Bangerth