* variable.c: Make autoload thread-safe. See #921.

  What's the problem?
    autoload is thread unsafe. When we define a constant to be
    autoloaded, we expect the constant construction is invariant. But
    current autoload implementation allows other threads to access the
    constant while the first thread is loading a file.

  What's happening inside?
    The current implementation uses Qundef as a marker of autoload in
    Constant table. Once the first thread find Qundef as a value at
    constant lookup, it starts loading a defined feature. Generally a
    loaded file overrides the Qundef in Constant table by module/class
    declaration at very beginning lines of the file, so other threads
    can see the new Module/Class object before feature loading is
    finished. It breaks invariant construction.

  How to solve?
    To ensure invariant constant construction, we need to override
    Qundef with defined Object after the feature loading. For keeping
    Qundef in Constant table, I expanded autoload_data struct in
    Module to have a slot for keeping the defined object while feature
    loading. And changed Module's constant lookup/update logic a
    little so that the slot is only visible from the thread which
    invokes feature loading. (== the first thread which accessed the
    autoload constant)

  Evaluation?
    All test passes (bootstrap test, test-all and RubySpec) and added
    8 tests for threading behavior. Extra logics are executed only
    when Qundef is found, so no perf drop should happen except
    autoloading.

* variable.c (rb_autoload): Prepare new autoload_data struct.

* variable.c (rb_autoload_load): Load feature and update Constant
  table after feature loading is finished. 

* variable.c (rb_const_get_0): When the fetched constant is under
  autoloading, it returns the object only for the thread which starts
  autoloading.

* variable.c (rb_const_defined_0): Ditto.

* variable.c (rb_const_set): When the specified constant is under
  autoloading, it sets the object only for the thread which starts
  autoloading. Otherwise, simply overrides Qundef with constant
  override warning.

* vm_insnhelper.c (vm_get_ev_const): Apply same change as
  rb_const_get_0 in variable.c.

* test/ruby/test_autoload.rb: Added tests for threading behavior.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@33078 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 2 insertions, 1 deletions

diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 9410963d5c..e79d4a092d 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -1178,7 +1178,7 @@ vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
 	    cref = cref->nd_next;
 
 	    if (!NIL_P(klass)) {
-		VALUE am = 0;
+		VALUE av, am = 0;
 		st_data_t data;
 	      search_continue:
 		if (RCLASS_CONST_TBL(klass) &&
@@ -1188,6 +1188,7 @@ vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
 			if (am == klass) break;
 			am = klass;
 			if (is_defined) return 1;
+			if (rb_autoloading_value(klass, id, &av)) return av;
 			rb_autoload_load(klass, id);
 			goto search_continue;
 		    }