Garbage Collection em Ruby

Palestra do TDC Florianópolis 2014

Transcript

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