[WIP] Do only one open syscall per Kernel#require

Author: mame

file.c

@@ -6612,7 +6612,7 @@ ruby_is_fd_loadable(int fd)
 
 #ifndef _WIN32
 int
-rb_file_load_ok(const char *path)
+rb_file_load_ok(const char *path, int *fd_ptr)
 {
     int ret = 1;
     /*
@@ -6634,7 +6634,12 @@ rb_file_load_ok(const char *path)
     }
     rb_update_max_fd(fd);
     ret = ruby_is_fd_loadable(fd);
-    (void)close(fd);
+    if (ret && fd_ptr) {
+        *fd_ptr = fd;
+    }
+    else {
+        (void)close(fd);
+    }
     return ret;
 }
 #endif
@@ -6661,7 +6666,7 @@ copy_path_class(VALUE path, VALUE orig)
 }
 
 int
-rb_find_file_ext(VALUE *filep, const char *const *ext)
+rb_find_file_ext_internal(VALUE *filep, const char *const *ext, int *fd)
 {
     const char *f = StringValueCStr(*filep);
     VALUE fname = *filep, load_path, tmp;
@@ -6682,7 +6687,7 @@ rb_find_file_ext(VALUE *filep, const char *const *ext)
         fnlen = RSTRING_LEN(fname);
         for (i=0; ext[i]; i++) {
             rb_str_cat2(fname, ext[i]);
-            if (rb_file_load_ok(RSTRING_PTR(fname))) {
+            if (rb_file_load_ok(RSTRING_PTR(fname), fd)) {
                 *filep = copy_path_class(fname, *filep);
                 return (int)(i+1);
             }
@@ -6707,7 +6712,7 @@ rb_find_file_ext(VALUE *filep, const char *const *ext)
             RB_GC_GUARD(str) = rb_get_path(str);
             if (RSTRING_LEN(str) == 0) continue;
             rb_file_expand_path_internal(fname, str, 0, 0, tmp);
-            if (rb_file_load_ok(RSTRING_PTR(tmp))) {
+            if (rb_file_load_ok(RSTRING_PTR(tmp), fd)) {
                 *filep = copy_path_class(tmp, *filep);
                 return (int)(j+1);
             }
@@ -6719,8 +6724,14 @@ rb_find_file_ext(VALUE *filep, const char *const *ext)
     return 0;
 }
 
+int
+rb_find_file_ext(VALUE *filep, const char *const *ext)
+{
+    return rb_find_file_ext_internal(filep, ext, NULL);
+}
+
 VALUE
-rb_find_file(VALUE path)
+rb_find_file_internal(VALUE path, int *fd)
 {
     VALUE tmp, load_path;
     const char *f = StringValueCStr(path);
@@ -6734,7 +6745,7 @@ rb_find_file(VALUE path)
     }
 
     if (expanded || rb_is_absolute_path(f) || is_explicit_relative(f)) {
-        if (!rb_file_load_ok(f)) return 0;
+        if (!rb_file_load_ok(f, fd)) return 0;
         if (!expanded)
             path = copy_path_class(file_expand_path_1(path), path);
         return path;
@@ -6752,7 +6763,7 @@ rb_find_file(VALUE path)
             if (RSTRING_LEN(str) > 0) {
                 rb_file_expand_path_internal(path, str, 0, 0, tmp);
                 f = RSTRING_PTR(tmp);
-                if (rb_file_load_ok(f)) goto found;
+                if (rb_file_load_ok(f, fd)) goto found;
             }
         }
         rb_str_resize(tmp, 0);
@@ -6766,6 +6777,12 @@ rb_find_file(VALUE path)
     return copy_path_class(tmp, path);
 }
 
+VALUE
+rb_find_file(VALUE path)
+{
+    return rb_find_file_internal(path, NULL);
+}
+
 #define define_filetest_function(name, func, argc) do {        \
     rb_define_module_function(rb_mFileTest, name, func, argc); \
     rb_define_singleton_method(rb_cFile, name, func, argc);    \

internal/file.h

@@ -18,7 +18,9 @@ VALUE rb_default_home_dir(VALUE result);
 VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
 VALUE rb_check_realpath(VALUE basedir, VALUE path, rb_encoding *origenc);
 void rb_file_const(const char*, VALUE);
-int rb_file_load_ok(const char *);
+int rb_file_load_ok(const char *, int *);
+int rb_find_file_ext_internal(VALUE *filep, const char *const *ext, int *fd);
+VALUE rb_find_file_internal(VALUE path, int *fd);
 VALUE rb_file_expand_path_fast(VALUE, VALUE);
 VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE);
 VALUE rb_get_path_check_to_string(VALUE);

iseq.c

@@ -1376,7 +1376,7 @@ pm_iseq_compile_with_option(VALUE src, VALUE file, VALUE realpath, VALUE line, V
     VALUE error;
 
     if (parse_file) {
-        error = pm_load_parse_file(&result, src, ruby_vm_keep_script_lines ? &script_lines : NULL);
+        error = pm_load_parse_file(&result, src, NULL, ruby_vm_keep_script_lines ? &script_lines : NULL);
     }
     else {
         error = pm_parse_string(&result, src, file, ruby_vm_keep_script_lines ? &script_lines : NULL);
@@ -1838,7 +1838,7 @@ iseqw_s_compile_file_prism(int argc, VALUE *argv, VALUE self)
     result.node.coverage_enabled = 1;
 
     VALUE script_lines;
-    VALUE error = pm_load_parse_file(&result, file, ruby_vm_keep_script_lines ? &script_lines : NULL);
+    VALUE error = pm_load_parse_file(&result, file, NULL, ruby_vm_keep_script_lines ? &script_lines : NULL);
 
     if (error == Qnil) {
         make_compile_option(&option, opt);

load.c

@@ -817,7 +817,7 @@ iseq_eval_in_namespace(VALUE arg)
 }
 
 static inline void
-load_iseq_eval(rb_execution_context_t *ec, VALUE fname)
+load_iseq_eval(rb_execution_context_t *ec, VALUE fname, int *fd)
 {
     GET_loading_vm_ns();
     const rb_namespace_t *loading_ns = rb_loading_namespace();
@@ -834,7 +834,7 @@ load_iseq_eval(rb_execution_context_t *ec, VALUE fname)
             result.options.line = 1;
             result.node.coverage_enabled = 1;
 
-            VALUE error = pm_load_parse_file(&result, fname, NULL);
+            VALUE error = pm_load_parse_file(&result, fname, fd, NULL);
 
             if (error == Qnil) {
                 int error_state;
@@ -915,7 +915,7 @@ load_wrapping(rb_execution_context_t *ec, VALUE fname, VALUE load_wrapper)
     EC_PUSH_TAG(ec);
     state = EC_EXEC_TAG();
     if (state == TAG_NONE) {
-        load_iseq_eval(ec, fname);
+        load_iseq_eval(ec, fname, NULL);
     }
     EC_POP_TAG();
 
@@ -958,7 +958,7 @@ rb_load_internal(VALUE fname, VALUE wrap)
         state = load_wrapping(ec, fname, namespace);
     }
     else {
-        load_iseq_eval(ec, fname);
+        load_iseq_eval(ec, fname, NULL);
     }
     raise_load_if_failed(ec, state);
 }
@@ -996,7 +996,7 @@ load_entrypoint_internal(VALUE fname, VALUE wrap)
 
     path = rb_find_file(fname);
     if (!path) {
-        if (!rb_file_load_ok(RSTRING_PTR(fname)))
+        if (!rb_file_load_ok(RSTRING_PTR(fname), NULL))
             load_failed(orig_fname);
         path = fname;
     }
@@ -1189,7 +1189,7 @@ rb_f_require_relative(VALUE obj, VALUE fname)
 typedef int (*feature_func)(vm_ns_t *vm_ns, const char *feature, const char *ext, int rb, int expanded, const char **fn);
 
 static int
-search_required(vm_ns_t *vm_ns, VALUE fname, volatile VALUE *path, feature_func rb_feature_p)
+search_required(vm_ns_t *vm_ns, VALUE fname, volatile VALUE *path, feature_func rb_feature_p, int *fd)
 {
     VALUE tmp;
     char *ext, *ftptr;
@@ -1204,7 +1204,7 @@ search_required(vm_ns_t *vm_ns, VALUE fname, volatile VALUE *path, feature_func
                 if (loading) *path = rb_filesystem_str_new_cstr(loading);
                 return 'r';
             }
-            if ((tmp = rb_find_file(fname)) != 0) {
+            if ((tmp = rb_find_file_internal(fname, fd)) != 0) {
                 ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
                 if (!rb_feature_p(vm_ns, ftptr, ext, TRUE, TRUE, &loading) || loading)
                     *path = tmp;
@@ -1245,7 +1245,7 @@ search_required(vm_ns_t *vm_ns, VALUE fname, volatile VALUE *path, feature_func
         return 'r';
     }
     tmp = fname;
-    const unsigned int type = rb_find_file_ext(&tmp, ft == 's' ? ruby_ext : loadable_ext);
+    const unsigned int type = rb_find_file_ext_internal(&tmp, ft == 's' ? ruby_ext : loadable_ext, ft == 's' ? NULL : fd);
 
     // Check if it's a statically linked extension when
     // not already a feature and not found as a dynamic library.
@@ -1339,7 +1339,7 @@ rb_resolve_feature_path(VALUE klass, VALUE fname)
 
     fname = rb_get_path(fname);
     path = rb_str_encode_ospath(fname);
-    found = search_required(vm_ns, path, &path, no_feature_p);
+    found = search_required(vm_ns, path, &path, no_feature_p, NULL);
 
     switch (found) {
       case 'r':
@@ -1429,9 +1429,10 @@ require_internal(rb_execution_context_t *ec, VALUE fname, int exception, bool wa
     if ((state = EC_EXEC_TAG()) == TAG_NONE) {
         VALUE handle;
         int found;
+        int fd = -1;
 
         RUBY_DTRACE_HOOK(FIND_REQUIRE_ENTRY, RSTRING_PTR(fname));
-        found = search_required(vm_ns, path, &saved_path, rb_feature_p);
+        found = search_required(vm_ns, path, &saved_path, rb_feature_p, &fd);
         RUBY_DTRACE_HOOK(FIND_REQUIRE_RETURN, RSTRING_PTR(fname));
         path = saved_path;
 
@@ -1459,7 +1460,7 @@ require_internal(rb_execution_context_t *ec, VALUE fname, int exception, bool wa
                         load_wrapping(saved.ec, path, vm_ns->ns->ns_object);
                     }
                     else {
-                        load_iseq_eval(saved.ec, path);
+                        load_iseq_eval(saved.ec, path, &fd);
                     }
                     break;
 

prism_compile.c

@@ -11187,7 +11187,7 @@ pm_parse_file_script_lines(const pm_scope_node_t *scope_node, const pm_parser_t
 // file, with additional handling for files that require blocking to properly
 // read (e.g. pipes).
 static pm_string_init_result_t
-pm_read_file(pm_string_t *string, const char *filepath)
+pm_read_file(pm_string_t *string, const char *filepath, int *passed_fd)
 {
 #ifdef _WIN32
     // Open the file for reading.
@@ -11256,9 +11256,15 @@ pm_read_file(pm_string_t *string, const char *filepath)
 #elif defined(_POSIX_MAPPED_FILES)
     // Open the file for reading
     const int open_mode = O_RDONLY | O_NONBLOCK;
-    int fd = open(filepath, open_mode);
-    if (fd == -1) {
-        return PM_STRING_INIT_ERROR_GENERIC;
+    int fd;
+    if (passed_fd && *passed_fd != -1) {
+        fd = *passed_fd;
+        *passed_fd = -1;
+    } else {
+        fd = open(filepath, open_mode);
+        if (fd == -1) {
+            return PM_STRING_INIT_ERROR_GENERIC;
+        }
     }
 
     // Stat the file to get the file size
@@ -11329,9 +11335,9 @@ pm_read_file(pm_string_t *string, const char *filepath)
  * be read.
  */
 VALUE
-pm_load_file(pm_parse_result_t *result, VALUE filepath, bool load_error)
+pm_load_file(pm_parse_result_t *result, VALUE filepath, int *fd, bool load_error)
 {
-    pm_string_init_result_t init_result = pm_read_file(&result->input, RSTRING_PTR(filepath));
+    pm_string_init_result_t init_result = pm_read_file(&result->input, RSTRING_PTR(filepath), fd);
 
     if (init_result == PM_STRING_INIT_SUCCESS) {
         pm_options_frozen_string_literal_init(&result->options);
@@ -11406,9 +11412,9 @@ pm_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
  * cannot be read or if it cannot be parsed properly.
  */
 VALUE
-pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines)
+pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, int *fd, VALUE *script_lines)
 {
-    VALUE error = pm_load_file(result, filepath, false);
+    VALUE error = pm_load_file(result, filepath, fd, false);
     if (NIL_P(error)) {
         error = pm_parse_file(result, filepath, script_lines);
     }

prism_compile.h

@@ -89,9 +89,9 @@ typedef struct {
 #define PM_CONSTANT_MULT ((pm_constant_id_t)(idMULT | PM_SPECIAL_CONSTANT_FLAG))
 #define PM_CONSTANT_POW ((pm_constant_id_t)(idPow | PM_SPECIAL_CONSTANT_FLAG))
 
-VALUE pm_load_file(pm_parse_result_t *result, VALUE filepath, bool load_error);
+VALUE pm_load_file(pm_parse_result_t *result, VALUE filepath, int *fd, bool load_error);
 VALUE pm_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines);
-VALUE pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines);
+VALUE pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, int *fd, VALUE *script_lines);
 VALUE pm_parse_string(pm_parse_result_t *result, VALUE source, VALUE filepath, VALUE *script_lines);
 VALUE pm_parse_stdin(pm_parse_result_t *result);
 void pm_options_version_for_current_ruby_set(pm_options_t *options);

ruby.c

@@ -2224,7 +2224,7 @@ prism_script(ruby_cmdline_options_t *opt, pm_parse_result_t *result)
         pm_options_command_line_set(options, command_line);
         pm_options_shebang_callback_set(options, prism_script_shebang_callback, (void *) opt);
 
-        error = pm_load_file(result, script_name, true);
+        error = pm_load_file(result, script_name, NULL, true);
 
         // If reading the file did not error, at that point we load the command
         // line options. We do it in this order so that if the main script fails