Skip to content

Changes to AsyncLocal usage for better lazy loading performance #35835

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 8 commits into from
Mar 25, 2025
Merged

Changes to AsyncLocal usage for better lazy loading performance #35835

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
7692c0c
Lazy loader performance
henriquewr Mar 24, 2025
2176e50
Added comments
henriquewr Mar 24, 2025
d2d688e
Removed threadId
henriquewr Mar 24, 2025
03b7b74
Suggestions made
henriquewr Mar 25, 2025
be3d3f3
Comments with wrong variable name
henriquewr Mar 25, 2025
78c9e2e
Accidently send csproj with versions (AutomaticVersions extension)
henriquewr Mar 25, 2025
12297b1
Resetting AsyncLocal.Value when adding a value to _isLoading
henriquewr Mar 25, 2025
0c96445
_isLoadingCallDepth decrement when exiting the method
henriquewr Mar 25, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
37 changes: 22 additions & 15 deletions src/EFCore/Infrastructure/Internal/LazyLoader.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,7 +23,8 @@ public class LazyLoader : ILazyLoader, IInjectableService
private bool _detached;
private IDictionary<string, bool>? _loadedStates;
private readonly Lock _isLoadingLock = new Lock();
private readonly Dictionary<(object Entity, string NavigationName), (TaskCompletionSource TaskCompletionSource, AsyncLocal<int> Depth)> _isLoading = new(NavEntryEqualityComparer.Instance);
private readonly Dictionary<(object Entity, string NavigationName), TaskCompletionSource> _isLoading = new(NavEntryEqualityComparer.Instance);
private static readonly AsyncLocal<int> _isLoadingCallDepth = new();
private HashSet<string>? _nonLazyNavigations;

/// <summary>
Expand Down Expand Up @@ -112,26 +113,28 @@ public virtual void Load(object entity, [CallerMemberName] string navigationName
var navEntry = (entity, navigationName);

bool exists;
(TaskCompletionSource TaskCompletionSource, AsyncLocal<int> Depth) isLoadingValue;
TaskCompletionSource isLoadingValue;

lock (_isLoadingLock)
{
ref var refIsLoadingValue = ref CollectionsMarshal.GetValueRefOrAddDefault(_isLoading, navEntry, out exists);
if (!exists)
{
refIsLoadingValue = (new(), new());
refIsLoadingValue = new();
}
_isLoadingCallDepth.Value++;
isLoadingValue = refIsLoadingValue!;
isLoadingValue.Depth.Value++;
}

if (exists)
{
// Only waits for the outermost call on the call stack. See #35528.
if (isLoadingValue.Depth.Value == 1)
// Only waits for the outermost call on the call stack. See #35528.
// if _isLoadingCallDepth.Value > 1 the call is recursive, waiting probably generates a deadlock See #35832.
if (_isLoadingCallDepth.Value == 1)
{
isLoadingValue.TaskCompletionSource.Task.Wait();
isLoadingValue.Task.Wait();
}
_isLoadingCallDepth.Value--;
return;
}

Expand All @@ -156,7 +159,8 @@ public virtual void Load(object entity, [CallerMemberName] string navigationName
}
finally
{
isLoadingValue.TaskCompletionSource.TrySetResult();
isLoadingValue.TrySetResult();
_isLoadingCallDepth.Value--;
lock (_isLoadingLock)
{
_isLoading.Remove(navEntry);
Expand All @@ -181,26 +185,28 @@ public virtual async Task LoadAsync(
var navEntry = (entity, navigationName);

bool exists;
(TaskCompletionSource TaskCompletionSource, AsyncLocal<int> Depth) isLoadingValue;
TaskCompletionSource isLoadingValue;

lock (_isLoadingLock)
{
ref var refIsLoadingValue = ref CollectionsMarshal.GetValueRefOrAddDefault(_isLoading, navEntry, out exists);
if (!exists)
{
refIsLoadingValue = (new(), new());
refIsLoadingValue = new();
}
_isLoadingCallDepth.Value++;
isLoadingValue = refIsLoadingValue!;
isLoadingValue.Depth.Value++;
}

if (exists)
{
// Only waits for the outermost call on the call stack. See #35528.
if (isLoadingValue.Depth.Value == 1)
// Only waits for the outermost call on the call stack. See #35528.
// if _isLoadingCallDepth.Value > 1 the call is recursive, waiting probably generates a deadlock See #35832.
if (_isLoadingCallDepth.Value == 1)
{
await isLoadingValue.TaskCompletionSource.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
await isLoadingValue.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
}
_isLoadingCallDepth.Value--;
return;
}

Expand All @@ -226,7 +232,8 @@ await entry.LoadAsync(
}
finally
{
isLoadingValue.TaskCompletionSource.TrySetResult();
isLoadingValue.TrySetResult();
_isLoadingCallDepth.Value--;
lock (_isLoadingLock)
{
_isLoading.Remove(navEntry);
Expand Down
78 changes: 67 additions & 11 deletions test/EFCore.Specification.Tests/LoadTestBase.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5059,14 +5059,31 @@ public virtual async Task Lazy_loading_is_thread_safe(bool noTracking, bool asyn
var parent = query.Single();

var children = (await parent.LazyLoadChildren(async))?.Select(x => x.Id).OrderBy(x => x).ToList();
var childrenInvert = (await parent.LazyLoadChildren(!async))?.Select(x => x.Id).OrderBy(x => x).ToList();

var singlePkToPk = (await parent.LazyLoadSinglePkToPk(async))?.Id;
var singlePkToPkInvert = (await parent.LazyLoadSinglePkToPk(!async))?.Id;

var single = (await parent.LazyLoadSingle(async))?.Id;
var singleInvert = (await parent.LazyLoadSingle(!async))?.Id;

var childrenAk = (await parent.LazyLoadChildrenAk(async))?.Select(x => x.Id).OrderBy(x => x).ToList();
var childrenAkInvert = (await parent.LazyLoadChildrenAk(!async))?.Select(x => x.Id).OrderBy(x => x).ToList();

var singleAk = (await parent.LazyLoadSingleAk(async))?.Id;
var singleAkInvert = (await parent.LazyLoadSingleAk(!async))?.Id;

var childrenShadowFk = (await parent.LazyLoadChildrenShadowFk(async))?.Select(x => x.Id).OrderBy(x => x).ToList();
var childrenShadowFkInvert = (await parent.LazyLoadChildrenShadowFk(!async))?.Select(x => x.Id).OrderBy(x => x).ToList();

var singleShadowFk = (await parent.LazyLoadSingleShadowFk(async))?.Id;
var singleShadowFkInvert = (await parent.LazyLoadSingleShadowFk(!async))?.Id;

var childrenCompositeKey = (await parent.LazyLoadChildrenCompositeKey(async))?.Select(x => x.Id).OrderBy(x => x).ToList();
var childrenCompositeKeyInvert = (await parent.LazyLoadChildrenCompositeKey(!async))?.Select(x => x.Id).OrderBy(x => x).ToList();

var singleCompositeKey = (await parent.LazyLoadSingleCompositeKey(async))?.Id;
var singleCompositeKeyInvert = (await parent.LazyLoadSingleCompositeKey(!async))?.Id;

var parent2 = query2.Single();

Expand All @@ -5075,18 +5092,57 @@ public virtual async Task Lazy_loading_is_thread_safe(bool noTracking, bool asyn
MaxDegreeOfParallelism = Environment.ProcessorCount * 500
};

await Parallel.ForAsync(0, 50000, parallelOptions, async (i, ct) =>
{
Assert.Equal(children, (await parent2.LazyLoadChildren(async))?.Select(x => x.Id).OrderBy(x => x).ToList());
Assert.Equal(singlePkToPk, (await parent2.LazyLoadSinglePkToPk(async))?.Id);
Assert.Equal(single, (await parent2.LazyLoadSingle(async))?.Id);
Assert.Equal(childrenAk, (await parent2.LazyLoadChildrenAk(async))?.Select(x => x.Id).OrderBy(x => x).ToList());
Assert.Equal(singleAk, (await parent2.LazyLoadSingleAk(async))?.Id);
Assert.Equal(childrenShadowFk, (await parent2.LazyLoadChildrenShadowFk(async))?.Select(x => x.Id).OrderBy(x => x).ToList());
Assert.Equal(singleShadowFk, (await parent2.LazyLoadSingleShadowFk(async))?.Id);
Assert.Equal(childrenCompositeKey, (await parent2.LazyLoadChildrenCompositeKey(async))?.Select(x => x.Id).OrderBy(x => x).ToList());
Assert.Equal(singleCompositeKey, (await parent2.LazyLoadSingleCompositeKey(async))?.Id);
await Parallel.ForAsync(0, 10000, parallelOptions, async (i, ct) =>
{
await Task.WhenAll(
AssertEqual(
(children, async () => (await parent2.LazyLoadChildren(async))?.Select(x => x.Id).OrderBy(x => x).ToList()),
(childrenInvert, async () => (await parent2.LazyLoadChildren(!async))?.Select(x => x.Id).OrderBy(x => x).ToList())
),
AssertEqual(
(singlePkToPk, async () => (await parent2.LazyLoadSinglePkToPk(async))?.Id),
(singlePkToPkInvert, async () => (await parent2.LazyLoadSinglePkToPk(!async))?.Id)
),
AssertEqual(
(single, async () => (await parent2.LazyLoadSingle(async))?.Id),
(singleInvert, async () => (await parent2.LazyLoadSingle(!async))?.Id)
),
AssertEqual(
(childrenAk, async () => (await parent2.LazyLoadChildrenAk(async))?.Select(x => x.Id).OrderBy(x => x).ToList()),
(childrenAkInvert, async () => (await parent2.LazyLoadChildrenAk(!async))?.Select(x => x.Id).OrderBy(x => x).ToList())
),
AssertEqual(
(singleAk, async () => (await parent2.LazyLoadSingleAk(async))?.Id),
(singleAkInvert, async () => (await parent2.LazyLoadSingleAk(!async))?.Id)
),
AssertEqual(
(childrenShadowFk, async () => (await parent2.LazyLoadChildrenShadowFk(async))?.Select(x => x.Id).OrderBy(x => x).ToList()),
(childrenShadowFkInvert, async () => (await parent2.LazyLoadChildrenShadowFk(!async))?.Select(x => x.Id).OrderBy(x => x).ToList())
),
AssertEqual(
(singleShadowFk, async () => (await parent2.LazyLoadSingleShadowFk(async))?.Id),
(singleShadowFkInvert, async () => (await parent2.LazyLoadSingleShadowFk(!async))?.Id)
),
AssertEqual(
(childrenCompositeKey, async () => (await parent2.LazyLoadChildrenCompositeKey(async))?.Select(x => x.Id).OrderBy(x => x).ToList()),
(childrenCompositeKeyInvert, async () => (await parent2.LazyLoadChildrenCompositeKey(!async))?.Select(x => x.Id).OrderBy(x => x).ToList())
),
AssertEqual(
(singleCompositeKey, async () => (await parent2.LazyLoadSingleCompositeKey(async))?.Id),
(singleCompositeKeyInvert, async () => (await parent2.LazyLoadSingleCompositeKey(!async))?.Id)
)
);
});

static async Task AssertEqual<T>((T Data, Func<Task<T>> Expected) data, (T Data, Func<Task<T>> Expected) dataInvert)
{
//Do the processing at the same time
var dataTask = data.Expected();
var dataInvertTask = dataInvert.Expected();

Assert.Equal(data.Data, await dataTask);
Assert.Equal(dataInvert.Data, await dataInvertTask);
}
}

private static void SetState(
Expand Down