Garbage collection no Ruby

221 visualizações

Publicada em

Talk no TDC Florianópolis 2014

Publicada em: Software
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
221
No SlideShare
0
A partir de incorporações
0
Número de incorporações
4
Ações
Compartilhamentos
0
Downloads
3
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Garbage collection no Ruby

  1. 1. Garbage Collection Ruby
  2. 2. Gerenciamento manual de memória
  3. 3. Objeto 01 Objeto 02
  4. 4. Desalocar manualmente
  5. 5. Objeto 01 Objeto 02
  6. 6. Objeto 01
  7. 7. Mas imagine o seguinte cenário
  8. 8. Objeto 01 Objeto 02
  9. 9. Objeto 01 Objeto 02
  10. 10. Referência para um objeto que não existe mais
  11. 11. Seu sistema pode quebrar
  12. 12. Ou pior…
  13. 13. Ele pode gerar resultados incorretos
  14. 14. Outras preocupações além do domínio da aplicação
  15. 15. Entender como os módulos que você utiliza gerenciam sua memória
  16. 16. Lauro Caetano @laurocaetano
  17. 17. Open Source
  18. 18. Rails
  19. 19. Rails core team
  20. 20. O que é Garbage Collection e como ele foi evoluindo a cada nova versão do Ruby
  21. 21. Agenda • O que é Garbage Collection • Garbage Collection no Ruby - Mark and sweep • Desvantagens do Mark and Sweep • Evolução • Lazy Sweep - Ruby 1.9 • Bitmap Mark - Ruby 2.0 • Generational Garbage Collection - Ruby 2.1
  22. 22. O que é Garbage Collection?
  23. 23. Gerenciamento dinâmico automático de memória
  24. 24. 3 Responsabilidades
  25. 25. 1.Alocar espaço para novos objetos
  26. 26. 2. Identificar os objetos ainda vivos
  27. 27. 3. Recuperar o espaço ocupado por objetos mortos
  28. 28. Garbage Collection no Ruby
  29. 29. Ruby ainda utiliza o mesmo algoritmo que foi inventado a mais de 50 anos por John MacCarthy
  30. 30. Mark-Sweep
  31. 31. Free List
  32. 32. Hora de limpar o Heap
  33. 33. Stop the world
  34. 34. Percorre todos os objetos do heap e marca os que ainda estão vivos
  35. 35. Varre novamente o heap, mas agora em busca dos objetos não marcados e os remove do heap
  36. 36. Volta a executar o seu programa
  37. 37. Vamos ao código
  38. 38. ! 1 def new! 2 ref = allocate! 3 ! 4 if ref.nil?! 5 collect! 6 ! 7 if ref.nil?! 8 raise "Out of memory"! 9 end! 10 end! 11 end! ! !
  39. 39. 12 ! 13 def collect! 14 mark_from_roots! 15 sweep(@heap_start, @heap_end)! 16 end! 17 ! ! !
  40. 40. 17 ! 18 def mark_from_roots! 19 initialize(worklist)! 20 ! 21 @roots.each do |fld|! 22 ref = fld! 23 if !ref.nil? && !marked?(ref)! 24 set_marked(ref)! 25 mark! 26 end! 27 end! 28 end! 29
  41. 41. 32 ! 33 def mark! 34 while(@worklist.any?)! 35 ref = remove(worklist)! 36 ! 37 pointers(ref).each do |fld|! 38 child = fld! 39 ! 40 if !child.nil? && !marked?(child)! 41 set_marked(child)! 42 add(@worklist, child)! 43 end! 44 end! 45 end! 46 end! 47
  42. 42. 47 ! 48 def sweep(heap_start, heap_end)! 49 scan = start! 50 ! 51 while (scan < heap_end)! 52 if marked?(scan)! 53 unset_marked(scan)! 54 else! 55 free(scan)! 56 end! 57 ! 58 scan = next_object(scan)! 59 end! 60 end
  43. 43. Desvantagens do Mark and sweep
  44. 44. Fazer Full GC toda hora que o heap está cheio não parece uma boa ideia
  45. 45. Stop the world
  46. 46. Mark and sweep é proporcional ao tamanho do heap
  47. 47. Evolução
  48. 48. Lazy Sweep Ruby 1.9
  49. 49. Fazer Full GC toda hora que o heap está cheio não parece uma boa ideia
  50. 50. Recuperar apenas o espaço necessário para criar um novo objeto e permitir que a aplicação continue rodando
  51. 51. Agora o sweep não para mais o mundo todo
  52. 52. A alocação é responsável por checar se existe espaço disponível
  53. 53. Caso não tenha espaço disponível, fazer Lazy Sweep até obter o espaço necessário
  54. 54. 12 ! 13 def allocate(size)! 14 result = remove(size)! 15 ! 16 if result.nil?! 17 lazy_sweep(size)! 18 result = remove(size)! 19 end! 20 ! 21 result! 22 end! 23
  55. 55. Bitmap Mark Ruby 2.0
  56. 56. Como os bits de marcação no ficavam objeto, os valores eram sempre diferentes
  57. 57. Para possibilitar que o Unix compartilhe valores iguais
  58. 58. Os bits de marcação foram movidos para uma tabela de bitmap
  59. 59. 1 1 1 1 10 0
  60. 60. Generational Garbage Collection Ruby 2.1
  61. 61. Mark and sweep é proporcional ao tamanho do heap
  62. 62. Weak generational hypothesis
  63. 63. O coletor processa mais frequentemente objetos novos do que objetos maduros
  64. 64. Um objeto maduro é aquele que permanece ativo por um algum período de tempo
  65. 65. Enquanto um objeto novo é aquele que seu sistema acabou de criar
  66. 66. Geração Nova Geração Madura
  67. 67. Quando o mark and sweep terminar, os objetos restantes serão considerados maduros
  68. 68. Geração Nova Geração Madura
  69. 69. Geração Nova Geração Madura
  70. 70. Objetos maduros não serão marcados novamente até um próximo full GC
  71. 71. Quando o full GC ocorrer, todos os objetos passarão pelo mark and sweep
  72. 72. É legal entender como as coisas funcionam
  73. 73. Obrigado @laurocaetano github.com/laurocaetano
  74. 74. Bonus
  75. 75. JRuby and Rubinius.
  76. 76. Copying Garbage Collection
  77. 77. Segmento de memória contínua
  78. 78. Bump Allocation
  79. 79. Aloca segmentos adjacentes de memória, mantendo um ponteiro para a próxima alocação
  80. 80. Próxima alocação
  81. 81. Próxima alocação
  82. 82. Próxima alocação
  83. 83. Objetos podem ser de tamanhos diferentes
  84. 84. A grande vantagem é que valores relacionados ficam próximos
  85. 85. A CPU pode cachear a região de memória que for acessada frequentemente
  86. 86. Também utiliza o Garbage Collection Generacional
  87. 87. Ruby 2.2
  88. 88. GC Simbolos
  89. 89. https://bugs.ruby-lang.org/issues/9634
  90. 90. Obrigado @laurocaetano github.com/laurocaetano

×