Merge pull request ruby#125 from Shopify/code_pages

maximecb · web-flow · commit 7d1dd6043980 · 2021-07-14T11:52:05.000-04:00
Code page GC object
diff --git a/yjit_asm.c b/yjit_asm.c
@@ -224,18 +224,11 @@ uint8_t* alloc_exec_mem(uint32_t mem_size)
 // How many code pages to allocate at once
 #define PAGES_PER_ALLOC 512
 
-typedef struct free_list_node
-{
-    uint8_t* page_ptr;
-
-    struct free_list_node *next;
-
-} freelist_t;
-
-freelist_t *freelist = NULL;
+// Head of the list of free code pages
+code_page_t *freelist = NULL;
 
 // Allocate a single code page from a pool of free pages
-uint8_t* alloc_code_page()
+code_page_t* alloc_code_page()
 {
     fprintf(stderr, "allocating code page\n");
 
@@ -246,29 +239,25 @@ uint8_t* alloc_code_page()
 
         // Do this in reverse order so we allocate our pages in order
         for (int i = PAGES_PER_ALLOC - 1; i >= 0; --i) {
-            freelist_t* node = malloc(sizeof(freelist_t));
-            node->page_ptr = code_chunk + i * CODE_PAGE_SIZE;
-            node->next = freelist;
-            freelist = node;
+            code_page_t* code_page = malloc(sizeof(code_page_t));
+            code_page->mem_block = code_chunk + i * CODE_PAGE_SIZE;
+            code_page->page_size = CODE_PAGE_SIZE;
+            code_page->_next = freelist;
+            freelist = code_page;
         }
     }
 
-    freelist_t* free_node = freelist;
-    uint8_t* page_ptr = freelist->page_ptr;
-
-    freelist = freelist->next;
-    free(free_node);
+    code_page_t* free_page = freelist;
+    freelist = freelist->_next;
 
-    return page_ptr;
+    return free_page;
 }
 
 // Put a code page back into the allocation pool
-void free_code_page(uint8_t* page_ptr)
+void free_code_page(code_page_t* code_page)
 {
-    freelist_t* node = malloc(sizeof(freelist_t));
-    node->page_ptr = page_ptr;
-    node->next = freelist;
-    freelist = node;
+    code_page->_next = freelist;
+    freelist = code_page;
 }
 
 // Initialize a code block object
diff --git a/yjit_asm.h b/yjit_asm.h
@@ -131,6 +131,20 @@ typedef struct X86Opnd
 
 } x86opnd_t;
 
+// Struct representing a code page
+typedef struct code_page_struct
+{
+    // Chunk of executable memory
+    uint8_t* mem_block;
+
+    // Size of the executable memory chunk
+    uint32_t page_size;
+
+    // Next node in the free list (private)
+    struct code_page_struct* _next;
+
+} code_page_t;
+
 // Dummy none/null operand
 static const x86opnd_t NO_OPND = { OPND_NONE, 0, .as.imm = 0 };
 
@@ -242,8 +256,8 @@ x86opnd_t const_ptr_opnd(const void *ptr);
 
 // Machine code allocation
 uint8_t* alloc_exec_mem(uint32_t mem_size);
-uint8_t* alloc_code_page();
-void free_code_page(uint8_t* page_ptr);
+code_page_t* alloc_code_page(void);
+void free_code_page(code_page_t* code_page);
 
 // Code block methods
 void cb_init(codeblock_t* cb, uint8_t* mem_block, uint32_t mem_size);
diff --git a/yjit_core.h b/yjit_core.h
@@ -242,8 +242,12 @@ typedef struct yjit_block_version
     VALUE receiver_klass;
     VALUE callee_cme;
 
+    // Code page this block lives on
+    VALUE code_page;
+
     // Index one past the last instruction in the iseq
     uint32_t end_idx;
+
 } block_t;
 
 // Context object methods
diff --git a/yjit_iface.c b/yjit_iface.c
@@ -855,6 +855,9 @@ rb_yjit_iseq_mark(const struct rb_iseq_constant_body *body)
                 memcpy(&object, value_address, SIZEOF_VALUE);
                 rb_gc_mark_movable(object);
             }
+
+            // Mark the machine code page this block lives on
+            rb_gc_mark_movable(block->code_page);
         }
     }
 }
@@ -895,6 +898,9 @@ rb_yjit_iseq_update_references(const struct rb_iseq_constant_body *body)
                     memcpy(value_address, &possibly_moved, SIZEOF_VALUE);
                 }
             }
+
+            // Update the machine code page this block lives on
+            block->code_page = rb_gc_location(block->code_page);
         }
     }
 }
@@ -917,6 +923,35 @@ rb_yjit_iseq_free(const struct rb_iseq_constant_body *body)
     rb_darray_free(body->yjit_blocks);
 }
 
+static void
+yjit_code_page_free(void *code_page)
+{
+    free_code_page((code_page_t*)code_page);
+}
+
+// Custom type for interacting with the GC
+static const rb_data_type_t yjit_code_page_type = {
+    "yjit_code_page",
+    {NULL, yjit_code_page_free, NULL, NULL},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+// Allocate a code page and wrap it into a Ruby object owned by the GC
+VALUE rb_yjit_code_page_alloc(void)
+{
+    code_page_t* code_page = alloc_code_page();
+    VALUE cp_obj = TypedData_Wrap_Struct(0, &yjit_code_page_type, code_page);
+    return cp_obj;
+}
+
+// Unwrap the Ruby object representing a code page
+code_page_t *rb_yjit_code_page_unwrap(VALUE cp_obj)
+{
+    code_page_t * code_page;
+    TypedData_Get_Struct(cp_obj, code_page_t, &yjit_code_page_type, code_page);
+    return code_page;
+}
+
 bool
 rb_yjit_enabled_p(void)
 {

Original file line number	Diff line number	Diff line change
`@@ -855,6 +855,9 @@ rb_yjit_iseq_mark(const struct rb_iseq_constant_body *body)`
`855`	`855`	`memcpy(&object, value_address, SIZEOF_VALUE);`
`856`	`856`	`rb_gc_mark_movable(object);`
`857`	`857`	`}`
	`858`	`+`
	`859`	`+ // Mark the machine code page this block lives on`
	`860`	`+ rb_gc_mark_movable(block->code_page);`
`858`	`861`	`}`
`859`	`862`	`}`
`860`	`863`	`}`
`@@ -895,6 +898,9 @@ rb_yjit_iseq_update_references(const struct rb_iseq_constant_body *body)`
`895`	`898`	`memcpy(value_address, &possibly_moved, SIZEOF_VALUE);`
`896`	`899`	`}`
`897`	`900`	`}`
	`901`	`+`
	`902`	`+ // Update the machine code page this block lives on`
	`903`	`+ block->code_page = rb_gc_location(block->code_page);`
`898`	`904`	`}`
`899`	`905`	`}`
`900`	`906`	`}`
`@@ -917,6 +923,35 @@ rb_yjit_iseq_free(const struct rb_iseq_constant_body *body)`
`917`	`923`	`rb_darray_free(body->yjit_blocks);`
`918`	`924`	`}`
`919`	`925`
	`926`	`+static void`
	`927`	`+yjit_code_page_free(void *code_page)`
	`928`	`+{`
	`929`	`+ free_code_page((code_page_t*)code_page);`
	`930`	`+}`
	`931`	`+`
	`932`	`+// Custom type for interacting with the GC`
	`933`	`+static const rb_data_type_t yjit_code_page_type = {`
	`934`	`+ "yjit_code_page",`
	`935`	`+ {NULL, yjit_code_page_free, NULL, NULL},`
	`936`	`+ 0, 0, RUBY_TYPED_FREE_IMMEDIATELY`
	`937`	`+};`
	`938`	`+`
	`939`	`+// Allocate a code page and wrap it into a Ruby object owned by the GC`
	`940`	`+VALUE rb_yjit_code_page_alloc(void)`
	`941`	`+{`
	`942`	`+ code_page_t* code_page = alloc_code_page();`
	`943`	`+ VALUE cp_obj = TypedData_Wrap_Struct(0, &yjit_code_page_type, code_page);`
	`944`	`+ return cp_obj;`
	`945`	`+}`
	`946`	`+`
	`947`	`+// Unwrap the Ruby object representing a code page`
	`948`	`+code_page_t *rb_yjit_code_page_unwrap(VALUE cp_obj)`
	`949`	`+{`
	`950`	`+ code_page_t * code_page;`
	`951`	`+ TypedData_Get_Struct(cp_obj, code_page_t, &yjit_code_page_type, code_page);`
	`952`	`+ return code_page;`
	`953`	`+}`
	`954`	`+`
`920`	`955`	`bool`
`921`	`956`	`rb_yjit_enabled_p(void)`
`922`	`957`	`{`