edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C674241 File: Initializers.Generated.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;C674241 (server) 12/15/2008 11:35 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Initializers.Generated.cs;Thread @@ -5123,7 +5123,7 @@ #if !SILVERLIGHT module.DefineLibraryMethod("run", 0x51, new System.Delegate[] { - new System.Action(IronRuby.Builtins.ThreadOps.Run), + new System.Func(IronRuby.Builtins.ThreadOps.Run), }); #endif @@ -5131,6 +5131,10 @@ new System.Func(IronRuby.Builtins.ThreadOps.Status), }); + module.DefineLibraryMethod("stop?", 0x51, new System.Delegate[] { + new System.Func(IronRuby.Builtins.ThreadOps.IsStopped), + }); + module.DefineLibraryMethod("terminate", 0x51, new System.Delegate[] { new System.Func(IronRuby.Builtins.ThreadOps.Kill), }); @@ -5141,7 +5145,7 @@ #if !SILVERLIGHT module.DefineLibraryMethod("wakeup", 0x51, new System.Delegate[] { - new System.Action(IronRuby.Builtins.ThreadOps.Run), + new System.Func(IronRuby.Builtins.ThreadOps.Run), }); #endif @@ -5172,6 +5176,10 @@ new System.Func(IronRuby.Builtins.ThreadOps.List), }); + module.DefineLibraryMethod("main", 0x61, new System.Delegate[] { + new System.Func(IronRuby.Builtins.ThreadOps.GetMainThread), + }); + module.DefineLibraryMethod("new", 0x61, new System.Delegate[] { new System.Func(IronRuby.Builtins.ThreadOps.CreateThread), }); =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs;C674241 File: KernelOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs;C674241 (server) 12/11/2008 4:00 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/KernelOps.cs;Thread @@ -786,7 +786,7 @@ [RubyMethod("sleep", RubyMethodAttributes.PrivateInstance)] [RubyMethod("sleep", RubyMethodAttributes.PublicSingleton)] public static void Sleep(object self) { - Thread.Sleep(Timeout.Infinite); + ThreadOps.Stop(Thread.CurrentThread); } [RubyMethod("sleep", RubyMethodAttributes.PrivateInstance)] =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;C674241 File: ThreadOps.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;C674241 (server) 12/11/2008 2:05 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Libraries.LCA_RESTRICTED/Builtins/ThreadOps.cs;Thread @@ -26,10 +26,51 @@ using System.Text; namespace IronRuby.Builtins { + /// + /// Ruby threads are represented by CLR thread objects (System.Threading.Thread). + /// Ruby 1.8.N has green threads where the language does the thread scheduling. We map the green threads + /// directly to CLR threads. + /// + /// Ruby supports asynchronously manipulating of an arbitrary thread with methods like Thread#raise, Thread#exit, etc. + /// For such methods, we use Thread.Abort which is unsafe. Howevever, Ruby 1.9 may not support green threads, + /// and this will not be an issue then. + /// [RubyClass("Thread", Extends = typeof(Thread), Inherits = typeof(object))] public static class ThreadOps { static bool _globalAbortOnException; + private class ThreadExitMarker { + } + + /// + /// The ThreadState enumeration is a flag, and multiple values could be set simultaneously. Also, + /// there is other state that IronRuby tracks. RubyThreadStatus flattens out the different states + /// into non-overlapping values. + /// + private enum RubyThreadStatus { + /// + /// Ruby does not expose such a state. However, since IronRuby uses CLR threads, this state can exist for + /// threads that are not created directly from Ruby code + /// + Unstarted, + + Running, + + Sleeping, + + Completed, + + /// + /// TODO - Ruby samples show this state. Is it really needed? + /// + // Aborting, + + /// + /// An unhandled exception was thrown by the thread + /// + Aborted + } + internal class RubyThreadInfo { private static readonly Dictionary _mapping = new Dictionary(); private readonly Dictionary _threadLocalStorage; @@ -37,6 +78,7 @@ private ThreadGroup _group; private readonly Thread _thread; private bool _abortOnException; + private AutoResetEvent _runSignal = new AutoResetEvent(false); private RubyThreadInfo(Thread thread) { _threadLocalStorage = new Dictionary(); @@ -115,6 +157,7 @@ internal Exception Exception { get; set; } internal object Result { get; set; } + internal bool CreatedFromRuby { get; set; } internal bool AbortOnException { get { @@ -138,6 +181,18 @@ } } } + + /// + /// We do not use Thread.Sleep here as another thread can call Thread#wakeup/Thread#run. Instead, we use our own + /// lock which can be signalled from another thread. + /// + internal void Sleep() { + _runSignal.WaitOne(); + } + + internal void Run() { + _runSignal.Set(); + } } // declared private instance methods: @@ -223,12 +278,21 @@ RubyUtils.AppendFormatHexObjectId(result, RubyUtils.GetObjectId(context, self)); result.Append(' '); - if ((self.ThreadState & ThreadState.WaitSleepJoin) != 0) { - result.Append("sleep"); - } else if ((self.ThreadState & (ThreadState.Stopped | ThreadState.Aborted | ThreadState.AbortRequested)) != 0) { - result.Append("dead"); - } else { - result.Append("run"); + RubyThreadStatus status = GetStatus(self); + switch (status) { + case RubyThreadStatus.Unstarted: + result.Append("unstarted"); + break; + case RubyThreadStatus.Running: + result.Append("run"); + break; + case RubyThreadStatus.Sleeping: + result.Append("sleep"); + break; + case RubyThreadStatus.Completed: + case RubyThreadStatus.Aborted: + result.Append("dead"); + break; } result.Append('>'); @@ -276,7 +340,11 @@ [RubyMethod("terminate")] public static Thread Kill(Thread/*!*/ self) { RubyThreadInfo.RegisterThread(Thread.CurrentThread); +#if SILVERLIGHT // Thread.Abort(stateInfo) self.Abort(); +#else + self.Abort(new ThreadExitMarker()); +#endif return self; } @@ -315,28 +383,65 @@ #if !SILVERLIGHT [RubyMethod("run", BuildConfig = "!SILVERLIGHT")] [RubyMethod("wakeup", BuildConfig = "!SILVERLIGHT")] - public static void Run(Thread/*!*/ self) { + public static Thread Run(Thread/*!*/ self) { RubyThreadInfo.RegisterThread(Thread.CurrentThread); - self.Interrupt(); + RubyThreadInfo info = RubyThreadInfo.FromThread(self); + info.Run(); + return self; } #endif + private static RubyThreadStatus GetStatus(Thread thread) { + ThreadState state = thread.ThreadState; + RubyThreadInfo info = RubyThreadInfo.FromThread(thread); + + if ((state & ThreadState.Unstarted) == ThreadState.Unstarted) { + if (info.CreatedFromRuby) { + // Ruby threads do not have an unstarted status. We must be in the tiny window when ThreadOps.CreateThread + // created the thread, but has not called Thread.Start on it yet. + return RubyThreadStatus.Running; + } else { + // This is a thread created from outside Ruby. In such a case, we do not know when Thread.Start + // will be called on it. So we report it as unstarted. + return RubyThreadStatus.Unstarted; + } + } + + if ((state & (ThreadState.Stopped|ThreadState.Aborted)) != 0) { + if (RubyThreadInfo.FromThread(thread).Exception == null) { + return RubyThreadStatus.Completed; + } else { + return RubyThreadStatus.Aborted; + } + } + + if ((state & ThreadState.WaitSleepJoin) == ThreadState.WaitSleepJoin) { + return RubyThreadStatus.Sleeping; + } + + if ((state & ThreadState.Running) == ThreadState.Running) { + return RubyThreadStatus.Running; + } + + throw new ArgumentException("unknown thread status: " + state); + } + [RubyMethod("status")] public static object Status(Thread/*!*/ self) { RubyThreadInfo.RegisterThread(Thread.CurrentThread); - switch (self.ThreadState) { - case ThreadState.WaitSleepJoin: + switch (GetStatus(self)) { + case RubyThreadStatus.Unstarted: + return MutableString.Create("unstarted"); + case RubyThreadStatus.Running: + return MutableString.Create("run"); + case RubyThreadStatus.Sleeping: return MutableString.Create("sleep"); - case ThreadState.Running: - return MutableString.Create("run"); - case ThreadState.Aborted: - case ThreadState.AbortRequested: + case RubyThreadStatus.Completed: + return false; + case RubyThreadStatus.Aborted: return null; - case ThreadState.Stopped: - case ThreadState.StopRequested: - return false; default: - throw new ArgumentException("unknown thread status: " + self.ThreadState.ToString()); + throw new ArgumentException("unknown thread status"); } } @@ -400,8 +505,30 @@ return result; } - // main + /// + /// Thread#exit is implemented by calling Thread.Abort. However, we need to distinguish a call to Thread#exit + /// from a raw call to Thread.Abort. + /// + /// true if the exception was raised by Thread#exit. In that case, it should not be treated as an uncaught exception + private static bool IsRubyThreadExit(Exception e) { + ThreadAbortException tae = e as ThreadAbortException; + if (tae != null) { +#if SILVERLIGHT // Thread.ExceptionState + return true; +#else + if (tae.ExceptionState is ThreadExitMarker) { + return true; + } +#endif + } + return false; + } + [RubyMethod("main", RubyMethodAttributes.PublicSingleton)] + public static Thread/*!*/ GetMainThread(RubyContext/*!*/ context, RubyClass self) { + return context.MainThread; + } + [RubyMethod("new", RubyMethodAttributes.PublicSingleton)] [RubyMethod("start", RubyMethodAttributes.PublicSingleton)] public static Thread/*!*/ CreateThread(RubyContext/*!*/ context, BlockParam startRoutine, object self, [NotNull]params object[]/*!*/ args) { @@ -411,6 +538,8 @@ ThreadGroup group = Group(Thread.CurrentThread); Thread result = new Thread(new ThreadStart(delegate() { RubyThreadInfo info = RubyThreadInfo.FromThread(Thread.CurrentThread); + info.CreatedFromRuby = true; + info.Group = group; try { @@ -418,28 +547,31 @@ // TODO: break? startRoutine.Yield(args, out threadResult); info.Result = threadResult; + } catch (Exception e) { + if (IsRubyThreadExit(e)) { + Utils.Log(String.Format("Thread {0} exited.", info.Thread.ManagedThreadId), "THREAD"); #if !SILVERLIGHT - } catch (ThreadInterruptedException) { - // Do nothing with this for now + Thread.ResetAbort(); #endif - } catch (Exception e) { - info.Exception = e; + } else { + info.Exception = e; - StringBuilder trace = new StringBuilder(); - trace.Append(e.Message); - trace.AppendLine(); - trace.AppendLine(); - trace.Append(e.StackTrace); - trace.AppendLine(); - trace.AppendLine(); - foreach (var frame in RubyExceptionData.GetInstance(e).Backtrace) { - trace.Append(frame.ToString()); - } + StringBuilder trace = new StringBuilder(); + trace.Append(e.Message); + trace.AppendLine(); + trace.AppendLine(); + trace.Append(e.StackTrace); + trace.AppendLine(); + trace.AppendLine(); + foreach (var frame in RubyExceptionData.GetInstance(e).Backtrace) { + trace.Append(frame.ToString()); + } - Utils.Log(trace.ToString(), "THREAD"); + Utils.Log(trace.ToString(), "THREAD"); - if (_globalAbortOnException || info.AbortOnException) { - throw; + if (_globalAbortOnException || info.AbortOnException) { + throw; + } } } })); @@ -458,7 +590,15 @@ public static void Stop(object self) { RubyThreadInfo.RegisterThread(Thread.CurrentThread); // TODO: MRI throws an exception if you try to stop the main thread - Thread.Sleep(Timeout.Infinite); + RubyThreadInfo info = RubyThreadInfo.FromThread(Thread.CurrentThread); + info.Sleep(); } + + [RubyMethod("stop?", RubyMethodAttributes.PublicInstance)] + public static bool IsStopped(Thread self) { + RubyThreadInfo.RegisterThread(Thread.CurrentThread); + RubyThreadStatus status = GetStatus(self); + return status == RubyThreadStatus.Sleeping || status == RubyThreadStatus.Completed || status == RubyThreadStatus.Aborted; + } } } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs;C669880 File: RubyModule.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs;C669880 (server) 12/15/2008 10:45 AM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Builtins/RubyModule.cs;Thread @@ -215,13 +215,15 @@ } internal virtual void EnsureInitialized() { - if (_state == State.Uninitialized) { - for (int i = 0; i < _mixins.Length; i++) { - _mixins[i].EnsureInitialized(); - } + lock(this) { // TODO: There is more work to be done to improve module initialization thread-safety and performance + if (_state == State.Uninitialized) { + for (int i = 0; i < _mixins.Length; i++) { + _mixins[i].EnsureInitialized(); + } - if (_state == State.Uninitialized) { - InitializeMembers(); + if (_state == State.Uninitialized) { + InitializeMembers(); + } } } } =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyContext.cs;C674241 File: RubyContext.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyContext.cs;C674241 (server) 12/15/2008 4:20 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyContext.cs;Thread @@ -89,6 +89,11 @@ private static KCode _kcode; /// + /// Thread#main + /// + private Thread _mainThread; + + /// /// $/, $-O /// private MutableString _inputSeparator; @@ -259,6 +264,10 @@ get { return _kcode; } } + public Thread MainThread { + get { return _mainThread; } + } + public MutableString InputSeparator { get { return _inputSeparator; } set { _inputSeparator = value; } @@ -380,6 +389,7 @@ _stringSeparator = null; _itemSeparator = null; _kcode = KCode.Default; + _mainThread = Thread.CurrentThread; if (_options.Verbosity <= 0) { Verbose = null; =================================================================== edit: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyExceptionData.cs;C651054 File: RubyExceptionData.cs =================================================================== --- $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyExceptionData.cs;C651054 (server) 12/15/2008 3:54 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/Merlin/Main/Languages/Ruby/Ruby/Runtime/RubyExceptionData.cs;Thread @@ -72,11 +72,11 @@ SetCompiledTrace(); } - AddBacktrace(result, _throwSiteTrace.GetFrames(), hasFileAccessPermissions, skipFrames); + AddBacktrace(result, _throwSiteTrace.GetFrames(), hasFileAccessPermissions, skipFrames, false); #endif if (_catchSiteTrace != null) { // skip one frame - the catch-site frame is already included - AddBacktrace(result, _catchSiteTrace.GetFrames(), hasFileAccessPermissions, 1); + AddBacktrace(result, _catchSiteTrace.GetFrames(), hasFileAccessPermissions, 1, false); } _backtrace = result; @@ -127,8 +127,8 @@ _backtraceInitialized = true; } - public static RubyArray/*!*/ CreateBacktrace(IEnumerable/*!*/ stackTrace, int skipFrames) { - return AddBacktrace(new RubyArray(), stackTrace, DetectFileAccessPermissions(), skipFrames); + internal static RubyArray/*!*/ CreateBacktrace(RubyContext/*!*/ context, IEnumerable/*!*/ stackTrace, int skipFrames) { + return AddBacktrace(new RubyArray(), stackTrace, DetectFileAccessPermissions(), skipFrames, context.Options.ExceptionDetail); } public static RubyArray/*!*/ CreateBacktrace(RubyContext/*!*/ context, int skipFrames) { @@ -142,7 +142,7 @@ #else StackTrace trace = new StackTrace(true); #endif - return AddBacktrace(new RubyArray(), trace.GetFrames(), DetectFileAccessPermissions(), skipFrames); + return AddBacktrace(new RubyArray(), trace.GetFrames(), DetectFileAccessPermissions(), skipFrames, context.Options.ExceptionDetail); } } @@ -188,11 +188,11 @@ } private static RubyArray/*!*/ AddBacktrace(RubyArray/*!*/ result, IEnumerable stackTrace, bool hasFileAccessPermission, - int skipFrames) { + int skipFrames, bool exceptionDetail) { if (stackTrace != null) { foreach (StackFrame frame in stackTrace) { - if (IsVisibleFrame(frame.GetMethod())) { + if (IsVisibleFrame(frame.GetMethod()) || exceptionDetail) { if (skipFrames == 0) { string methodName, file; int line; =================================================================== edit: $/Dev10/feature/vs_langs01/ndp/fx/src/Core/Microsoft/Scripting/Ast/ExpressionWriter.cs;C669698 File: ExpressionWriter.cs =================================================================== --- $/Dev10/feature/vs_langs01/ndp/fx/src/Core/Microsoft/Scripting/Ast/ExpressionWriter.cs;C669698 (server) 12/14/2008 11:20 PM +++ Shelved Change: $/Dev10/feature/vs_langs01/ndp/fx/src/Core/Microsoft/Scripting/Ast/ExpressionWriter.cs;Thread @@ -528,6 +528,10 @@ } private static bool NeedsParentheses(Expression parent, Expression child) { + Debug.Assert(parent != null); + if (child == null) { + return false; + } return GetOperatorPrecedence(child) < GetOperatorPrecedence(parent); } =================================================================== edit: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/critical_tags.txt;C659732 File: critical_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/critical_tags.txt;C659732 (server) 12/11/2008 3:27 PM +++ Shelved Change: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/critical_tags.txt;Thread @@ -36,9 +36,6 @@ core\string\hex_tags.txt:3:critical:String#hex returns 0 on error core\string\oct_tags.txt:3:critical:String#oct takes an optional sign core\string\oct_tags.txt:3:critical:String#oct returns 0 on error -core\thread\inspect_tags.txt:2:critical:Thread#inspect describes a sleeping thread -core\thread\stop_tags.txt:2:critical:Thread.stop resets Thread.critical to false -core\thread\stop_tags.txt:0:critical:Thread#stop? reports if a thread has stopped due to sleeping language\method_tags.txt:0:critical:Calling a method fails with both lambda and block argument library\mathn\rational\power2_tags.txt:0:critical:Rational#power2 when passed [Rational] returns Rational.new!(1, 1) when the passed argument is 0 library\mathn\rational\power2_tags.txt:0:critical:Rational#power2 when passed [Rational] returns the Rational value of self raised to the passed argument =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/exit_tags.txt;C638190 File: exit_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/exit_tags.txt;C638190 (server) 12/15/2008 11:30 AM +++ [no target file] @@ -1,1 +1,0 @@ -fails:Thread#exit does not deadlock when called from within the thread while being joined from without =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/inspect_tags.txt;C638190 File: inspect_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/inspect_tags.txt;C638190 (server) 12/15/2008 11:31 AM +++ [no target file] @@ -1,1 +1,0 @@ -critical:Thread#inspect describes a sleeping thread =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/kill_tags.txt;C638190 File: kill_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/kill_tags.txt;C638190 (server) 12/15/2008 4:09 PM +++ [no target file] @@ -1,1 +1,0 @@ -fails:Thread#kill does not deadlock when called from within the thread while being joined from without =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/list_tags.txt;C638190 File: list_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/list_tags.txt;C638190 (server) 12/15/2008 4:10 PM +++ [no target file] @@ -1,1 +1,0 @@ -fails:Thread::list includes the current and main thread =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/main_tags.txt;C638190 File: main_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/main_tags.txt;C638190 (server) 12/15/2008 4:24 PM +++ [no target file] @@ -1,1 +1,0 @@ -fails:Thread.main returns the main thread =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/status_tags.txt;C638190 File: status_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/status_tags.txt;C638190 (server) 12/15/2008 4:25 PM +++ [no target file] @@ -1,1 +1,0 @@ -fails:Thread#status returns nil if thread terminates with exception =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/stop_tags.txt;C638190 File: stop_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/stop_tags.txt;C638190 (server) 12/15/2008 4:25 PM +++ [no target file] @@ -1,3 +1,0 @@ -critical:Thread.stop resets Thread.critical to false -critical:Thread#stop? reports if a thread has stopped due to sleeping -fails:Thread.stop causes the current thread to sleep indefinitely =================================================================== delete: $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/terminate_tags.txt;C638190 File: terminate_tags.txt =================================================================== --- $/Merlin_External/Languages/IronRuby/mspec/ironruby-tags/1.8/core/thread/terminate_tags.txt;C638190 (server) 12/15/2008 4:25 PM +++ [no target file] @@ -1,1 +1,0 @@ -fails:Thread#terminate does not deadlock when called from within the thread while being joined from without ===================================================================