A festa seqüencial acabou

Dia desses montei uma máquina nova para mim. Ela tem um desses processadores pomposos de núcleo duplo que já deixaram de ser os artigos de luxo que eram há alguns anos. Minha máquina anterior tem um processador de núcleo simples da época em que os de núcleo duplo tinham preços proibitivos. Este núcleo solitário trabalha a uma freqüência de 1.8GHz enquanto os dois núcleos da máquina nova rodam a 2.2GHz. Acho que a diferença é suficientemente pequena para que possamos dizer que a freqüência é mais ou menos a mesma. Os ganhos de performance, portanto, devem ser proporcionados principalmente pela presença dos dois núcleos e não do aumento de freqüência.

Porém a máquina nova não parece ser muito mais rápida que a antiga. Obviamente ela se sai muito melhor que a anterior quando há vários processos rodando ao mesmo tempo. Mas quando preciso que ela execute um programa único, a performance é mais ou menos a mesma. Por um lado, é verdade que o gargalo da maioria das aplicações realmente não está no processador nem na memória, mas nos dispositivos de entrada e saída como rede e disco. Para estas aplicações é de se esperar que um aumento da capacidade de processamento não faça grande diferença. Por outro lado, esta máquina nova não parece mais rápida nem para atividades com uso intenso do processador.

Utilização de CPUEm nome da boa e velha curiosidade, resolvi fazer um teste rápido. Peguei um dos meus CDs de música e coloquei a máquina para compactar uma amostra razoável de áudio. Compactação de áudio (e vídeo) é uma daquelas tarefas ridiculamente paralelizáveis. Uma forma bastante óbvia de aproveitar melhor o hardware seria deixar que cada um dos processadores ficasse responsável pela compactação de metade do trecho de áudio. Apesar disso, quando estava compactando o áudio, observei que apenas um dos núcleos fica em uso em um dado momento. De vez em quando o processamento é transferido de um núcleo para outro, mas apenas um é usado efetivamente.

Quando há vários processos diferentes brigando por um pouco de tempo de processador, os sistemas operacionais modernos são bastante espertos para distribuírem a carga inteligentemente. O problema acontece quando há um programa que demanda muito do processador mas não está preparado para ser quebrado em partes menores e executado em paralelo. Se ele não usa nenhum mecanismo para identificar os trechos de código que podem ser executados lado a lado, o máximo que o sistema operacional pode fazer é enxergá-lo como um grande amontoado de instruções a serem executadas uma após a outra. Chegamos a um ponto em que os sistemas operacionais estão prontos e o hardware também está pronto, só faltam as aplicações.

Máquinas com múltiplos processadores já são realidade há um bom tempo e o uso de vários núcleos por chip não é tão novo assim, mas este tipo de tecnologia estava limitado a certos nichos. A preocupação em utilizar o poder de vários processadores operando em paralelo só começa a se popularizar agora que a festa seqüencial acabou. Antes não fazia muito sentido dar-se ao trabalho de escrever programas paralelizáveis porque era possível fazê-los executar de forma mais rápida simplesmente enfiando mais alguns megahertz nos processadores. Porém agora o limite da freqüência, e principalmente da dissipação do calor associado, parece ter sido atingido e, por mais que esperemos, não vai dar mais para comprar processadores que operem a freqüências muito maiores que as atuais.

Meu palpite é que, de agora em diante, quem precisar melhorar a performance de suas aplicações utilizando todo o hardware disponível (o que não se aplica a todo mundo, afinal a “otimização prematura é a raiz de todo o mal”) vai precisar escrever programas paralelos. Na verdade, eu acho que as pessoas já estariam escrevendo programas paralelos há muito tempo se fosse mais fácil. Só que os ambientes para desenvolvimento mais populares de hoje não são muito amigáveis para este tipo de programa. As plataformas mais usadas ainda fazem uso de alguns conceitos que se mostraram bem difíceis de digerir, como threads e semáforos.

Isso quer dizer que precisamos descobrir novos modelos de pensamento se quisermos trabalhar com código concorrente e paralelo. Se você me permitir outro palpite, posso arriscar dizer que os modelos mais eficientes do futuro não vão ser tão seqüenciais quanto os atuais.

3 Responses to “A festa seqüencial acabou”


  1. 1 Andre Furtado 03/jul/2007 às 15\0355

    Tendência forte sim, linguagens (e pessoas) precisarão rever seus conceitos! Exemplo: saber programar para os três processadores do Xbox 360 pode fazer toda a diferença na hora de criar um jogo.

    []s
    — AFurtado

  2. 2 Juan Maiz 11/jul/2007 às 14\0251

    Já viu a linguagem Io e seus atores para concorrência?
    iolanguage.com

  3. 3 kevorkian 26/ago/2007 às 02\0237

    Não percebeu diferença? Na boa, isto só acontece quando você usa uma placa-mãe de baixo custo (coisa comum em PCs com preços não “proibitivos”). Ela suporta o processador, mas seus chipsets costumam ser antigos e não dão suporte “full” às frequências do Core 2 duo. Tem chipsets novos por aí (Sis por exemplo) que fazem a máquina ser mais lentas do que Pentiuns 4. Qual o chipset do seu PC?


Comments are currently closed.




%d blogueiros gostam disto: