Use IAsyncEnumerable in NavigateTo OOP calls. #64576

CyrusNajmabadi · 2022-10-07T20:54:56Z

CyrusNajmabadi · 2022-10-07T20:57:08Z

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.CachedDocumentSearch.cs

                storageService, patternName, patternContainer, declaredSymbolInfoKindsSet,
-                onItemFound, priorityDocumentKeys, cancellationToken).ConfigureAwait(false);
+                priorityDocumentKeys, cancellationToken).WithCancellation(cancellationToken))


@jcouv do i need to call .WithCancellation in all these plaes? i'm annotating all async IAsyncEnumerable methods with the appropriate [EnumeratorCancellation] attribute, so i'm hping the answer is 'no'.

If that WithCancellation is an extension method defined in the MS.VS.Threading assembly, then it certainly isn't necessary.

@CyrusNajmabadi That's correct. .WithCancellation(...) isn't needed when the method is annotated with [EnumeratorCancellation] and you're passing the cancellation token.
http://blog.monstuff.com/archives/2019/03/async-enumerables-with-cancellation.html

CyrusNajmabadi · 2022-10-07T20:57:58Z

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.CachedDocumentSearch.cs


-            await Task.WhenAll(tasks).ConfigureAwait(false);
+            return builder.ToArray().MergeAsync(cancellationToken);


MergeAsync (which you'll see later in the PR) allows us to take N IAsyncEnumerables and combine them into a single final stream. the individual values can all be interleaved.

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs

CyrusNajmabadi · 2022-10-07T20:59:15Z

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.CachedDocumentSearch.cs

-                        return;
-
-                    await ProcessIndexAsync(
-                        documentKey.Id, document: null, patternName, patternContainer, kinds, onItemFound, index, cancellationToken).ConfigureAwait(false);


this code was extracted to a helper called ProcessStaleIndexAsync (in another file).

CyrusNajmabadi · 2022-10-07T20:59:33Z

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs

        }

-        private static async Task ProcessIndexAsync(
+        private static async IAsyncEnumerable<RoslynNavigateToItem> ProcessStaleIndexAsync(


here is the moved method.

CyrusNajmabadi · 2022-10-07T21:00:14Z

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs

+            }
+            else
+            {
+                return null;


this is the deepest part of the stream where the actual values are create and bubble up. everything above this is just passing the values back.

CyrusNajmabadi · 2022-10-07T21:00:51Z

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.cs

+            Solution solution,
+            Document? activeDocument,
+            IAsyncEnumerable<RoslynNavigateToItem> items,
+            [EnumeratorCancellation] CancellationToken cancellationToken)


this is effectively a .WhereAsync for IAsyncEnumerable.

CyrusNajmabadi · 2022-10-07T21:01:11Z

src/Features/Core/Portable/NavigateTo/IRemoteNavigateToSearchService.cs


        ValueTask HydrateAsync(Checksum solutionChecksum, CancellationToken cancellationToken);
-
-        public interface ICallback


no more remote callback. woot :)

src/Workspaces/Core/Portable/Remote/RemoteHostClient.cs

CyrusNajmabadi · 2022-10-07T21:03:40Z

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs

+        {
+            yield break;
+        }
+#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously


this is the simplest way i can find to just make a singleon empty IAsyncEnumerable. Would be nice to have this in teh BCL :)

Is there any efficiency concerns by not doing this more directly? I agree anything else seems like a PITA though to do.

i'm not sure what woudl be the "more directly" approach :)

CyrusNajmabadi · 2022-10-07T21:04:10Z

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs

+        /// <remarks>This helper is useful when doign parallel processing of work where each job returns an <see
+        /// cref="IAsyncEnumerable{T}"/>, but one final stream is desired as the result.</remarks>
+        public static IAsyncEnumerable<T> MergeAsync<T>(this IAsyncEnumerable<T>[] enumerables, CancellationToken cancellationToken)
+        {


@stephentoub for auditing this as well. it feels very sane, but i'd still like your eyes.

CyrusNajmabadi · 2022-10-07T21:05:41Z

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

    /// <summary>
    /// Workspace created by the remote host that mirrors the corresponding client workspace.
    /// </summary>
    internal sealed partial class RemoteWorkspace : Workspace
    {
+        public sealed class PinnedSolution : System.IAsyncDisposable


this portion of the PR is the scariest. Prior to this PR we had the model where remote services pass a simple async callback to do work to RemoteWorkspace. RemoteWorkspace itself pins the solution and invokes the simple callback.

this is no longer simple as we have to support streaming and we have to ensure the solution is pinned while that happens. Once done with the streaming we have to unpin the solution. (or, decrement the ref count on it and unpin iif it goes to zero).

CyrusNajmabadi · 2022-10-07T21:06:34Z

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

+            {
+                throw ExceptionUtilities.Unreachable();
+            }
+        }


this is the bridge to from the existing pattern (which works for all non-streaming cases) to the nwe functionality. It aims to be extremely trivial. specifically, it gets the pinnedSolution, then immediately puts it in a using so it will clean up. I then runs the client-provided helper to actually do work.

CyrusNajmabadi · 2022-10-07T21:07:31Z

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

+            try
+            {
+                var pinnedSolution = await GetPinnedSolutionAsync(assetProvider, solutionChecksum, workspaceVersion, updatePrimaryBranch, cancellationToken).ConfigureAwait(false);
+                await using (pinnedSolution.ConfigureAwait(false))


@stephentoub the need for the two .ConfigureAwaits seems... really unfortunate. It's also scary to see the acquisition of the IAsyncDisposable, and then a separate statement before it it actually placed into the using.

Is there a better way to do this?

CyrusNajmabadi · 2022-10-07T21:08:37Z

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

@@ -13,15 +13,34 @@
 using Microsoft.CodeAnalysis.SolutionCrawler;


@dibarbet for eyes on the changes in this file as well as you were heavily involved with the last refactoring here.

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs

CyrusNajmabadi · 2022-10-11T04:49:02Z

@jasonmalinowski @tmat @dibarbet ptal. thanks!

alrz · 2022-10-11T09:55:44Z

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs

+            // allow reading to complete as well.
+            Task.WhenAll(tasks).ContinueWith(
+                t => channel.Writer.Complete(t.Exception),
+                CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);


Curious if TaskContinuationOptions.ExecuteSynchronously makes sense here.

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs

dibarbet

I don't see any obvious issues in the pinned solution bits, just a couple of suggestions for cleanup

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.PinnedSolution.cs

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

src/Workspaces/Remote/ServiceHub/Services/BrokeredServiceBase.cs

CyrusNajmabadi · 2022-10-12T20:35:41Z

@dibarbet @jasonmalinowski @tmat ptal. thanks!

dibarbet

pinned solution bits seem fine. Rest also seems OK but someone else should also review those bits :)

src/Workspaces/Remote/ServiceHub/Services/NavigateToSearch/RemoteNavigateToSearchService.cs

…oteNavigateToSearchService.cs Co-authored-by: David Barbet <[email protected]>

CyrusNajmabadi · 2022-10-14T17:15:38Z

@jasonmalinowski ptal :)

jasonmalinowski

My signoff here doesn't really count for the pinned solution changes, since I don't know that code well enough to know if anything is really getting worse there. There's some tiny fishy bits, but hopefully somebody else can confirm everything is fine.

Overall wow this is so much nicer, I can't wait to use more IAsyncEnumerable in other places, I think!

jasonmalinowski · 2022-10-14T22:24:05Z

src/Features/Core/Portable/NavigateTo/NavigateToSearcher.cs

+            await foreach (var item in service.SearchDocumentAsync(
+                _activeDocument, _searchPattern, _kinds, _activeDocument, cancellationToken))
+            {
+                await _callback.AddItemAsync(project, item, cancellationToken).ConfigureAwait(false);


Should we keep pushing the pattern further up higher, or was this a convenient stopping point?

this is effectively the top level entrypoint (or close enough to not make moving up any more matter :))

jasonmalinowski · 2022-10-14T22:29:35Z

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs

+        {
+            yield break;
+        }
+#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously


Is there any efficiency concerns by not doing this more directly? I agree anything else seems like a PITA though to do.

jasonmalinowski · 2022-10-14T22:34:38Z

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs

+            // Note: passing CancellationToken.None here is intentional/correct.  We must complete all the channels to
+            // allow reading to complete as well.


How does cancellation work? In the cancelled case, is the exception here an OperationCancelledException, or something else? And since Exception here actually returns an aggregate exception, is that going to cause us to wrap exceptions when we don't expect it? Or does .Complete() here do unwrapping of the aggregate exception?

this is a good question. i'll wait on @stephentoub to explain this because i'm not actually sure if this handled cancellation properly.

From muy reading, you'll get an AggregateException wrapping all the cancellation exceptions. i think the TPL sees through this when completing the writer (and then exposing that on the reader side), so you hopefully just get cancellation on the reading side.

But i'm not sure. @stephentoub for insights.

i just debugged this with a little test. The task you get here is:

Note that it is in the canceled state, but .Exception is null. From teh docs, this is what is said:

If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

If you're waiting on a Task that transitions to the Canceled state, a System.Threading.Tasks.TaskCanceledException exception (wrapped in an AggregateException exception) is thrown. This exception indicates successful cancellation instead of a faulty situation. Therefore, the task's Exception property returns null.

The last line is particularly relevant.

So it seems like task.Exception is null in this case. This is also something you can trivially demonstrate by doing Task.FromCanceled(canceledToken) and checking .Exception on that.

So i think we're all good here. Will comment in next pr.

jasonmalinowski · 2022-10-14T22:37:35Z

src/Workspaces/Remote/ServiceHub/Services/NavigateToSearch/RemoteNavigateToSearchService.cs

+
+            // Intentionally do not call GetSolutionAsync here.  We do not want the cost of
+            // synchronizing the solution over to the remote side.  Instead, we just directly
+            // check whatever cached data we have from the previous vs session.


Suggested change

// check whatever cached data we have from the previous vs session.

// check whatever cached data we have from the previous VS session.

I recognize not new, but lowercase "vs" means "versus" to me.

done in next pr.

jasonmalinowski · 2022-10-14T22:38:56Z

src/Workspaces/Remote/ServiceHub/Services/NavigateToSearch/RemoteNavigateToSearchService.cs

-                await AbstractNavigateToSearchService.SearchGeneratedDocumentsInCurrentProcessAsync(
-                    project, searchPattern, kinds.ToImmutableHashSet(), callback, cancellationToken).ConfigureAwait(false);
-            }, cancellationToken);
+                await foreach (var item in AbstractNavigateToSearchService.SearchGeneratedDocumentsInCurrentProcessAsync(


Maybe dumb question here: why did this need an await + yield versus just returning directly the SearchGeneratedDocumentsInCurrentProcessAsync return? I don't see any other yielding/async but maybe I'm missing something.

you are correct. t his doesn't need await/yield. i can fixup later :)

done in next pr.

src/Workspaces/Remote/ServiceHub/Services/NavigateToSearch/RemoteNavigateToSearchService.cs

jasonmalinowski · 2022-10-14T22:41:57Z

src/EditorFeatures/CSharpTest/NavigateTo/NavigateToSearcherTests.cs

            }
        }

+#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously


This seems odd: can we delete the async keyword here, or is this a compiler bug?

no. unfortunately, you must use async to use yield to create an IAsyncEnumerbale (not sure why tbh). So you have to add that modifier, then you have to suppress the warning. @jcouv ?

jasonmalinowski · 2022-10-14T22:45:25Z

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

+                // Ensure we cleanup if an exception occurred.  Otherwise, we'll never release this data.
+                if (exception != null)
+                    await DecrementInFlightCountAsync(inFlightSolution).ConfigureAwait(false);


If the intent is "only run this if we didn't throw an exception", them just move it out of the finally block? I'm confused what's going on here.

so i don't disagree. but my understanding from @tmat is that this is the right pattern to ensure proper async callstacks. if we move this into the catch then we get back stacks (even if we use throw;). @tmat can you elaborate here?

jasonmalinowski · 2022-10-14T22:46:13Z

src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs

            }
-            catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex, cancellationToken, ErrorSeverity.Critical))
+            catch (Exception ex) when ((exception = ex) == null)


What is the == null here? Or intentionally a way to force the block to always be false? This is missing an explanatory comment.

(see earlier comment being unsure why we have a catch/finally at all)

yes. this is a pattern we have in OOP that tomas likes for ensuring callstacks remain good.

jasonmalinowski · 2022-10-14T22:51:36Z

Given @dibarbet signed off on the pinned solution bits but wanting somebody else for everything else, and I'm signing off on everything except the pinned solution bits, I think you're good @CyrusNajmabadi. 😄

…amOOP" This reverts commit 83550ee, reversing changes made to 5bf1a43.

Revert #64616 and #64576

…syncStreamOOP"" This reverts commit ccef2a9.

CyrusNajmabadi added 5 commits October 7, 2022 12:06

Initial pattern for async streaming in oop

927494b

Fixup features

5b32fdf

About to do remote side

50d188e

Remote workspace portion

5a80563

Update tests

024122c

dotnet-issue-labeler bot added the Area-IDE label Oct 7, 2022

CyrusNajmabadi requested review from jcouv, jasonmalinowski, tmat and AArnott October 7, 2022 20:55

CyrusNajmabadi commented Oct 7, 2022

View reviewed changes

src/Features/Core/Portable/NavigateTo/AbstractNavigateToSearchService.InProcess.cs Show resolved Hide resolved

CyrusNajmabadi commented Oct 7, 2022

View reviewed changes

Rvert name

2353dde

CyrusNajmabadi commented Oct 7, 2022

View reviewed changes

src/Workspaces/Core/Portable/Remote/RemoteHostClient.cs Show resolved Hide resolved

CyrusNajmabadi commented Oct 7, 2022

View reviewed changes

Add back comment

9f238c1

CyrusNajmabadi commented Oct 7, 2022

View reviewed changes

CyrusNajmabadi added 2 commits October 7, 2022 14:11

Add docs

6e5f9d1

Simplify

579875a

CyrusNajmabadi requested a review from dibarbet October 7, 2022 21:13

Simplify

4145d65

stephentoub reviewed Oct 10, 2022

View reviewed changes

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs Outdated Show resolved Hide resolved

stephentoub reviewed Oct 10, 2022

View reviewed changes

src/Workspaces/Core/Portable/Shared/Extensions/IAsyncEnumerableExtensions.cs Show resolved Hide resolved

CyrusNajmabadi added 3 commits October 10, 2022 13:26

Merge remote-tracking branch 'upstream/main' into asyncStreamOOP

4a09360

Simplify

36c5391

Add back pressure

9b84c12

CyrusNajmabadi mentioned this pull request Oct 10, 2022

Use IAsyncEnumerable in DesignerAttributeScanning as well. #64616

Merged

alrz reviewed Oct 11, 2022

View reviewed changes

dibarbet reviewed Oct 11, 2022

View reviewed changes

remove unnecessary qualification

8aff48a

runfoapp bot mentioned this pull request Oct 12, 2022

roslyn.visualstudio.newintegrationtests.workspaces.workspacesnetcore.projectproperties (vs2022) #64672

Open

CyrusNajmabadi requested a review from dibarbet October 12, 2022 20:35

dibarbet approved these changes Oct 13, 2022

View reviewed changes

src/Workspaces/Remote/ServiceHub/Services/NavigateToSearch/RemoteNavigateToSearchService.cs Outdated Show resolved Hide resolved

Update src/Workspaces/Remote/ServiceHub/Services/NavigateToSearch/Rem…

229228f

…oteNavigateToSearchService.cs Co-authored-by: David Barbet <[email protected]>

This was referenced Oct 14, 2022

FixAllOccurrencesIgnoresGeneratedCode is flaky #56625

Open

csharpsourcegenerators.findreferencesforfilewithdefinitioninsourcegeneratedfile(false) #64721

Closed

jasonmalinowski approved these changes Oct 14, 2022

View reviewed changes

CyrusNajmabadi merged commit 83550ee into dotnet:main Oct 17, 2022

CyrusNajmabadi deleted the asyncStreamOOP branch October 17, 2022 23:29

ghost added this to the Next milestone Oct 17, 2022

CyrusNajmabadi added a commit to CyrusNajmabadi/roslyn that referenced this pull request Oct 20, 2022

Revert "Merge pull request dotnet#64576 from CyrusNajmabadi/asyncStre…

ccef2a9

…amOOP" This reverts commit 83550ee, reversing changes made to 5bf1a43.

JoeRobich added a commit that referenced this pull request Oct 20, 2022

Merge pull request #64873 from CyrusNajmabadi/revertPull

a7f8059

Revert #64616 and #64576

CyrusNajmabadi added a commit to CyrusNajmabadi/roslyn that referenced this pull request Oct 21, 2022

Revert "Revert "Merge pull request dotnet#64576 from CyrusNajmabadi/a…

51fc994

…syncStreamOOP"" This reverts commit ccef2a9.

allisonchou mentioned this pull request Oct 22, 2022

[Automated] PRs inserted in VS build main-33021.259 #64913

Closed

RikkiGibson modified the milestones: Next, 17.5 P1 Oct 24, 2022


		await Task.WhenAll(tasks).ConfigureAwait(false);
		return builder.ToArray().MergeAsync(cancellationToken);


		ValueTask HydrateAsync(Checksum solutionChecksum, CancellationToken cancellationToken);

		public interface ICallback

		@@ -13,15 +13,34 @@
		using Microsoft.CodeAnalysis.SolutionCrawler;

		// Note: passing CancellationToken.None here is intentional/correct. We must complete all the channels to
		// allow reading to complete as well.

	// check whatever cached data we have from the previous vs session.
	// check whatever cached data we have from the previous VS session.

Use IAsyncEnumerable in NavigateTo OOP calls. #64576

Use IAsyncEnumerable in NavigateTo OOP calls. #64576

Conversation

CyrusNajmabadi commented Oct 7, 2022 • edited by Pilchie Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

CyrusNajmabadi commented Oct 11, 2022

Choose a reason for hiding this comment

dibarbet left a comment

Choose a reason for hiding this comment

CyrusNajmabadi commented Oct 12, 2022

dibarbet left a comment

Choose a reason for hiding this comment

CyrusNajmabadi commented Oct 14, 2022

jasonmalinowski left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jasonmalinowski commented Oct 14, 2022

CyrusNajmabadi commented Oct 7, 2022 •

edited by Pilchie

Loading