Demonstração de coleta de lixo mais rápida que o gerenciamento manual de memória

Eu li em muitos lugares (diabos, eu mesmo escrevi) que a coleta de lixo pode (teoricamente) ser mais rápida que o gerenciamento manual de memória.

No entanto, mostrar é muito mais difícil de encontrar do que dizer.
Na verdade, nunca vi nenhum código que demonstre esse efeito em ação.

Alguém tem (ou sabe onde posso encontrar) código que demonstra essa vantagem de desempenho?

Veja http://blogs.msdn.com/b/ricom/archive/2005/05/10/416151.aspx e siga todos os links para ver Rico Mariani x Raymond Chen (ambos programadores muito competentes da Microsoft). . Raymond melhoraria o não gerenciado, Rico responderia otimizando a mesma coisa nos gerenciados.

Com um esforço de otimização praticamente zero, as versões gerenciadas começaram muitas vezes mais rápido que o manual. Eventualmente, o manual superou o gerenciado, mas apenas otimizando para um nível que a maioria dos programadores não gostaria de ir. Em todas as versões, o uso de memória do manual foi significativamente melhor que o gerenciado.

A regra geral é que não há almoços grátis.

O GC elimina a dor de cabeça do gerenciamento manual de memória e reduz a probabilidade de cometer erros. Existem algumas situações em que uma estratégia específica de GC é a solução ideal para o problema. Nesse caso, você não pagará nenhuma penalidade por usá-la. Mas há outros onde outras soluções serão mais rápidas. Como você sempre pode simular abstrações mais altas de um nível mais baixo, mas não o contrário, pode provar efetivamente que não há como abstrações mais altas serem mais rápidas do que as mais baixas no caso geral.

O GC é um caso especial de gerenciamento manual de memória

Pode ser muito trabalhoso ou mais propenso a erros para obter melhor desempenho manualmente, mas essa é uma história diferente.

É fácil construir uma situação artificial em que o GC é infinitamente mais eficiente que os métodos manuais - basta organizar que haja apenas uma "raiz" para o coletor de lixo e que tudo seja lixo, para que a etapa do GC seja concluída instantaneamente.

Se você pensar bem, esse é o modelo usado ao coletar a memória alocada para um processo. O processo morre, tudo que é memória é lixo, terminamos. Mesmo em termos práticos, um processo que inicia, executa e morre sem deixar rastro pode ser mais eficiente do que aquele que inicia e executa para sempre.

Para programas práticos, escritos em idiomas com coleta de lixo, a vantagem da coleta de lixo não é a velocidade, mas a correção e a simplicidade.

Deve-se considerar que o GC não é apenas uma estratégia de gerenciamento de memória; também exige todo o design do ambiente de linguagem e tempo de execução, que impõe custos (e benefícios). Por exemplo, uma linguagem que suporte o GC deve ser compilada de forma que os ponteiros não possam ser ocultados do coletor de lixo e geralmente onde não possam ser construídos, exceto por primitivas do sistema cuidadosamente gerenciadas. Outra consideração é a dificuldade de manter as garantias de tempo de resposta, pois o GC impõe algumas etapas que precisam ser executadas até a conclusão.

Conseqüentemente, se você tiver um idioma que é coletado de lixo e comparar a velocidade com a memória gerenciada manualmente no mesmo sistema, ainda precisará pagar a sobrecarga para oferecer suporte à coleta de lixo, mesmo que não esteja sendo usado.

Mais rápido é duvidoso. No entanto, pode ser ultra-rápido, imperceptível ou mais rápido se for suportado por hardware. Havia projetos como esse para máquinas LISP há muito tempo. Um deles incorporou o GC no subsistema de memória do hardware, de modo que a CPU principal não sabia que estava lá. Como muitos projetos posteriores, o GC funcionava simultaneamente com o processador principal, com pouca ou nenhuma necessidade de pausas. Um design mais moderno são as máquinas Azul Systems Vega 3 que executam o código Java muito mais rápido do que a JVM, usando processadores criados especificamente para uso e um GC sem pausa. Pesquise no Google se quiser saber a rapidez com que o GC (ou Java) pode ser.

Eu trabalhei bastante nisso e descrevi algumas delas aqui . Comparei o Boehm GC em C ++, alocando usando, mallocmas não liberando, alocando e liberando usando freee um GC de região de marca personalizado, escrito em C ++ all vs o GC de estoque da OCaml, executando um solucionador de n-rainhas baseado em lista. O GC do OCaml foi mais rápido em todos os casos. Os programas C ++ e OCaml foram escritos deliberadamente para executar as mesmas alocações na mesma ordem.

Obviamente, você pode reescrever os programas para resolver o problema usando apenas números inteiros de 64 bits e sem alocações. Embora mais rápido que isso derrotasse o objetivo do exercício (que era prever o desempenho de um novo algoritmo de GC, eu estava trabalhando usando um protótipo construído em C ++).

Passei muitos anos na indústria portando código C ++ real para idiomas gerenciados. Em quase todos os casos, observei melhorias substanciais no desempenho, muitas das quais provavelmente devido ao GC superando o gerenciamento manual de memória. A limitação prática não é o que pode ser alcançado em uma marca de microbench, mas o que pode ser realizado antes de um prazo e as linguagens baseadas em GC oferecem melhorias de produtividade tão grandes que eu nunca olhei para trás. Eu ainda uso C e C ++ em dispositivos incorporados (microcontroladores), mas mesmo isso está mudando agora.

Esse exemplo necessariamente tem um esquema de alocação manual de memória ruim.

Suponha o melhor coletor de lixo GC. Possui internamente métodos para alocar memória, determinar qual memória pode ser liberada e métodos para finalmente liberá-la. Juntos, eles levam menos tempo do que todos GC; algum tempo é gasto nos outros métodos do GC.

Agora considere um alocador manual que use o mesmo mecanismo de alocação que GCe cuja free()chamada apenas reserve a memória para ser liberada pelo mesmo método que GC. Não possui uma fase de verificação nem possui nenhum dos outros métodos. Leva necessariamente menos tempo.