/********************************************************************** mjit_worker.c - Worker for MRI method JIT compiler Copyright (C) 2017 Vladimir Makarov . **********************************************************************/ /* NOTE: All functions in this file are executed on MJIT worker. So don't call Ruby methods (C functions that may call rb_funcall) or trigger GC (using xmalloc, ZALLOC, etc.) in this file. */ /* We utilize widely used C compilers (GCC and LLVM Clang) to implement MJIT. We feed them a C code generated from ISEQ. The industrial C compilers are slower than regular JIT engines. Generated code performance of the used C compilers has a higher priority over the compilation speed. So our major goal is to minimize the ISEQ compilation time when we use widely optimization level (-O2). It is achieved by o Using a precompiled version of the header o Keeping all files in `/tmp`. On modern Linux `/tmp` is a file system in memory. So it is pretty fast o Implementing MJIT as a multi-threaded code because we want to compile ISEQs in parallel with iseq execution to speed up Ruby code execution. MJIT has one thread (*worker*) to do parallel compilations: o It prepares a precompiled code of the minimized header. It starts at the MRI execution start o It generates PIC object files of ISEQs o It takes one JIT unit from a priority queue unless it is empty. o It translates the JIT unit ISEQ into C-code using the precompiled header, calls CC and load PIC code when it is ready o Currently MJIT put ISEQ in the queue when ISEQ is called o MJIT can reorder ISEQs in the queue if some ISEQ has been called many times and its compilation did not start yet o MRI reuses the machine code if it already exists for ISEQ o The machine code we generate can stop and switch to the ISEQ interpretation if some condition is not satisfied as the machine code can be speculative or some exception raises o Speculative machine code can be canceled. Here is a diagram showing the MJIT organization: _______ |header | |_______| | MRI building --------------|---------------------------------------- | MRI execution | _____________|_____ | | | | ___V__ | CC ____________________ | | |----------->| precompiled header | | | | | |____________________| | | | | | | | MJIT | | | | | | | | | | | | ____V___ CC __________ | |______|----------->| C code |--->| .so file | | | |________| |__________| | | | | | | | MRI machine code |<----------------------------- |___________________| loading */ #ifdef __sun #define __EXTENSIONS__ 1 #endif #include "internal.h" #include "vm_core.h" #include "mjit.h" #include "gc.h" #include "constant.h" #include "id_table.h" #include "ruby_assert.h" #include "ruby/thread.h" #include "ruby/util.h" #ifdef _WIN32 #include #include #else #include #include #include #endif #include #ifdef HAVE_FCNTL_H #include #endif #ifdef HAVE_SYS_PARAM_H # include #endif #include "dln.h" #include "mjit_internal.h" #ifdef _WIN32 #define waitpid(pid,stat_loc,options) (WaitForSingleObject((HANDLE)(pid), INFINITE), GetExitCodeProcess((HANDLE)(pid), (LPDWORD)(stat_loc)), (pid)) #define WIFEXITED(S) ((S) != STILL_ACTIVE) #define WEXITSTATUS(S) (S) #define WIFSIGNALED(S) (0) typedef intptr_t pid_t; #endif /* process.c */ rb_pid_t ruby_waitpid_locked(rb_vm_t *, rb_pid_t, int *status, int options, rb_nativethread_cond_t *cond); /* Atomically set function pointer if possible. */ #define MJIT_ATOMIC_SET(var, val) (void)ATOMIC_PTR_EXCHANGE(var, val) extern struct mjit_options mjit_opts; extern int mjit_enabled; extern struct rb_mjit_unit_list mjit_unit_queue; extern struct rb_mjit_unit_list mjit_active_units; extern struct rb_mjit_unit_list mjit_compact_units; extern int mjit_current_unit_num; extern rb_nativethread_cond_t mjit_pch_wakeup; extern rb_nativethread_cond_t mjit_client_wakeup; extern rb_nativethread_cond_t mjit_worker_wakeup; extern rb_nativethread_cond_t mjit_gc_wakeup; extern int mjit_in_gc; extern int mjit_in_jit; /* --- Defined in the client thread before starting MJIT threads: --- */ /* Used C compiler path. */ const char *mjit_cc_path; /* Name of the precompiled header file. */ char *mjit_pch_file; #ifndef _MSC_VER /* Name of the header file. */ char *mjit_header_file; #endif #ifdef _WIN32 /* Linker option to enable libruby. */ char *mjit_libruby_pathflag; #endif /* Return time in milliseconds as a double. */ #ifdef __APPLE__ double ruby_real_ms_time(void); # define real_ms_time() ruby_real_ms_time() #else static double real_ms_time(void) { # ifdef HAVE_CLOCK_GETTIME struct timespec tv; # ifdef CLOCK_MONOTONIC const clockid_t c = CLOCK_MONOTONIC; # else const clockid_t c = CLOCK_REALTIME; # endif clock_gettime(c, &tv); return tv.tv_nsec / 1000000.0 + tv.tv_sec * 1000.0; # else struct timeval tv; gettimeofday(&tv, NULL); return tv.tv_usec / 1000.0 + tv.tv_sec * 1000.0; # endif } #endif static const char *const CC_DEBUG_ARGS[] = {MJIT_DEBUGFLAGS NULL}; static const char *const CC_OPTIMIZE_ARGS[] = {MJIT_OPTFLAGS NULL}; static const char *const CC_LDSHARED_ARGS[] = {MJIT_LDSHARED GCC_PIC_FLAGS NULL}; static const char *const CC_DLDFLAGS_ARGS[] = { MJIT_DLDFLAGS #if defined __GNUC__ && !defined __clang__ "-nostartfiles", # if !defined(_WIN32) && !defined(__CYGWIN__) "-nodefaultlibs", "-nostdlib", # endif #endif NULL }; static const char *const CC_LIBS[] = { #if defined(_WIN32) || defined(__CYGWIN__) MJIT_LIBS # if defined __GNUC__ && !defined __clang__ # if defined(_WIN32) "-lmsvcrt", # endif "-lgcc", # endif #endif NULL }; #define CC_CODEFLAG_ARGS (mjit_opts.debug ? CC_DEBUG_ARGS : CC_OPTIMIZE_ARGS) /* Status of the precompiled header creation. The status is shared by the workers and the pch thread. */ enum pch_status_t mjit_pch_status; /* Return the best unit from list. The best is the first high priority unit or the unit whose iseq has the biggest number of calls so far. */ static struct rb_mjit_unit_node * get_from_list(struct rb_mjit_unit_list *list) { struct rb_mjit_unit_node *node, *best = NULL; if (list->head == NULL) return NULL; /* Find iseq with max total_calls */ for (node = list->head; node != NULL; node = node ? node->next : NULL) { if (node->unit->iseq == NULL) { /* ISeq is GCed. */ free_unit(node->unit); remove_from_list(node, list); continue; } if (best == NULL || best->unit->iseq->body->total_calls < node->unit->iseq->body->total_calls) { best = node; } } return best; } /* Return length of NULL-terminated array ARGS excluding the NULL marker. */ static size_t args_len(char *const *args) { size_t i; for (i = 0; (args[i]) != NULL;i++) ; return i; } /* Concatenate NUM passed NULL-terminated arrays of strings, put the result (with NULL end marker) into the heap, and return the result. */ static char ** form_args(int num, ...) { va_list argp; size_t len, n; int i; char **args, **res, **tmp; va_start(argp, num); res = NULL; for (i = len = 0; i < num; i++) { args = va_arg(argp, char **); n = args_len(args); if ((tmp = (char **)realloc(res, sizeof(char *) * (len + n + 1))) == NULL) { free(res); return NULL; } res = tmp; MEMCPY(res + len, args, char *, n + 1); len += n; } va_end(argp); return res; } COMPILER_WARNING_PUSH #ifdef __GNUC__ COMPILER_WARNING_IGNORED(-Wdeprecated-declarations) #endif /* Start an OS process of executable PATH with arguments ARGV. Return PID of the process. TODO: Use the same function in process.c */ static pid_t start_process(const char *path, char *const *argv) { pid_t pid; if (mjit_opts.verbose >= 2) { int i; const char *arg; fprintf(stderr, "Starting process: %s", path); for (i = 0; (arg = argv[i]) != NULL; i++) fprintf(stderr, " %s", arg); fprintf(stderr, "\n"); } #ifdef _WIN32 pid = spawnvp(_P_NOWAIT, path, argv); #else { /* * Not calling non-async-signal-safe functions between vfork * and execv for safety */ char fbuf[MAXPATHLEN]; const char *abspath = dln_find_exe_r(path, 0, fbuf, sizeof(fbuf)); int dev_null; if (!abspath) { verbose(1, "MJIT: failed to find `%s' in PATH\n", path); return -1; } dev_null = rb_cloexec_open(ruby_null_device, O_WRONLY, 0); if ((pid = vfork()) == 0) { umask(0077); if (mjit_opts.verbose == 0) { /* CC can be started in a thread using a file which has been already removed while MJIT is finishing. Discard the messages about missing files. */ dup2(dev_null, STDERR_FILENO); dup2(dev_null, STDOUT_FILENO); } (void)close(dev_null); pid = execv(abspath, argv); /* Pid will be negative on an error */ /* Even if we successfully found CC to compile PCH we still can fail with loading the CC in very rare cases for some reasons. Stop the forked process in this case. */ verbose(1, "MJIT: Error in execv: %s\n", abspath); _exit(1); } (void)close(dev_null); } #endif return pid; } COMPILER_WARNING_POP /* Execute an OS process of executable PATH with arguments ARGV. Return -1 or -2 if failed to execute, otherwise exit code of the process. TODO: Use a similar function in process.c */ static int exec_process(const char *path, char *const argv[]) { int stat, exit_code = -2; pid_t pid; rb_vm_t *vm = WAITPID_USE_SIGCHLD ? GET_VM() : 0; rb_nativethread_cond_t cond; if (vm) { rb_native_cond_initialize(&cond); rb_native_mutex_lock(&vm->waitpid_lock); } pid = start_process(path, argv); for (;pid > 0;) { pid_t r = vm ? ruby_waitpid_locked(vm, pid, &stat, 0, &cond) : waitpid(pid, &stat, 0); if (r == -1) { if (errno == EINTR) continue; fprintf(stderr, "[%"PRI_PIDT_PREFIX"d] waitpid(%lu): %s (SIGCHLD=%d,%u)\n", getpid(), (unsigned long)pid, strerror(errno), RUBY_SIGCHLD, SIGCHLD_LOSSY); break; } else if (r == pid) { if (WIFEXITED(stat)) { exit_code = WEXITSTATUS(stat); break; } else if (WIFSIGNALED(stat)) { exit_code = -1; break; } } } if (vm) { rb_native_mutex_unlock(&vm->waitpid_lock); rb_native_cond_destroy(&cond); } return exit_code; } #ifdef _MSC_VER /* Compile C file to so. It returns 1 if it succeeds. (mswin) */ static int compile_c_to_so(const char *c_file, const char *so_file) { int exit_code; const char *files[] = { NULL, NULL, NULL, NULL, "-link", mjit_libruby_pathflag, NULL }; char **args; char *p; /* files[0] = "-Fe*.dll" */ files[0] = p = (char *)alloca(sizeof(char) * (rb_strlen_lit("-Fe") + strlen(so_file) + 1)); p = append_lit(p, "-Fe"); p = append_str2(p, so_file, strlen(so_file)); *p = '\0'; /* files[1] = "-Yu*.pch" */ files[1] = p = (char *)alloca(sizeof(char) * (rb_strlen_lit("-Yu") + strlen(mjit_pch_file) + 1)); p = append_lit(p, "-Yu"); p = append_str2(p, mjit_pch_file, strlen(mjit_pch_file)); *p = '\0'; /* files[2] = "C:/.../rb_mjit_header-*.obj" */ files[2] = p = (char *)alloca(sizeof(char) * (strlen(mjit_pch_file) + 1)); p = append_str2(p, mjit_pch_file, strlen(mjit_pch_file) - strlen(".pch")); p = append_lit(p, ".obj"); *p = '\0'; /* files[3] = "-Tc*.c" */ files[3] = p = (char *)alloca(sizeof(char) * (rb_strlen_lit("-Tc") + strlen(c_file) + 1)); p = append_lit(p, "-Tc"); p = append_str2(p, c_file, strlen(c_file)); *p = '\0'; args = form_args(5, CC_LDSHARED_ARGS, CC_CODEFLAG_ARGS, files, CC_LIBS, CC_DLDFLAGS_ARGS); if (args == NULL) return FALSE; { int stdout_fileno = _fileno(stdout); int orig_fd = dup(stdout_fileno); int dev_null = rb_cloexec_open(ruby_null_device, O_WRONLY, 0); /* Discard cl.exe's outputs like: _ruby_mjit_p12u3.c Creating library C:.../_ruby_mjit_p12u3.lib and object C:.../_ruby_mjit_p12u3.exp TODO: Don't discard them on --jit-verbose=2+ */ dup2(dev_null, stdout_fileno); exit_code = exec_process(mjit_cc_path, args); dup2(orig_fd, stdout_fileno); close(orig_fd); close(dev_null); } free(args); if (exit_code != 0) verbose(2, "compile_c_to_so: compile error: %d", exit_code); return exit_code == 0; } #else /* _MSC_VER */ /* The function producing the pre-compiled header. */ static void make_pch(void) { int exit_code; const char *rest_args[] = { # ifdef __clang__ "-emit-pch", # endif "-o", NULL, NULL, NULL, }; char **args; int len = sizeof(rest_args) / sizeof(const char *); rest_args[len - 2] = mjit_header_file; rest_args[len - 3] = mjit_pch_file; verbose(2, "Creating precompiled header"); args = form_args(3, CC_COMMON_ARGS, CC_CODEFLAG_ARGS, rest_args); if (args == NULL) { if (mjit_opts.warnings || mjit_opts.verbose) fprintf(stderr, "MJIT warning: making precompiled header failed on forming args\n"); CRITICAL_SECTION_START(3, "in make_pch"); mjit_pch_status = PCH_FAILED; CRITICAL_SECTION_FINISH(3, "in make_pch"); return; } exit_code = exec_process(mjit_cc_path, args); free(args); CRITICAL_SECTION_START(3, "in make_pch"); if (exit_code == 0) { mjit_pch_status = PCH_SUCCESS; } else { if (mjit_opts.warnings || mjit_opts.verbose) fprintf(stderr, "MJIT warning: Making precompiled header failed on compilation. Stopping MJIT worker...\n"); mjit_pch_status = PCH_FAILED; } /* wakeup `mjit_finish` */ rb_native_cond_broadcast(&mjit_pch_wakeup); CRITICAL_SECTION_FINISH(3, "in make_pch"); } /* Compile .c file to .o file. It returns 1 if it succeeds. (non-mswin) */ static int compile_c_to_o(const char *c_file, const char *o_file) { int exit_code; const char *files[] = { "-o", NULL, NULL, # ifdef __clang__ "-include-pch", NULL, # endif "-c", NULL }; char **args; files[1] = o_file; files[2] = c_file; # ifdef __clang__ files[4] = mjit_pch_file; # endif args = form_args(5, CC_COMMON_ARGS, CC_CODEFLAG_ARGS, files, CC_LIBS, CC_DLDFLAGS_ARGS); if (args == NULL) return FALSE; exit_code = exec_process(mjit_cc_path, args); free(args); if (exit_code != 0) verbose(2, "compile_c_to_o: compile error: %d", exit_code); return exit_code == 0; } /* Link .o files to .so file. It returns 1 if it succeeds. (non-mswin) */ static int link_o_to_so(const char **o_files, const char *so_file) { int exit_code; const char *options[] = { "-o", NULL, # ifdef _WIN32 mjit_libruby_pathflag, # endif NULL }; char **args; options[1] = so_file; args = form_args(6, CC_LDSHARED_ARGS, CC_CODEFLAG_ARGS, options, o_files, CC_LIBS, CC_DLDFLAGS_ARGS); if (args == NULL) return FALSE; exit_code = exec_process(mjit_cc_path, args); free(args); if (exit_code != 0) verbose(2, "link_o_to_so: link error: %d", exit_code); return exit_code == 0; } /* Link all cached .o files and build a .so file. Reload all JIT func from it. This allows to avoid JIT code fragmentation and improve performance to call JIT-ed code. */ static void compact_all_jit_code(void) { # ifndef _WIN32 /* This requires header transformation but we don't transform header on Windows for now */ struct rb_mjit_unit *unit; struct rb_mjit_unit_node *node; double start_time, end_time; static const char so_ext[] = DLEXT; char so_file[MAXPATHLEN]; const char **o_files; int i = 0, success; /* Abnormal use case of rb_mjit_unit that doesn't have ISeq */ unit = (struct rb_mjit_unit *)calloc(1, sizeof(struct rb_mjit_unit)); /* To prevent GC, don't use ZALLOC */ if (unit == NULL) return; unit->id = mjit_current_unit_num++; sprint_uniq_filename(so_file, (int)sizeof(so_file), unit->id, MJIT_TMP_PREFIX, so_ext); /* NULL-ending for form_args */ o_files = (const char **)alloca(sizeof(char *) * (mjit_active_units.length + 1)); o_files[mjit_active_units.length] = NULL; CRITICAL_SECTION_START(3, "in compact_all_jit_code to keep .o files"); for (node = mjit_active_units.head; node != NULL; node = node->next) { o_files[i] = node->unit->o_file; i++; } start_time = real_ms_time(); success = link_o_to_so(o_files, so_file); end_time = real_ms_time(); /* TODO: Shrink this big critical section. For now, this is needed to prevent failure by missing .o files. This assumes that o -> so link doesn't take long time because the bottleneck, which is compiler optimization, is already done. But actually it takes about 500ms for 5,000 methods on my Linux machine, so it's better to finish this critical section before link_o_to_so by disabling unload_units. */ CRITICAL_SECTION_FINISH(3, "in compact_all_jit_code to keep .o files"); if (success) { void *handle = dlopen(so_file, RTLD_NOW); if (handle == NULL) { if (mjit_opts.warnings || mjit_opts.verbose) fprintf(stderr, "MJIT warning: failure in loading code from compacted '%s': %s\n", so_file, dlerror()); free(unit); return; } unit->handle = handle; /* lazily dlclose handle (and .so file for win32) on `mjit_finish()`. */ node = (struct rb_mjit_unit_node *)calloc(1, sizeof(struct rb_mjit_unit_node)); /* To prevent GC, don't use ZALLOC */ node->unit = unit; add_to_list(node, &mjit_compact_units); if (!mjit_opts.save_temps) { # ifdef _WIN32 unit->so_file = strdup(so_file); /* lazily delete on `clean_object_files()` */ # else remove_file(so_file); # endif } CRITICAL_SECTION_START(3, "in compact_all_jit_code to read list"); for (node = mjit_active_units.head; node != NULL; node = node->next) { void *func; char funcname[35]; /* TODO: reconsider `35` */ sprintf(funcname, "_mjit%d", node->unit->id); if ((func = dlsym(handle, funcname)) == NULL) { if (mjit_opts.warnings || mjit_opts.verbose) fprintf(stderr, "MJIT warning: skipping to reload '%s' from '%s': %s\n", funcname, so_file, dlerror()); continue; } if (node->unit->iseq) { /* Check whether GCed or not */ /* Usage of jit_code might be not in a critical section. */ MJIT_ATOMIC_SET(node->unit->iseq->body->jit_func, (mjit_func_t)func); } } CRITICAL_SECTION_FINISH(3, "in compact_all_jit_code to read list"); verbose(1, "JIT compaction (%.1fms): Compacted %d methods -> %s", end_time - start_time, mjit_active_units.length, so_file); } else { free(unit); verbose(1, "JIT compaction failure (%.1fms): Failed to compact methods", end_time - start_time); } # endif /* _WIN32 */ } #endif /* _MSC_VER */ static void * load_func_from_so(const char *so_file, const char *funcname, struct rb_mjit_unit *unit) { void *handle, *func; handle = dlopen(so_file, RTLD_NOW); if (handle == NULL) { if (mjit_opts.warnings || mjit_opts.verbose) fprintf(stderr, "MJIT warning: failure in loading code from '%s': %s\n", so_file, dlerror()); return (void *)NOT_ADDED_JIT_ISEQ_FUNC; } func = dlsym(handle, funcname); unit->handle = handle; return func; } static void print_jit_result(const char *result, const struct rb_mjit_unit *unit, const double duration, const char *c_file) { verbose(1, "JIT %s (%.1fms): %s@%s:%d -> %s", result, duration, RSTRING_PTR(unit->iseq->body->location.label), RSTRING_PTR(rb_iseq_path(unit->iseq)), FIX2INT(unit->iseq->body->location.first_lineno), c_file); } #ifndef __clang__ static const char * header_name_end(const char *s) { const char *e = s + strlen(s); # ifdef __GNUC__ /* don't chomp .pch for mswin */ static const char suffix[] = ".gch"; /* chomp .gch suffix */ if (e > s+sizeof(suffix)-1 && strcmp(e-sizeof(suffix)+1, suffix) == 0) { e -= sizeof(suffix)-1; } # endif return e; } #endif /* Print platform-specific prerequisites in generated code. */ static void compile_prelude(FILE *f) { #ifndef __clang__ /* -include-pch is used for Clang */ const char *s = mjit_pch_file; const char *e = header_name_end(s); fprintf(f, "#include \""); /* print mjit_pch_file except .gch for gcc, but keep .pch for mswin */ for (; s < e; s++) { switch(*s) { case '\\': case '"': fputc('\\', f); } fputc(*s, f); } fprintf(f, "\"\n"); #endif #ifdef _WIN32 fprintf(f, "void _pei386_runtime_relocator(void){}\n"); fprintf(f, "int __stdcall DllMainCRTStartup(void* hinstDLL, unsigned int fdwReason, void* lpvReserved) { return 1; }\n"); #endif } /* Compile ISeq in UNIT and return function pointer of JIT-ed code. It may return NOT_COMPILED_JIT_ISEQ_FUNC if something went wrong. */ static mjit_func_t convert_unit_to_func(struct rb_mjit_unit *unit) { char c_file_buff[MAXPATHLEN], *c_file = c_file_buff, *so_file, funcname[35]; /* TODO: reconsider `35` */ int success; int fd; FILE *f; void *func; double start_time, end_time; int c_file_len = (int)sizeof(c_file_buff); static const char c_ext[] = ".c"; static const char so_ext[] = DLEXT; const int access_mode = #ifdef O_BINARY O_BINARY| #endif O_WRONLY|O_EXCL|O_CREAT; #ifndef _MSC_VER static const char o_ext[] = ".o"; char *o_file; #endif c_file_len = sprint_uniq_filename(c_file_buff, c_file_len, unit->id, MJIT_TMP_PREFIX, c_ext); if (c_file_len >= (int)sizeof(c_file_buff)) { ++c_file_len; c_file = alloca(c_file_len); c_file_len = sprint_uniq_filename(c_file, c_file_len, unit->id, MJIT_TMP_PREFIX, c_ext); } ++c_file_len; #ifndef _MSC_VER o_file = alloca(c_file_len - sizeof(c_ext) + sizeof(o_ext)); memcpy(o_file, c_file, c_file_len - sizeof(c_ext)); memcpy(&o_file[c_file_len - sizeof(c_ext)], o_ext, sizeof(o_ext)); #endif so_file = alloca(c_file_len - sizeof(c_ext) + sizeof(so_ext)); memcpy(so_file, c_file, c_file_len - sizeof(c_ext)); memcpy(&so_file[c_file_len - sizeof(c_ext)], so_ext, sizeof(so_ext)); sprintf(funcname, "_mjit%d", unit->id); fd = rb_cloexec_open(c_file, access_mode, 0600); if (fd < 0 || (f = fdopen(fd, "w")) == NULL) { int e = errno; if (fd >= 0) (void)close(fd); verbose(1, "Failed to fopen '%s', giving up JIT for it (%s)", c_file, strerror(e)); return (mjit_func_t)NOT_COMPILED_JIT_ISEQ_FUNC; } /* print #include of MJIT header, etc. */ compile_prelude(f); /* wait until mjit_gc_finish_hook is called */ CRITICAL_SECTION_START(3, "before mjit_compile to wait GC finish"); while (mjit_in_gc) { verbose(3, "Waiting wakeup from GC"); rb_native_cond_wait(&mjit_gc_wakeup, &mjit_engine_mutex); } mjit_in_jit = TRUE; CRITICAL_SECTION_FINISH(3, "before mjit_compile to wait GC finish"); { VALUE s = rb_iseq_path(unit->iseq); const char *label = RSTRING_PTR(unit->iseq->body->location.label); const char *path = RSTRING_PTR(s); int lineno = FIX2INT(unit->iseq->body->location.first_lineno); verbose(2, "start compilation: %s@%s:%d -> %s", label, path, lineno, c_file); fprintf(f, "/* %s@%s:%d */\n\n", label, path, lineno); } success = mjit_compile(f, unit->iseq->body, funcname); /* release blocking mjit_gc_start_hook */ CRITICAL_SECTION_START(3, "after mjit_compile to wakeup client for GC"); mjit_in_jit = FALSE; verbose(3, "Sending wakeup signal to client in a mjit-worker for GC"); rb_native_cond_signal(&mjit_client_wakeup); CRITICAL_SECTION_FINISH(3, "in worker to wakeup client for GC"); fclose(f); if (!success) { if (!mjit_opts.save_temps) remove_file(c_file); print_jit_result("failure", unit, 0, c_file); return (mjit_func_t)NOT_COMPILED_JIT_ISEQ_FUNC; } start_time = real_ms_time(); #ifdef _MSC_VER success = compile_c_to_so(c_file, so_file); #else /* splitting .c -> .o step and .o -> .so step, to cache .o files in the future */ if (success = compile_c_to_o(c_file, o_file)) { const char *o_files[2] = { NULL, NULL }; o_files[0] = o_file; success = link_o_to_so(o_files, so_file); /* Alwasy set o_file for compaction. The value is also used for lazy deletion. */ unit->o_file = strdup(o_file); } #endif end_time = real_ms_time(); if (!mjit_opts.save_temps) remove_file(c_file); if (!success) { verbose(2, "Failed to generate so: %s", so_file); return (mjit_func_t)NOT_COMPILED_JIT_ISEQ_FUNC; } func = load_func_from_so(so_file, funcname, unit); if (!mjit_opts.save_temps) { #ifdef _WIN32 unit->so_file = strdup(so_file); /* lazily delete on `clean_object_files()` */ #else remove_file(so_file); #endif } if ((uintptr_t)func > (uintptr_t)LAST_JIT_ISEQ_FUNC) { struct rb_mjit_unit_node *node = create_list_node(unit); CRITICAL_SECTION_START(3, "end of jit"); add_to_list(node, &mjit_active_units); if (unit->iseq) print_jit_result("success", unit, end_time - start_time, c_file); CRITICAL_SECTION_FINISH(3, "end of jit"); } return (mjit_func_t)func; } /* Set to TRUE to stop worker. */ int mjit_stop_worker_p; /* Set to TRUE if worker is stopped. */ int mjit_worker_stopped; /* The function implementing a worker. It is executed in a separate thread by rb_thread_create_mjit_thread. It compiles precompiled header and then compiles requested ISeqs. */ void mjit_worker(void) { #ifndef _MSC_VER if (mjit_pch_status == PCH_NOT_READY) { make_pch(); } #endif if (mjit_pch_status == PCH_FAILED) { mjit_enabled = FALSE; CRITICAL_SECTION_START(3, "in worker to update mjit_worker_stopped"); mjit_worker_stopped = TRUE; verbose(3, "Sending wakeup signal to client in a mjit-worker"); rb_native_cond_signal(&mjit_client_wakeup); CRITICAL_SECTION_FINISH(3, "in worker to update mjit_worker_stopped"); return; /* TODO: do the same thing in the latter half of mjit_finish */ } /* main worker loop */ while (!mjit_stop_worker_p) { struct rb_mjit_unit_node *node; /* wait until unit is available */ CRITICAL_SECTION_START(3, "in worker dequeue"); while ((mjit_unit_queue.head == NULL || mjit_active_units.length > mjit_opts.max_cache_size) && !mjit_stop_worker_p) { rb_native_cond_wait(&mjit_worker_wakeup, &mjit_engine_mutex); verbose(3, "Getting wakeup from client"); } node = get_from_list(&mjit_unit_queue); CRITICAL_SECTION_FINISH(3, "in worker dequeue"); if (node) { mjit_func_t func = convert_unit_to_func(node->unit); CRITICAL_SECTION_START(3, "in jit func replace"); if (node->unit->iseq) { /* Check whether GCed or not */ /* Usage of jit_code might be not in a critical section. */ MJIT_ATOMIC_SET(node->unit->iseq->body->jit_func, func); } remove_from_list(node, &mjit_unit_queue); CRITICAL_SECTION_FINISH(3, "in jit func replace"); #ifndef _MSC_VER /* Combine .o files to one .so and reload all jit_func to improve memory locality */ if ((!mjit_opts.wait && mjit_unit_queue.length == 0 && mjit_active_units.length > 1) || mjit_active_units.length == mjit_opts.max_cache_size) { compact_all_jit_code(); } #endif } } /* To keep mutex unlocked when it is destroyed by mjit_finish, don't wrap CRITICAL_SECTION here. */ mjit_worker_stopped = TRUE; }