Precise Garbage Collection for C. Jon Rafkind * Adam Wick + John Regehr * Matthew Flatt *

Size: px

Start display at page:

Download "Precise Garbage Collection for C. Jon Rafkind * Adam Wick + John Regehr * Matthew Flatt *"

Gabriel Simpson
6 years ago
Views:

1 Slide No. 1 Precise Garbage Collection for C Jon Rafkind * Adam Wick + John Regehr * Matthew Flatt * * University of Utah + Galois, Inc.

2 Slide No. 2 Motivation C Used to implement important programs Web servers Operating systems Virtual machines Memory management is difficult to get right

3 Slide No. 3 Conservative GC Scans for pointer values Works well for weakly typed languages Objects are stored in memory as sequences of bytes Unobtrusive to the original program Works for many C programs

4 Slide No. 4 Liveness void * void * void * Registers

5 Slide No. 5 Liveness Boehm 02 void * void * void * Registers Long running programs have possibility of liveness errors

6 Slide No. 6 Liveness inaccuracy Machine state outside the realm of C Registers Non-pointer values as pointers void * x long y 0xba xbd100000

7 Slide No. 7 Mitigating liveness Atomic blocks (memory regions with no pointers) Custom tracers Liveness errors have non-zero chance of occurring

8 Slide No. 8 thread 1 Memory leaks thread 2 thread 3 void * void * void * Heap size (mb) conservative Iterations

9 Slide No. 9 Precise GC void * void * void * Root

10 Slide No. 10 Precise GC Liveness is apparent at the source level struct painter * p =...; p->brush =...; p->color =...; p->brush = 0;

11 Slide No. 11 Precise GC Successfully added a precise garbage collector to long running C programs PLT Scheme ZSnes Emulator Nano text editor Linux

12 Slide No. 12 Precise All live objects must be reachable through pointers starting from roots Run-time type of objects must match their static allocation type

13 Slide No. 13 Precise for C All live objects must be reachable through pointers starting from roots Globals Stack Source to source transformation Run-time type of objects must match their static allocation type Type information

14 Slide No. 14 Insight C programs provide enough type information to precisely distinguish pointers from non-pointers

15 Slide No. 15 Transformation Register global variables as roots Dynamically register stack variables Rewrite allocations with run-time information Add traversal routines for structures

16 Slide No. 16 Precise for C All live objects must be reachable through pointers starting from roots Globals Stack Run-time type of objects must match their static allocation type Type information

17 Slide No. 17 Roots int * counter; int * maker(int * value){ int * x = malloc(10); *x = *value; *counter += 1; return x; }

18 Slide No. 18 int * counter; int * maker(int * value){ int * x = malloc(10); *x = *value; *counter += 1; Shadow stack void * frame[3]; frame[0] = POINTER; frame[1] = &x; frame[2] = &value; GC_set_stack(frame); Henderson 02 } return x;

19 Slide No. 19 int * counter; int * maker(int * value){ int * x = GC_malloc(10); *x = *value; *counter += 1; Shadow stack void * frame[3]; frame[0] = POINTER; frame[1] = &x; frame[2] = &value; GC_set_stack(frame); Henderson 02 } return x; GC_set_stack(last_stack);

20 Slide No. 20 Shadow stack Garbage collection Roots Globals Stack Frame Stack Frame Stack Frame

21 Slide No. 21 Stack optimizations Call graph analysis detects functions that do not need shadow stacks Potentially allocates Does not allocate Need shadow stacks Gzip: 80% non-allocating H264: 40% non-allocating Don't need shadow stacks

22 Slide No. 22 Precise for C All live objects must be reachable through pointers starting from roots Globals Stack Run-time type of objects must match their static allocation type Type information

23 Allocation rules Heuristic used to statically detect run-time type var = malloc(<expr>); sizeof(t) allocate single t structure sizeof(t) * e allocate array of t structures sizeof(t*) * e allocate pointer array e allocate atomic block Slide No. 23

24 Slide No. 24 Transforming allocations var = malloc(sizeof(struct cat)); sizeof(t) allocate single t structure sizeof(t) * e allocate array of t structures sizeof(t*) * e allocate pointer array e allocate atomic block var = GC_malloc(gc_tag_struct_cat, sizeof(struct cat));

25 Slide No. 25 Traversal functions struct cat { int * paws; char * nose; }; Used during mark phase void gc_struct_cat_mark(struct cat * c){ GC_mark(c->paws); GC_mark(c->nose); } void gc_struct_cat_repair(struct cat * c){ GC_repair(&c->paws); GC_repair(&c->nose); } Generate traversal functions Updates references to moved objects

26 Slide No. 26 Result of transformation The transformed source program will operate semantically equivalent to what it did before and is capable of supporting a moving collector

27 Slide No. 27 Internal pointers C Support Int * x = obj->x; Pointer arithmetic char * p =...; while (*p){ p++; }

28 Slide No. 28 Unions Active variant is tracked union object { int value; void * info; }; union object o; o.value = 1; GC_autotag(&o, 0); o.info = get(); GC_autotag(&o, 1);

29 Slide No. 29 External libraries Libraries that store pointers Annotate objects that should not be moved by the collector Memory allocated by libraries Safe to use because the GC will ignore it

30 Slide No. 30 Unsupported C Pointer obfuscation int * p = malloc(20); p - = 10; p[10] = 2; GC cannot traverse the pointer Pointers as integers long make(){ return malloc(); } GC cannot find pointer Ruby Constructing pointers int * x = (int*) 0x323429; Liveness issues Arrays of open sized arrays struct foo{ char rest[0]; }; GC doesn't know how large individual elements are Perl

31 Slide No. 31 Tool support GUI that verifies allocation heuristic and traversal functions

32 Slide No. 32 Tool support Two tools that can be used on C programs ~2500 line Ocaml program based on CIL (Necula 2002) Capable of parsing the Linux kernel source Fully automatic

33 Slide No. 33 Benchmarks Precise vs Conservative memory runtime Source transformation overhead

34 Slide No. 34 Precise is bounded Heap size (mb) conservative precise Repeated executions of drscheme Iterations

35 Slide No. 35 PLT Scheme Performance Benchmark: CPStack GC Mutator Duration (ms) conservative precise

36 Slide No. 36 PLT Scheme Performance Benchmark: Takl Duration (ms) GC Mutator 0 conservative precise

37 Slide No. 37 GC overhead Spec 2k benchmarks Slowdown % vpr gzip twolf hmmer h264 lame Benchmark

38 Slide No. 38 Linux kernel Test the limits of precise for C Longest running program in a system Harsh C environment

39 Slide No. 39 Linux kernel: Implementation Transformed 74,975 lines of C code Ext3 and ipv4 85 manual changes GC is non-moving / non-generational Interface to non-transformed modules

40 Slide No. 40 Linux kernel: Stack Stack limit reached with additional shadow stack information Over 4k

41 Linux kernel: Memory regions Separate memory regions kmalloc Physically contiguous Slide No. 41 vmalloc Virtually contiguous GC only returns physically contiguous memory

42 Slide No. 42 Linux kernel: heuristics Allocation heuristic broken X = kmalloc(sizeof(...)) Y = kmem_cache_alloc(cache) Type of Y is cannot be discerned

43 Slide No. 43 Linux kernel: finalizers RCU (Read-Copy-Update) is a finalizer mechanism in Linux CPU 1 CPU 3 CPU 2 CPU 4

44 Slide No. 44 Performance dbench filesystem benchmark GC Normal GC every second

45 Slide No. 45 dd on memory filesystem Performance dd on disk filesystem

46 Slide No. 46 Conclusions Precise garbage collection is a practical for C because most C programs embed enough information required to extract the required properties Long running programs benefit from precise garbage collection Thank you rafkind@cs.utah.edu

47 Slide No. 47 Precise Garbage Collection for C Jon Rafkind Adam Wick John Regehr Matthew Flatt

48 Slide No. 48

49 Slide No. 49 Precise Garbage Collection for C C is a weakly typed language Magpie Written a tool that makes C programs use precise garbage collection Applied to PLT Scheme, Linux kernel, benchmarks

50 Garbage Collection Techniques Slide No. 50 Precise collection Conservative collection

51 Garbage Collection Techniques Slide No. 51 Precise collection Conservative collection

52 Slide No. 52 Garbage Collection Techniques Precise collection Conservative collection int void* void* void* void*

53 Slide No. 53 Linked lists Thread 1 Thread 2 Lists of threads and stacks create unreclaimable chains Thread 3

54 Slide No. 54 Long running programs Web servers, OS's, etc can experience unstable memory usage with conservative collectors

55 Slide No. 55 Background Core of Drscheme written in C 10+ years of managing Boehm collector

56 Slide No. 56 Conservative collection Certain classes of programs are susceptible to memory leaks

57 Slide No. 57 Other programs ZSNes emulator Super Nintendo emulator Nano text editor Unbounded memory with conservative, stable with precise

58 Slide No. 58 Main idea Source to source transformation of C code can embed information to let precise garbage collection work: Invariants: All pointers are known Run-time type of objects is the same as their static allocation type

59 Slide No. 59 Precise Registers are not scanned for pointers All live pointers in the system are known stack Type information Roots Object Shapes

60 Slide No. 60 Precise Source transformation to retain this information stack Type information Roots Object Shapes

61 Slide No. 61 Allocation rules var = malloc(<expr>); sizeof(t) allocate single t structure sizeof(t) * e allocate array of t structures sizeof(t*) * e allocate pointer array e allocate atomic block

62 Slide No. 62 Copying hybrid-compacting Traverse objects: Marking Updating pointers collector

63 Slide No. 63 struct cat{ int * paws; char * nose; }; Traversal functions void gc_struct_cat_mark(struct cat * c){ GC_mark(c->paws); GC_mark(c->nose); } void gc_struct_cat_repair(struct cat * c){ GC_repair(&c->paws); GC_repair(&c->nose); } Generate traversal functions

64 Slide No. 64 Unions Active variant is tracked union object{ int value; void * info; }; union object o; o.value = 1; GC_autotag(&o, 0); o.info = get(); GC_autotag(&o, 1);

65 Slide No. 65 Unsupported idioms Pointer obfuscation int * p = malloc(20); p - = 10; p[10] = 2; Pointers as integers int make(){ return malloc(); } Constructing pointers Int * x = (int*) 0x323429; Arrays of open sized arrays struct foo{ char rest[0]; };

66 Slide No. 66 Mzscheme Performance Benchmark: CPStack Conservative GC Precise GC 0 conservative precise

67 Slide No. 67 Mzscheme Performance 1.2 Benchmark: Takl Conservative precise conservative precise

68 Slide No. 68 Spec Performance Factor vpr gzip twolf hmmer h264 lame Benchmark

69 Slide No. 69 Tool support Two tools that can be used on C programs

70 Slide No. 70 Tool support Two tools that can be used on C programs Based on Cil (Necula 2002) Parses C and GCC extensions Fully automatic

71 Slide No. 71 Linux Too large to fully transform Subsystems: Ext3 IPV4

72 Slide No. 72 Linux User Mode Linux stack is limited to 4k GC shadow stack went over this limit Shadow stack

73 Slide No. 73 Linux Manual changes RCU (Read-Copy-Update) finalizers Important structures allocated with vmalloc Custom allocators (kmem_cache_alloc)

74 Slide No. 74 Performance GC can cause high latencies

75 Slide No. 75 Performance GC overhead

76 Slide No. 76 Conclusions Precise garbage collection is a practical alternative for C Long running programs benefit from precise garbage collection

77 Slide No. 77 Mzscheme Performance CPStack Takl conservative precise

Precise Garbage Collection for C

Precise Garbage Collection for C Jon Rafkind Adam Wick John Regehr Matthew Flatt University of Utah rafkind@cs.utah.edu Galois, Inc. awick@galois.com University of Utah regehr@cs.utah.edu University of