Existem problemas / algoritmos famosos na computação científica que não podem ser acelerados pela paralelização

Existem problemas / algoritmos famosos na computação científica que não podem ser acelerados pela paralelização? Parece-me ao ler livros sobre CUDA que a maioria das coisas pode ser.

O problema central é o comprimento do caminho crítico em relação à quantidade total de computação T . Se C é proporcional a T , o paralelismo oferece, na melhor das hipóteses, uma aceleração constante. Se C é assintoticamente menor que T , há espaço para mais paralelismo à medida que o tamanho do problema aumenta. Para algoritmos nos quais T é polinomial no tamanho de entrada N , o melhor caso é C ∼ log T porque muito poucas quantidades úteis podem ser calculadas em menos que o tempo logarítmico.$C$$T$$C$$T$$C$$T$$T$$N$$C \sim \log T$

Exemplos

• para uma resolução tridiagonal usando o algoritmo padrão. Toda operação depende da conclusão da operação anterior, portanto não há oportunidade para paralelismo. Problemas tridiagonais podem ser resolvidos em tempo logarítmico em um computador paralelo usando uma solução direta de dissecação aninhada, decomposição de domínio multinível ou multigrid com funções básicas construídas usando extensão harmônica (esses três algoritmos são distintos em múltiplas dimensões, mas podem coincidir exatamente em 1D).$C = T$
• Um denso triangular inferior resolver com uma matriz tem T = N = O ( m 2 ) , mas o caminho crítico só é C = m = $m\times m$$T = N = \mathcal O(m^2)$ , então algum paralelismo pode ser benéfico.$C = m = \sqrt T$
• Multigrade e FMM ambos têm , com um caminho crítico de comprimento C = log T .$T = N$$C = \log T$
• Propagação da onda explícita para um tempo sobre uma malha regular do domínio ( 0 , 1 ) d requer k = τ / Δ t ~ τ N 1 / d passos de tempo (por estabilidade), por conseguinte, o caminho crítico é, pelo menos, C = k . A quantidade total de trabalho é T = k N = τ N ( d + 1 ) / d . O número máximo útil de processadores é P = $\tau$$(0,1)^d$$k = \tau / \Delta t \sim \tau N^{1/d}$$C = k$$T = k N = \tau N^{(d+1)/d}$ , o fator restante N 1 / d não pode ser recuperado pelo aumento do paralelismo.$P = T/C = N$$N^{1/d}$

Complexidade formal

A classe de complexidade NC caracteriza os problemas que podem ser resolvidos eficientemente em paralelo (isto é, em tempo polilogarítmico). Não se sabe se , mas a hipótese é amplamente falsa. Se esse for realmente o caso, o P-complete caracteriza os problemas que são "inerentemente sequenciais" e não podem ser acelerados significativamente pelo paralelismo.$NC = P$

Para dar um aspecto teórica para este, $NC$ é definida como a classe de complexidade que é solúvel em de tempo em um sistema com S ( n k ) processadores paralelos. Ainda não se sabe se P = N C (embora a maioria das pessoas suspeite que não esteja) onde P é o conjunto de problemas solucionáveis ​​no tempo polinomial. Os problemas "mais difíceis" a serem paralelizados são conhecidos como problemas completos de P no sentido de que todo problema em P pode ser reduzido a um problema completo de P via$O(log^c n)$$O(n^k)$$P=NC$$P$$P$$P$$P$Reduções de N C. Se você mostrar que um únicoproblema com P completo está em N C , você prova que P = N C (embora isso provavelmente seja falso como mencionado acima).$NC$$P$$NC$$P=NC$

Portanto, qualquer problema que seja completo seria intuitivamente difícil de paralelizar (embora ainda sejam possíveis grandes acelerações). Um problema completo de P para o qual não temos acelerações de fator constante muito boas é a Programação Linear (veja este comentário na troca OR).$P$$P$

Comece grocking Lei de Amdahl . Basicamente, qualquer coisa com um grande número de etapas seriais se beneficiará de forma insignificante do paralelismo. Alguns exemplos incluem análise, regex e a maior compactação de alta taxa.

Além disso, o principal problema geralmente é um gargalo na largura de banda da memória. Em particular na maioria das GPUs, seus flops teóricos superam amplamente a quantidade de números de ponto flutuante que você pode obter nas ALU, pois algoritmos com baixa intensidade aritmética (flops / cache-miss) gastam a maior parte do tempo esperando na RAM.

Por fim, sempre que um pedaço de código exigir ramificação, é improvável que ele tenha um bom desempenho, pois a ALU geralmente supera a lógica.

Em conclusão, um exemplo realmente simples de algo que seria difícil obter um ganho de velocidade de uma GPU é simplesmente contar o número de zeros em uma matriz de números inteiros, pois você pode precisar ramificar frequentemente, no máximo, executar uma operação (incremento por um) caso encontre um zero e faça pelo menos uma busca de memória por operação.

Um exemplo livre do problema de ramificação é calcular um vetor que é a soma cumulativa de outro vetor. ([1,2,1] -> [1,3,4])

Não sei se isso conta como "famoso", mas certamente há um grande número de problemas com os quais a computação paralela não o ajudará.

O método (famoso) de marcha rápida para resolver a equação de Eikonal não pode ser acelerado pela paralelização. Existem outros métodos (por exemplo, métodos de varredura rápida) para resolver a equação Eikonal que são mais passíveis de paralelização, mas mesmo aqui o potencial para aceleração (paralela) é limitado.

O problema com a equação de Eikonal é que o fluxo de informações depende da própria solução. Em termos gerais, a informação flui ao longo das características (isto é, raios de luz na óptica), mas as características dependem da própria solução. E o fluxo de informações para a equação Eikonal discretizada é ainda pior, exigindo aproximações adicionais (como implicitamente presentes em métodos de varredura rápida) se qualquer aceleração paralela for desejada.

Para ver as dificuldades da paralelização, imagine um belo labirinto como em alguns exemplos na página de Sethian . O número de células no caminho mais curto através do labirinto (provavelmente) é um limite inferior para o número mínimo de etapas / iterações de qualquer algoritmo (paralelo) que resolve o problema correspondente.

(Eu escrevo "(provavelmente) é", porque limites mais baixos são notoriamente difíceis de provar e geralmente exigem algumas suposições razoáveis ​​sobre as operações usadas por um algoritmo).

Outra classe de problemas difíceis de paralelizar na prática são os problemas sensíveis a erros de arredondamento, em que a estabilidade numérica é alcançada pela serialização.

Considere, por exemplo, o processo de Gram-Schmidt e sua modificação serial. O algoritmo funciona com vetores, portanto, você pode usar operações com vetores paralelos, mas isso não é escalável. Se o número de vetores for grande e o tamanho do vetor for pequeno, o uso de Gram-Schmidt clássico paralelo e a re-regionalização pode ser estável e mais rápido que o Gram-Schmidt modificado único, embora isso envolva fazer várias vezes mais trabalho.