kotovalexarian-likes-github
/
ruby--ruby
mirror of https://github.com/ruby/ruby.git
1
0
Fork 0
Code Releases Activity
ruby--ruby/yjit_codegen.h

24 lines
654 B
C
Raw Normal View History

Yet Another Ruby JIT! Renaming uJIT to YJIT. AKA s/ujit/yjit/g.
2021-03-06 23:46:56 +00:00
#ifndef YJIT_CODEGEN_H
#define YJIT_CODEGEN_H 1
Refactor uJIT code into more files for readability
2020-12-08 21:54:41 +00:00
Thread EC through jit state. Add codegen status enum.
2021-03-02 01:43:58 +00:00
typedef enum codegen_status {
Yet Another Ruby JIT! Renaming uJIT to YJIT. AKA s/ujit/yjit/g.
2021-03-06 23:46:56 +00:00
YJIT_END_BLOCK,
YJIT_KEEP_COMPILING,
YJIT_CANT_COMPILE
Thread EC through jit state. Add codegen status enum.
2021-03-02 01:43:58 +00:00
} codegen_status_t;
Avoid generating redundant interpreter exit code after branches
2021-01-07 22:09:25 +00:00
Thread EC through jit state. Add codegen status enum.
2021-03-02 01:43:58 +00:00
// Code generation function signature
style: align pointer "*" to the right
2021-09-29 18:58:01 +00:00
typedef codegen_status_t (*codegen_fn)(jitstate_t *jit, ctx_t *ctx, codeblock_t *cb);
Avoid generating redundant interpreter exit code after branches
2021-01-07 22:09:25 +00:00
YJIT: Make block invalidation more robust This commit adds an entry_exit field to block_t for use in invalidate_block_version(). By patching the start of the block while invalidating it, invalidate_block_version() can function correctly while there is no executable memory left for new branch stubs. This change additionally fixes correctness for situations where we cannot patch incoming jumps to the invalidated block. In situations such as Shopify/yjit#226, the address to the start of the block is saved and used later, possibly after the block is invalidated. The assume_* family of function now generate block->entry_exit before remembering blocks for invalidation. RubyVM::YJIT.simulate_oom! is introduced for testing out of memory conditions. The test for it is disabled for now because OOM triggers other failure conditions not addressed by this commit. Fixes Shopify/yjit#226
2021-11-04 16:30:30 +00:00
static void jit_ensure_block_entry_exit(jitstate_t *jit);
Put YJIT into a single compilation unit For upstreaming, we want functions we export either prefixed with "rb_" or made static. Historically we haven't been following this rule, so we were "leaking" a lot of symbols as `make leak-globals` would tell us. This change unifies everything YJIT into a single compilation unit, yjit.o, and makes everything unprefixed static to pass `make leak-globals`. This manual "unified build" setup is similar to that of vm.o. Having everything in one compilation unit allows static functions to be visible across YJIT files and removes the need for declarations in headers in some cases. Unnecessary declarations were removed. Other changes of note: - switched to MJIT_SYMBOL_EXPORT_BEGIN which indicates stuff as being off limits for native extensions - the first include of each YJIT file is change to be "internal.h" - undefined MAP_STACK before explicitly redefining it since it collide's with a definition in system headers. Consider renaming?
2021-10-01 22:38:39 +00:00
static uint8_t *yjit_entry_prologue(codeblock_t *cb, const rb_iseq_t *iseq);
Split out compile_entry() from compile_block()
2020-12-18 18:49:53 +00:00
YJIT: Fail gracefully while OOM for new entry points Previously, YJIT crashes with rb_bug() when asked to compile new methods while out of executable memory. To handle this situation gracefully, this change keeps track of all the blocks compiled each invocation in case YJIT runs out of memory in the middle of a compliation sequence. The list is used to free all blocks in case compilation fails. yjit_gen_block() is renamed to gen_single_block() to make it distinct from gen_block_version(). Call to limit_block_version() and block_t allocation is moved into the function to help tidy error checking in the outer loop. limit_block_version() now returns by value. I feel that an out parameter with conditional mutation is unnecessarily hard to read in code that does not need to go for last drop performance. There is a good chance that the optimizer is able to output identical code anyways.
2021-11-20 04:44:13 +00:00
static block_t *gen_single_block(blockid_t blockid, const ctx_t *start_ctx, rb_execution_context_t *ec);
Refactor uJIT code into more files for readability
2020-12-08 21:54:41 +00:00
YJIT: Add ability to exit to interpreter from stubs Previously, YJIT assumed that it's always possible to generate a new basic block when servicing a stub in branch_stub_hit(). When YJIT is out of executable memory, for example, this assumption doesn't hold up. Add handling to branch_stub_hit() for servicing stubs without consuming more executable memory by adding a code path that exits to the interpreter at the location the branch stub represents. The new code path reconstructs interpreter state in branch_stub_hit() and then exits with a new snippet called `code_for_exit_from_stub` that returns `Qundef` from the YJIT native stack frame. As this change adds another place where we regenerate code from `branch_t`, extract the logic for it into a new function and call it regenerate_branch(). While we are at it, make the branch shrinking code path in branch_stub_hit() more explicit. This new functionality is hard to test without full support for out of memory conditions. To verify this change, I ran `RUBY_YJIT_ENABLE=1 make check -j12` with the following patch to stress test the new code path: ```diff diff --git a/yjit_core.c b/yjit_core.c index 4ab63d9806..5788b8c5ed 100644 --- a/yjit_core.c +++ b/yjit_core.c @@ -878,8 +878,12 @@ branch_stub_hit(branch_t *branch, const uint32_t target_idx, rb_execution_contex cb_set_write_ptr(cb, branch->end_addr); } +if (rand() < RAND_MAX/2) { // Compile the new block version p_block = gen_block_version(target, target_ctx, ec); +}else{ + p_block = NULL; +} if (!p_block && branch_modified) { // We couldn't generate a new block for the branch, but we modified the branch. ``` We can enable the new test along with other OOM tests once full support lands. Other small changes: * yjit_utils.c (print_str): Update to work with new native frame shape. Follow up for 8fa0ee4d404. * yjit_iface.c (rb_yjit_init): Run yjit_init_core() after yjit_init_codegen() so `cb` and `ocb` are available.
2021-11-26 23:00:42 +00:00
static void gen_code_for_exit_from_stub(void);
Put YJIT into a single compilation unit For upstreaming, we want functions we export either prefixed with "rb_" or made static. Historically we haven't been following this rule, so we were "leaking" a lot of symbols as `make leak-globals` would tell us. This change unifies everything YJIT into a single compilation unit, yjit.o, and makes everything unprefixed static to pass `make leak-globals`. This manual "unified build" setup is similar to that of vm.o. Having everything in one compilation unit allows static functions to be visible across YJIT files and removes the need for declarations in headers in some cases. Unnecessary declarations were removed. Other changes of note: - switched to MJIT_SYMBOL_EXPORT_BEGIN which indicates stuff as being off limits for native extensions - the first include of each YJIT file is change to be "internal.h" - undefined MAP_STACK before explicitly redefining it since it collide's with a definition in system headers. Consider renaming?
2021-10-01 22:38:39 +00:00
static void yjit_init_codegen(void);
Refactor uJIT code into more files for readability
2020-12-08 21:54:41 +00:00
Yet Another Ruby JIT! Renaming uJIT to YJIT. AKA s/ujit/yjit/g.
2021-03-06 23:46:56 +00:00
#endif // #ifndef YJIT_CODEGEN_H