Ruby & GCs Entendendo Gerenciamento de Memória

Tamanho: px

Começar a partir da página:

Download "Ruby & GCs Entendendo Gerenciamento de Memória"

Amadeu Bonilha Prado
8 Há anos
Visualizações:

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 multiphased marking cycle, G1 GC can work with much larger heaps while providing reasonable worst-case pause times."

By introducing a parallel, concurrent and multiphased marking cycle, G1

7 Obsoletos Atuais

8 #include<stdio.h> int main() { int *ptr_one;! ptr_one = (int *)malloc(sizeof(int));! if (ptr_one == 0) { printf("error: Out of memory\n"); return 1; }! *ptr_one = 25; printf("%d\n", *ptr_one);! free(ptr_one);! return 0; }

$if (ptr_one == 0) { printf("error: Out of memory\n");$

9 #include<stdio.h> int main() { int *ptr_one;! ptr_one = (int *)malloc(sizeof(int));! if (ptr_one == 0) { printf("error: Out of memory\n"); return 1; }! *ptr_one = 25; printf("%d\n", *ptr_one);! free(ptr_one);! return 0; }

$if (ptr_one == 0) { printf("error: Out of memory\n");$

10 #include<stdio.h> int main() { int *ptr_one;! ptr_one = (int *)malloc(sizeof(int));! if (ptr_one == 0) { printf("error: Out of memory\n"); return 1; }! *ptr_one = 25; printf("%d\n", *ptr_one);! free(ptr_one);! return 0; }

$if (ptr_one == 0) { printf("error: Out of memory\n");$

11 #include<stdio.h> int main() { int *ptr_one;! ptr_one = (int *)malloc(sizeof(int));! if (ptr_one == 0) { printf("error: Out of memory\n"); return 1; }! *ptr_one = 25; printf("%d\n", *ptr_one);! free(ptr_one);! return 0; }

$if (ptr_one == 0) { printf("error: Out of memory\n"); return 1; }!$

12 #include<stdio.h> int main() { int *ptr_one;! ptr_one = (int *)malloc(sizeof(int));! if (ptr_one == 0) { printf("error: Out of memory\n"); return 1; }! *ptr_one = 25; printf("%d\n", *ptr_one);! free(ptr_one);! return 0; }

$if (ptr_one == 0) { printf("error: Out of memory\n"); return 1; }!$

13 40 bytes livres

14 Slot (40 bytes) Heap (ex 6 slots)

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

16 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; 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; }; RVALUE RSTRING(str)->as.heap.ptr

$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;$

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

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

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

21 Mark and Sweep GC Full Marking and Full Sweep GC

22 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"

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

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

29 Mark Bit Map

30 Bitmap Marking GC Full Bitmap Marking and Full Sweep GC

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

32 Mark Sweep Mark Sweep Mark Sweep

33 Mark Mark Mark

34 Lazy Sweep GC Full Bitmap Marking and Lazy Sweep GC

39 RUBY_GC_MALLOC_LIMIT= \ RUBY_HEAP_MIN_SLOTS= \ bundle exec rails server

40 RUBY_GC_MALLOC_LIMIT RUBY_HEAP_MIN_SLOTS

42 env_gc_malloc_limit_in_mb 7.6mb 26.6mb total_gc_runs heaps_with_used_slots total_heaps_allocated total_heaps_allocated_in_mb 30.6mb 30.7mb heaps_to_allocate_next_gc 869 0

44 2.49Mb 71.9Mb

51 GC Anterior

56 Weak Generational Hypothesis Most young objects die young"

57 Young Generation (Eden) Old Generation (Tomb)

58 Generational GC Copying Garbage Collector

61 From-Heap To-Heap

62 From-Heap To-Heap

63 Mark-Compact GC Mark Copy Compact Heap Swap GC

64 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

65 Ruby 2.1.x Shady vs Non-Shady

66 Ruby Array Ruby Object Write Barrier (Non-Shady only)

67 Shady Object Non-Shady Object (Sunny)

68 Mark bitmap (mark_bits[]) Shady bitmap ( rememberset_bits[])

69 Objetos "Old" 96.4% Objetos "Young" 3.6% Objetos "Shady" 1.5%

70 Mark Mark Mark

71 Major GC Minor GC

72 2.49Mb 71.9Mb

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

75 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

83 ruby-trunk e ruby (não lançado)

85 < 1.3! (+ major GC)

86 força GC por diminuir o teto RUBY_GC_MALLOC_LIMIT_MAX= \ RUBY_GC_OLDMALLOC_LIMIT_MAX= \ RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR=0.9 bundle exec rails server basicamente desabilita minor GC (de volta a Ruby 2.0.0)

87 RUBY_GC_MALLOC_LIMIT_MAX RUBY_GC_OLDMALLOC_LIMIT_MAX RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR RUBY_GC_HEAP_INIT_SLOTS RUBY_GC_HEAP_FREE_SLOTS RUBY_GC_HEAP_GROWTH_FACTOR RUBY_GC_HEAP_GROWTH_MAX_SLOTS (no limit) (obs: monitore, mensure, tuning, mensure de novo!)

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

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

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

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

92 OOBGC Out-of-Band Major GC

95 Pausas foram de 125ms para 50ms

99 slideshare.net/akitaonrails

Documentos relacionados

2.1. Princípios de garbage collection Garbage Collector

2.1. Princípios de garbage collection Garbage Collector Capítulo 2 Java Virtual Machine Com a JVM no centro da Plataforma Java, conhecer seu funcionamento interno é essencial para qualquer aplicação Java. Muitas vezes, deixamos de lado ajustes importantes de