More proper evaluation aborting.

Author: nerzhulart

Mono.Debugging.Soft/SoftDebuggerAdaptor.cs

@@ -32,7 +32,6 @@
 using System.Reflection.Emit;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
-using System.Threading;
 using System.Threading.Tasks;
 using Mono.Debugger.Soft;
 using Mono.Debugging.Backend;
@@ -2191,11 +2190,7 @@ public override string Description {
 			}
 		}
 
-		protected override void AfterCancelledImpl (int elapsedAfterCancelMs)
-		{
-		}
-
-		protected override Task<OperationResult<Value>> InvokeAsyncImpl (CancellationToken token)
+		protected override Task<OperationResult<Value>> InvokeAsyncImpl ()
 		{
 			try {
 				var optionsToInvoke = options;
@@ -2204,14 +2199,15 @@ protected override Task<OperationResult<Value>> InvokeAsyncImpl (CancellationTok
 				}
 				var tcs = new TaskCompletionSource<OperationResult<Value>> ();
 				invokeAsyncResult = (IInvokeAsyncResult)obj.BeginInvokeMethod (ctx.Thread, function, args, optionsToInvoke, ar => {
+					if (Token.IsCancellationRequested) {
+						tcs.SetCanceled ();
+						return;
+					}
 					try {
 						var endInvokeResult = obj.EndInvokeMethodWithResult (ar);
-						token.ThrowIfCancellationRequested ();
 						tcs.SetResult (new SoftOperationResult (endInvokeResult.Result, false, endInvokeResult.OutArgs));
 					}
 					catch (InvocationException ex) {
-						// throw OCE if cancelled
-						token.ThrowIfCancellationRequested ();
 						if (ex.Exception != null) {
 							tcs.SetResult (new SoftOperationResult (ex.Exception, true, null));
 						}
@@ -2222,7 +2218,6 @@ protected override Task<OperationResult<Value>> InvokeAsyncImpl (CancellationTok
 					catch (CommandException e) {
 						if (e.ErrorCode == ErrorCode.INVOKE_ABORTED) {
 							tcs.TrySetCanceled ();
-							token.ThrowIfCancellationRequested ();
 						}
 						else {
 							tcs.SetException (new EvaluatorException (e.Message));
@@ -2279,7 +2274,7 @@ void UpdateSessionState ()
 			ctx.Session.StackVersion++;
 		}
 
-		protected override void CancelImpl ()
+		protected override void AbortImpl (int abortCallTimes)
 		{
 			if (invokeAsyncResult == null) {
 				DebuggerLoggingService.LogError ("invokeAsyncResult is null", new ArgumentNullException ("invokeAsyncResult"));

Mono.Debugging/Mono.Debugging.Evaluation/AsyncOperationBase.cs

@@ -32,7 +32,7 @@ public interface IAsyncOperationBase
 	{
 		Task RawTask { get; }
 		string Description { get; }
-		void AfterCancelled (int elapsedAfterCancelMs);
+		void Abort ();
 	}
 
 	public abstract class AsyncOperationBase<TValue> : IAsyncOperationBase
@@ -49,40 +49,46 @@ public Task RawTask
 
 		public abstract string Description { get; }
 
-		public void AfterCancelled (int elapsedAfterCancelMs)
+		int abortCalls = 0;
+
+		readonly CancellationTokenSource tokenSource = new CancellationTokenSource ();
+
+		/// <summary>
+		/// When evaluation is aborted and debugger callback is invoked the implementation has to check
+		/// for Token.IsCancellationRequested and call Task.SetCancelled() instead of setting the result
+		/// </summary>
+		protected CancellationToken Token { get { return tokenSource.Token; } }
+
+		public void Abort ()
 		{
 			try {
-				AfterCancelledImpl (elapsedAfterCancelMs);
+				tokenSource.Cancel();
+				AbortImpl (Interlocked.Increment (ref abortCalls) - 1);
+			}
+			catch (OperationCanceledException) {
+				// if CancelImpl throw OCE we shouldn't mute it
+				throw;
 			}
 			catch (Exception e) {
-				DebuggerLoggingService.LogError ("AfterCancelledImpl() thrown an exception", e);
+				DebuggerLoggingService.LogMessage ("Exception in CancelImpl(): {0}", e.Message);
 			}
 		}
 
-		protected abstract void AfterCancelledImpl (int elapsedAfterCancelMs);
-
-		public Task<OperationResult<TValue>> InvokeAsync (CancellationToken token)
+		public Task<OperationResult<TValue>> InvokeAsync ()
 		{
 			if (Task != null) throw new Exception("Task must be null");
-
-			token.Register (() => {
-				try {
-					CancelImpl ();
-				}
-				catch (OperationCanceledException) {
-					// if CancelImpl throw OCE we shouldn't mute it
-					throw;
-				}
-				catch (Exception e) {
-					DebuggerLoggingService.LogMessage ("Exception in CancelImpl(): {0}", e.Message);
-				}
-			});
-			Task = InvokeAsyncImpl (token);
+			Task = InvokeAsyncImpl ();
 			return Task;
 		}
-		protected abstract Task<OperationResult<TValue>> InvokeAsyncImpl (CancellationToken token);
 
-		protected abstract void CancelImpl ();
+		protected abstract Task<OperationResult<TValue>> InvokeAsyncImpl ();
+
+		/// <summary>
+		/// The implementation has to tell the debugger to abort the evaluation. This method must bot block.
+		/// </summary>
+		/// <param name="abortCallTimes">indicates how many times this method has been already called for this evaluation.
+		/// E.g. the implementation can perform some 'rude abort' after several previous ordinary 'aborts' were failed. For the first call this parameter == 0</param>
+		protected abstract void AbortImpl (int abortCallTimes);
 
 	}
 }

Mono.Debugging/Mono.Debugging.Evaluation/AsyncOperationManager.cs

@@ -28,7 +28,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 using Mono.Debugging.Client;
 
@@ -39,12 +38,9 @@ public class AsyncOperationManager : IDisposable
 		class OperationData
 		{
 			public IAsyncOperationBase Operation { get; private set; }
-			public CancellationTokenSource TokenSource { get; private set; }
-
-			public OperationData (IAsyncOperationBase operation, CancellationTokenSource tokenSource)
+			public OperationData (IAsyncOperationBase operation)
 			{
 				Operation = operation;
-				TokenSource = tokenSource;
 			}
 		}
 
@@ -74,13 +70,12 @@ public OperationResult<TValue> Invoke<TValue> (AsyncOperationBase<TValue> mc, in
 
 			Task<OperationResult<TValue>> task;
 			var description = mc.Description;
-			var cts = new CancellationTokenSource ();
-			var operationData = new OperationData (mc, cts);
+			var operationData = new OperationData (mc);
 			lock (currentOperations) {
 				if (disposed)
 					throw new ObjectDisposedException ("Already disposed");
 				DebuggerLoggingService.LogMessage (string.Format("Starting invoke for {0}", description));
-				task = mc.InvokeAsync (cts.Token);
+				task = mc.InvokeAsync ();
 				currentOperations.Add (operationData);
 			}
 
@@ -91,7 +86,7 @@ public OperationResult<TValue> Invoke<TValue> (AsyncOperationBase<TValue> mc, in
 					return task.Result;
 				}
 				DebuggerLoggingService.LogMessage (string.Format ("Invoke {0} timed out after {1} ms. Cancelling.", description, timeout));
-				cts.Cancel ();
+				mc.Abort ();
 				try {
 					WaitAfterCancel (mc);
 				}
@@ -127,7 +122,7 @@ public OperationResult<TValue> Invoke<TValue> (AsyncOperationBase<TValue> mc, in
 		void ChangeBusyState (bool busy, string description)
 		{
 			try {
-				BusyStateChanged (this, new BusyStateEventArgs {IsBusy = true, Description = description});
+				BusyStateChanged (this, new BusyStateEventArgs {IsBusy = busy, Description = description});
 			}
 			catch (Exception e) {
 				DebuggerLoggingService.LogError ("Exception during ChangeBusyState", e);
@@ -138,24 +133,21 @@ void WaitAfterCancel (IAsyncOperationBase op)
 		{
 			var desc = op.Description;
 			DebuggerLoggingService.LogMessage (string.Format ("Waiting for cancel of invoke {0}", desc));
-			try {
-				if (!op.RawTask.Wait (ShortCancelTimeout)) {
-					try {
-						ChangeBusyState (true, desc);
-						op.RawTask.Wait (Timeout.Infinite);
-					}
-					finally {
-						ChangeBusyState (false, desc);
+			if (!op.RawTask.Wait (ShortCancelTimeout)) {
+				try {
+					ChangeBusyState (true, desc);
+					while (true) {
+						op.Abort ();
+						if (op.RawTask.Wait (ShortCancelTimeout))
+							break;
 					}
 				}
-			}
-			finally {
-				DebuggerLoggingService.LogMessage (string.Format ("Calling AfterCancelled() for {0}", desc));
-				op.AfterCancelled (ShortCancelTimeout);
+				finally {
+					ChangeBusyState (false, desc);
+				}
 			}
 		}
 
-
 		public void AbortAll ()
 		{
 			DebuggerLoggingService.LogMessage ("Aborting all the current invocations");
@@ -174,7 +166,7 @@ void CancelOperations (List<OperationData> operations, bool wait)
 			foreach (var operationData in operations) {
 				var taskDescription = operationData.Operation.Description;
 				try {
-					operationData.TokenSource.Cancel ();
+					operationData.Operation.Abort ();
 					if (wait) {
 						WaitAfterCancel (operationData.Operation);
 					}