O G1 GC é um coletor de lixo incremental paralelo que fornece tempos de pausa mais previsíveis em comparação com o CMS GC e Parallel Old GC. Introduzindo um ciclo de marcação paralelo, concorrente e multifásico, o G1 GC pode trabalhar com heap muito maiores fornecendo tempos de pausa razoáveis no pior caso.

1. Ruby & GCs
Entendendo Gerenciamento de Memória

4. "G1 GC is an incremental parallel compacting
GC that provides more predictable pause times
compared to CMS GC and Parallel Old GC. By
introducing a parallel, concurrent and multi-
phased marking cycle, G1 GC can work with
much larger heaps while providing reasonable
worst-case pause times."

5. "G1 GC is an incremental parallel compacting
GC that provides more predictable pause times
compared to CMS GC and Parallel Old GC. By
introducing a parallel, concurrent and multi-
phased marking cycle, G1 GC can work with
much larger heaps while providing reasonable
worst-case pause times."

10. Obsoletos
1.8.6
1.8.7
1.9.2

11. Obsoletos
1.8.6
1.8.7
1.9.2
Atuais
1.9.3
2.0.0
2.1.2

12. Alocação de Memória malloc()
Limpeza de Lixo free()

13. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}

14. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}

15. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}

16. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}

17. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}

18. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}
0000
0000
0000
0000
0000
0000
0001
1001

19. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}
0000
0000
0000
0000
0000
0000
0001
1001

20. #include<stdio.h>
int main()
{
int *ptr_one;
!
ptr_one = (int *)malloc(sizeof(int));
!
if (ptr_one == 0) {
printf("ERROR: Out of memoryn");
return 1;
}
!
*ptr_one = 25;
printf("%dn", *ptr_one);
!
free(ptr_one);
!
return 0;
}

21. Alocação de Memória malloc()
Detecção de Lixo ?
Limpeza de Lixo free()

22. 40 bytes livres

23. Slot (40 bytes)
Heap (ex 6 slots)

24. Slot (40 bytes)
Heap (ex 6 slots)
Instância de RVALUE

25. typedef struct RVALUE {
union {
struct {
VALUE flags; /* always 0 for freed obj */
struct RVALUE *next;
} free;
struct RBasic basic;
struct RObject object;
struct RClass klass;
struct RFloat flonum;
struct RString string;
struct RArray array;
struct RRegexp regexp;
struct RHash hash;
struct RData data;
struct RTypedData typeddata;
struct RStruct rstruct;
struct RBignum bignum;
struct RFile file;
struct RNode node;
struct RMatch match;
struct RRational rational;
struct RComplex complex;
struct {
struct RBasic basic;
VALUE v1;
VALUE v2;
VALUE v3;
} values;
} as;
#if GC_DEBUG
const char *file;
VALUE line;
#endif
} RVALUE;
RVALUE

26. typedef struct RVALUE {
union {
struct {
VALUE flags; /* always 0 for freed obj */
struct RVALUE *next;
} free;
struct RBasic basic;
struct RObject object;
struct RClass klass;
struct RFloat flonum;
struct RString string;
struct RArray array;
struct RRegexp regexp;
struct RHash hash;
struct RData data;
struct RTypedData typeddata;
struct RStruct rstruct;
struct RBignum bignum;
struct RFile file;
struct RNode node;
struct RMatch match;
struct RRational rational;
struct RComplex complex;
struct {
struct RBasic basic;
VALUE v1;
VALUE v2;
VALUE v3;
} values;
} as;
#if GC_DEBUG
const char *file;
VALUE line;
#endif
} RVALUE;
RVALUE
struct RString {
struct RBasic basic;
union {
struct {
long len;
char *ptr;
union {
long capa;
VALUE shared;
} aux;
} heap;
char ary[RSTRING_EMBED_LEN_MAX + 1];
} as;
};
RSTRING(str)->as.heap.ptr

27. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

31. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

32. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

33. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

34. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

35. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

36. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

37. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

38. Slot (40 kb)
Heap (ex 6 slots)
Instância de RVALUE
Dados do RVALUE

39. Mark and Sweep
GC
Full Marking and Full Sweep GC

41. • Slots de mesmo tamanho (não há problema com
fragmentação)

42. • Slots de mesmo tamanho (não há problema com
fragmentação)
• Quanto mais heaps, mais lento
• Fase de marcação conservadora

43. • Slots de mesmo tamanho (não há problema com
fragmentação)
• Quanto mais heaps, mais lento
• Fase de marcação conservadora
• pode haver “leaks” (ex. constantes)

44. • Slots de mesmo tamanho (não há problema com
fragmentação)
• Quanto mais heaps, mais lento
• Fase de marcação conservadora
• pode haver “leaks” (ex. constantes)
• Processo “Stop-the-World"

47. Master
Unicorn ou
Passenger
Rails
App
NGINX
request
150mb

48. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
fork()
request
150mb 150mb

49. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
Rails
App
fork() fork()
request
150mb 150mb 150mb

51. Copy on Write
(CoW)
só copia o trecho da memória quando for modificada

54. “Mark Bit Map”

55. “Mark Bit Map”

56. “Mark Bit Map”

57. “Mark Bit Map”

58. “Mark Bit Map”

59. Bitmap Marking
GC
Full Bitmap Marking and Full Sweep GC

60. Master
Unicorn ou
Passenger
Rails
App
NGINX
request
150mb

61. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
fork()
request
150mb 100mb

62. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
Rails
App
fork() fork()
request
150mb 100mb 100mb

63. Mark Sweep Mark Sweep Mark Sweep

64. Mark Mark Mark

65. Lazy Sweep
GC
Full Bitmap Marking and Lazy Sweep GC

67. https://gist.github.com/akitaonrails/10212233

68. http://u.akita.ws/samsaffron_ruby20

70. RUBY_GC_MALLOC_LIMIT=30000000
RUBY_HEAP_MIN_SLOTS=800000
bundle exec rails server

72. RUBY_GC_MALLOC_LIMIT 8.000.000 30.000.000

73. RUBY_GC_MALLOC_LIMIT 8.000.000 30.000.000
RUBY_HEAP_MIN_SLOTS 10.000 800.000

76. env_gc_malloc_limit_in_mb 7.6mb 26.6mb

77. env_gc_malloc_limit_in_mb 7.6mb 26.6mb
total_gc_runs 105 65

78. env_gc_malloc_limit_in_mb 7.6mb 26.6mb
total_gc_runs 105 65
heaps_with_used_slots 1.089 1.477

79. env_gc_malloc_limit_in_mb 7.6mb 26.6mb
total_gc_runs 105 65
heaps_with_used_slots 1.089 1.477
total_heaps_allocated 1.958 1.965

80. env_gc_malloc_limit_in_mb 7.6mb 26.6mb
total_gc_runs 105 65
heaps_with_used_slots 1.089 1.477
total_heaps_allocated 1.958 1.965
total_heaps_allocated_in_mb 30.6mb 30.7mb

81. env_gc_malloc_limit_in_mb 7.6mb 26.6mb
total_gc_runs 105 65
heaps_with_used_slots 1.089 1.477
total_heaps_allocated 1.958 1.965
total_heaps_allocated_in_mb 30.6mb 30.7mb
heaps_to_allocate_next_gc 869 0

84. 71.9Mb

85. 2.49Mb
71.9Mb

94. GC Anterior

109. Weak Generational
Hypothesis
“Most young objects die young"

110. Young Generation (Eden)
Old Generation (Tomb)

111. Generational
GC
Copying Garbage Collector

121. From-Heap
To-Heap

122. From-Heap
To-Heap

123. From-Heap
To-Heap

124. From-Heap
To-Heap

125. From-Heap
To-Heap

126. From-Heap
To-Heap

127. From-Heap
To-Heap

128. Mark-Compact
GC
Mark Copy Compact Heap Swap GC

130. • “Stop-and-Copy”

131. • “Stop-and-Copy”
• Sweep precisa ir slot a slot, neste é só considerar
tudo no primeiro heap como livre

132. • “Stop-and-Copy”
• Sweep precisa ir slot a slot, neste é só considerar
tudo no primeiro heap como livre
• Gerenciamento interno de ponteiros

133. • “Stop-and-Copy”
• Sweep precisa ir slot a slot, neste é só considerar
tudo no primeiro heap como livre
• Gerenciamento interno de ponteiros
• Feito para corrigir fragmentação

134. • “Stop-and-Copy”
• Sweep precisa ir slot a slot, neste é só considerar
tudo no primeiro heap como livre
• Gerenciamento interno de ponteiros
• Feito para corrigir fragmentação
• Ruby tem slots de mesmo tamanho

135. • “Stop-and-Copy”
• Sweep precisa ir slot a slot, neste é só considerar
tudo no primeiro heap como livre
• Gerenciamento interno de ponteiros
• Feito para corrigir fragmentação
• Ruby tem slots de mesmo tamanho
• Não suporta Copy-on-Write

136. Ruby 2.1.x
Shady vs Non-Shady

137. Ruby Array

138. Ruby Object
Ruby Array

139. Ruby Object
Write Barrier (Non-Shady only)
Ruby Array

140. Shady Object
Non-Shady Object (Sunny)

141. Mark bitmap (mark_bits[])
Shady bitmap (rememberset_bits[])

142. Mark bitmap (mark_bits[])
Shady bitmap (rememberset_bits[])

144. Objetos "Old" 96.4%

145. Objetos "Old" 96.4%
Objetos "Young" 3.6%

146. Objetos "Old" 96.4%
Objetos "Young" 3.6%
Objetos "Shady" 1.5%

147. Mark Mark Mark

149. Major GC
Minor GC

150. 2.49Mb
71.9Mb

153. Restricted Generational
GC (RGenGC)
Full M&S for Shady, Generational for Non-Shady

155. • Partial Markings, Lazy Sweeps = Menos Stop

156. • Partial Markings, Lazy Sweeps = Menos Stop
• Shady objects não vão para o Tomb

157. • Partial Markings, Lazy Sweeps = Menos Stop
• Shady objects não vão para o Tomb
• Write Barriers (referência old para new - non-Shady only)

158. • Partial Markings, Lazy Sweeps = Menos Stop
• Shady objects não vão para o Tomb
• Write Barriers (referência old para new - non-Shady only)
• Compatível com extensões C (Shady)

159. • Partial Markings, Lazy Sweeps = Menos Stop
• Shady objects não vão para o Tomb
• Write Barriers (referência old para new - non-Shady only)
• Compatível com extensões C (Shady)
• Objetos em Tomb só são remarcados em Full Mark

164. < 1.3!
(+ major GC)

165. RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR=1.3
bundle exec rails server
força GC por diminuir o teto
basicamente desabilita
minor GC
(de volta a Ruby 2.0.0)

166. @retained = []
@rand = Random.new(999)
!
MAX_STRING_SIZE = 100
!
def stress(allocate_count, retain_count, chunk_size)
chunk = []
while retain_count > 0 || allocate_count > 0
if retain_count == 0 || (@rand.rand < 0.5 && allocate_count > 0)
chunk << " " * (@rand.rand * MAX_STRING_SIZE).to_i
allocate_count -= 1
if chunk.length > chunk_size
chunk = []
end
else
@retained << " " * (@rand.rand * MAX_STRING_SIZE).to_i
retain_count -= 1
end
end
end
!
start = Time.now
# simulate rails boot, 2M objects allocated 600K retained in memory
stress(2_000_000, 600_000, 200_000)
!
# simulate 100 requests that allocate 100K objects
stress(10_000_000, 0, 100_000)
http://u.akita.ws/ruby212ready

167. Ruby 2.0 10 seg 119 mb
Ruby 2.1.1 7 seg 230 mb
ruby stress.rb
http://u.akita.ws/ruby212ready

168. Ruby 2.0 10 seg 119 mb
Ruby 2.1.1 7 seg 230 mb
1.3 6.85 seg 180 mb
RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR=1.3 ruby stress.rb
http://u.akita.ws/ruby212ready

169. Ruby 2.0 10 seg 119 mb
Ruby 2.1.1 7 seg 230 mb
1.3 6.85 seg 180 mb
0.9 6.75 seg 146 mb
RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR=0.9 ruby stress.rb
http://u.akita.ws/ruby212ready

170. Ruby 2.0 10 seg 119 mb
Ruby 2.1.1 7 seg 230 mb
1.3 6.85 seg 180 mb
0.9 6.75 seg 146 mb
8 mb 9 seg 117 mb
RUBY_GC_MALLOC_LIMIT_MAX=8000000
RUBY_GC_OLDMALLOC_LIMIT_MAX=8000000
RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR=0.9 ruby stress.rb
http://u.akita.ws/ruby212ready

171. RUBY_GC_MALLOC_LIMIT_MAX 3210241024 8000000
RUBY_GC_OLDMALLOC_LIMIT_MAX 12810241024 8000000
RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR 2.0 1.3
RUBY_GC_HEAP_INIT_SLOTS 10000 300000
RUBY_GC_HEAP_FREE_SLOTS 4096 300000
RUBY_GC_HEAP_GROWTH_FACTOR 1.8 1.25
RUBY_GC_HEAP_GROWTH_MAX_SLOTS (no limit) 150000
(obs: monitore, mensure, tuning, mensure de novo!)
http://tmm1.net/ruby21-rgengc/

174. • Objetos vão para Tomb se sobreviverem 1 GC

175. • Objetos vão para Tomb se sobreviverem 1 GC
• Objetos podem ir para Tomb cedo demais

176. • Objetos vão para Tomb se sobreviverem 1 GC
• Objetos podem ir para Tomb cedo demais
• Eden - Survivor - Tenured - Permanent

177. • Objetos vão para Tomb se sobreviverem 1 GC
• Objetos podem ir para Tomb cedo demais
• Eden - Survivor - Tenured - Permanent
• RGENGC_THREEGEN mode (experimental 2.2)

178. • Objetos vão para Tomb se sobreviverem 1 GC
• Objetos podem ir para Tomb cedo demais
• Eden - Survivor - Tenured - Permanent
• RGENGC_THREEGEN mode (experimental 2.2)
• Parallel Marking (ex. em Thread separada)
• Tri-Color Marking (talvez)

179. • Objetos vão para Tomb se sobreviverem 1 GC
• Objetos podem ir para Tomb cedo demais
• Eden - Survivor - Tenured - Permanent
• RGENGC_THREEGEN mode (experimental 2.2)
• Parallel Marking (ex. em Thread separada)
• Tri-Color Marking (talvez)
• Futuro: Incremental Major Phase (major GC menores)

180. Java
• Young Generation
• -XX:+UseSerialGC (copying collector)
• -XX:+UseParallelGC (copying collector multi-thread)
• -XX:+UseParNewGC
• Old Generation
• -XX:+UseParallelOldGC
• -XX:+UseConcMarkSweepGC

181. Master
Unicorn ou
Passenger
Rails
App
NGINX
request
190ms

182. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
Rails
App
request
190ms 190ms 190ms

183. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
Rails
App
request
190ms 190ms 190ms
50ms de Full GC!

184. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
request
140ms 140ms
Executa Full GC quando não receber request

185. Master
Unicorn ou
Passenger
Rails
App
NGINX
Rails
App
Rails
App
request
140ms 140ms Full GC
Executa Full GC quando não receber request

186. OOBGC
Out-of-Band Major GC

189. http://tmm1.net/ruby21-oobgc/

190. Pausas foram de
125ms para 50ms
http://tmm1.net/ruby21-oobgc/

193. CUIDADO!!

194. CUIDADO!!

195. http://u.akita.ws/rubymicroscope

196. Obrigado!
@akitaonrails
slideshare.net/akitaonrails
www.akitaonrails.com