O dia em que (sem querer) acabei ensinando para minha mãe alguns conceitos da programação paralela.

O título pode soar um pouco estranho, mas essa foi uma situação cômica que aconteceu comigo recentemente. Lendo o livro Sistemas Operacionais Modernos, do grande Andrew Tanenbaum, acabei relembrando dessa história que, de certa forma, me ajudou a fixar melhor os conceitos que tenho visto durante as aulas de Programação Paralela.

Contextualizando: aqui em casa temos o costume de encher alguns garrafões d’água. É uma tarefa tediosa que realizamos de tempos em tempos e que normalmente nos proporciona bastante tempo ocioso. Esses garrafões, de acordo com as minhas medições, possuem 20 L e, em média, levam 4 minutos para ficarem completamente cheios. Normalmente os enchemos um por um (esses 4 minutos se tornam uma eternidade quando não se faz nada). Nesse dia em específico, havia duas torneiras livres e sugeri que deveríamos dividir a tarefa. No entanto, minha mãe inicialmente recusou, afirmando que isso demoraria mais do que de costume. Essa afirmação tinha certo embasamento, já que o fluxo de água diminuía perceptivelmente quando duas torneiras estavam ligadas. Mesmo assim, eu a contrariei e apostei com ela que seria muito mais rápido encher ambos os garrafões ao mesmo tempo. Dito e feito: ambos foram preenchidos juntos. Ela ficou surpresa ao ver isso, e eu comemorei bastante, aproveitando a situação para explicar alguns conceitos teóricos.

Quando estudamos os conceitos da programação paralela, um dos primeiros tópicos abordados é o da concorrência e paralelismo. Entender esse conceito muda nossa visão sobre o software, pois é preciso “visualizar” onde e como o paralelismo pode ser implementado. Pegando a situação acima: se os garrafões fossem enchidos sequencialmente, seriam necessários 8 minutos, além do tempo em “inatividade” que poderia ser aproveitado. Quando implementamos o paralelismo de alguma forma, o ganho de tempo e produtividade é perceptível — mesmo que, à primeira vista, pareça que estamos perdendo desempenho.

Pegue, por exemplo, um gerenciador de pacotes. Eu gosto de utilizar o pacman. Por padrão, o pacman costuma manter o download de pacotes em paralelo desativado. Isso foi algo que demorei para perceber, e por muito tempo fiquei me perguntando por que os downloads estavam tão lentos, mesmo com uma internet relativamente rápida. Ao “descomentar” a linha #Parallel Downloads e permitir que 10 pacotes sejam baixados em paralelo, é visível o ganho de tempo: do mais leve ao mais pesado, todos os pacotes são baixados simultaneamente. Entretanto, é preciso saber dimensionar os recursos; caso contrário, é certo que haverá uma perda de desempenho.

Com esses exemplos, é possível perceber que o paralelismo está em todos os lugares — desde os garrafões, passando pelos sistemas operacionais, até os gerenciadores de pacotes. Aplicar esse tipo de programação em nossos projetos é uma tarefa complexa, que requer muito entendimento para que os ganhos sejam visíveis.

Sei que, com essa explicação, ainda faltou abordar conceitos como concorrência e linhas de execução. No entanto, para fins didáticos, vamos encerrar por aqui. Programação Paralela tem sido uma das matérias mais desafiadoras — e ao mesmo tempo fascinantes — da faculdade, e espero que, com essa história, certos conceitos tenham ficado um pouco mais fáceis de compreender. Recomendo mais uma vez a leitura do livro Sistemas Operacionais Modernos: lá estão todas as definições precisas e certamente muito mais bem escritas do que este breve relato.

Até breve, abraços :)