Downloaded 26 times
![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](https://image.slidesharecdn.com/qcon2014-rubygc-140410211233-phpapp02/85/Ruby-GCs-QConSP-2014-16-320.jpg)
![Mark bitmap (mark_bits[])
Shady bitmap (rememberset_bits[])](https://image.slidesharecdn.com/qcon2014-rubygc-140410211233-phpapp02/85/Ruby-GCs-QConSP-2014-68-320.jpg)
Uploaded byFabio Akita
Ruby & GCs (QConSP 2014)
O G1 GC é um coletor de lixo paralelo e incremental que oferece tempos de pausa mais previsíveis em comparação com o CMS GC. Ele utiliza um ciclo de marcação paralelo e multi-fásico, permitindo trabalhar com heaps maiores enquanto mantém tempos de pausa razoáveis. A apresentação discute também aspectos e configurações do gerenciamento de memória e coleta de lixo no Ruby.
More Related Content
Ruby & GCs (QConSP 2014)
- 1. Ruby & GCs EntendendoGerenciamento de Memória
- 4. "G1 GC isan 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."
- 7. Obsoletos Atuais 1.8.6 1.9.3 1.8.72.0.0 1.9.2 2.1.1
- 8. #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; }
- 9. #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; }
- 10. #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; }
- 11. #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
- 12. #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
- 13.
- 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; 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
- 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 FullMarking and Full Sweep GC
- 22. • Slots demesmo 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.
- 27. Copy on Write (CoW) sócopia o trecho da memória quando for modificada
- 29.
- 30. Bitmap Marking GC Full BitmapMarking and Full Sweep GC
- 31.
- 32. Mark Sweep MarkSweep Mark Sweep
- 33.
- 34. Lazy Sweep GC Full BitmapMarking and Lazy Sweep GC
- 36.
- 37.
- 39. RUBY_GC_MALLOC_LIMIT=30000000 RUBY_HEAP_MIN_SLOTS=800000 bundleexec rails server
- 40.
- 42. env_gc_malloc_limit_in_mb 7.6mb 26.6mb total_gc_runs105 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
- 44.
- 51.
- 56. Weak Generational Hypothesis “Most youngobjects die young"
- 57. Young Generation (Eden) OldGeneration (Tomb)
- 58.
- 61.
- 62.
- 63. Mark-Compact GC Mark Copy CompactHeap Swap GC
- 64. • “Stop-and-Copy” • Sweepprecisa 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 vsNon-Shady
- 66. Ruby Object Write Barrier(Non-Shady only) Ruby Array
- 67.
- 68. Mark bitmap (mark_bits[]) Shadybitmap (rememberset_bits[])
- 69. Objetos "Old" 96.4% Objetos"Young" 3.6% Objetos "Shady" 1.5%
- 70.
- 71.
- 72.
- 74. Restricted Generational GC (RGenGC) FullM&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
- 82.
- 83. ruby-trunk e ruby2.1.2 (não lançado)
- 84.
- 85.
- 86. RUBY_GC_MALLOC_LIMIT_MAX=8000000 RUBY_GC_OLDMALLOC_LIMIT_MAX=8000000 RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR=0.9 bundleexec rails server força GC por diminuir o teto basicamente desabilita minor GC (de volta a Ruby 2.0.0)
- 87. RUBY_GC_MALLOC_LIMIT_MAX 3210241024 8000000 RUBY_GC_OLDMALLOC_LIMIT_MAX12810241024 8000000 RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR 2.0 0.9 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/
- 88. • Objetos vãopara 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. Master Unicorn ou Passenger Rails App NGINX Rails App Rails App request 190ms 190ms190ms 50ms de Full GC!
- 91. Master Unicorn ou Passenger Rails App NGINX Rails App Rails App request 140ms 140msFull GC Executa Full GC quando não receber request
- 92.
- 95. Pausas foram de 125mspara 50ms http://tmm1.net/ruby21-oobgc/
- 98.
- 99.