From ebaba40a5a9a71da0167b0838d87974240997113 Mon Sep 17 00:00:00 2001 From: Stephen Toub Date: Thu, 29 Sep 2022 12:44:23 -0400 Subject: [PATCH] Return s_defaultResultTask from Task.FromResult in more cases (#76349) * Return s_defaultResultTask from Task.FromResult in more cases Today we return a cached task from Task.FromResult when the TResult is a primitive and its value is 0. But it needn't be constrained to only being a primitive; what matters is that we need to be able to efficiently compare its bit pattern to 0. And we can do that easily now by using Unsafe.SizeOf to check if the size is the same as a primitive, Unsafe casting to that primitive, and then comparing against 0. * Update tests --- .../src/System/Threading/Tasks/Task.cs | 25 ++++++++----------- .../tests/Task/TaskRtTests.cs | 24 +++++++++++++++--- 2 files changed, 31 insertions(+), 18 deletions(-) diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs index 97ebb29c0f503..6230fda260589 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs @@ -5249,21 +5249,18 @@ public static Task FromResult(TResult result) return Unsafe.As>(task); // Unsafe.As avoids a type check we know will succeed } } - // For other known value types, we only special-case 0 / default(TResult). We don't include - // floating point types as == may return true for different bit representations of the same value. - else if ( - (typeof(TResult) == typeof(uint) && default == (uint)(object)result!) || - (typeof(TResult) == typeof(byte) && default(byte) == (byte)(object)result!) || - (typeof(TResult) == typeof(sbyte) && default(sbyte) == (sbyte)(object)result!) || - (typeof(TResult) == typeof(char) && default(char) == (char)(object)result!) || - (typeof(TResult) == typeof(long) && default == (long)(object)result!) || - (typeof(TResult) == typeof(ulong) && default == (ulong)(object)result!) || - (typeof(TResult) == typeof(short) && default(short) == (short)(object)result!) || - (typeof(TResult) == typeof(ushort) && default(ushort) == (ushort)(object)result!) || - (typeof(TResult) == typeof(IntPtr) && default == (IntPtr)(object)result!) || - (typeof(TResult) == typeof(UIntPtr) && default == (UIntPtr)(object)result!)) + // For other value types, we special-case default(TResult) if we can easily compare bit patterns to default/0. + else if (!RuntimeHelpers.IsReferenceOrContainsReferences()) { - return Task.s_defaultResultTask; + // We don't need to go through the equality operator of the TResult because we cached a task for default(TResult), + // so we only need to confirm that this TResult has the same bits as default(TResult). + if ((Unsafe.SizeOf() == sizeof(byte) && Unsafe.As(ref result) == default(byte)) || + (Unsafe.SizeOf() == sizeof(ushort) && Unsafe.As(ref result) == default(ushort)) || + (Unsafe.SizeOf() == sizeof(uint) && Unsafe.As(ref result) == default) || + (Unsafe.SizeOf() == sizeof(ulong) && Unsafe.As(ref result) == default)) + { + return Task.s_defaultResultTask; + } } } diff --git a/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs b/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs index ffb2437aa4b3e..b2f69398af441 100644 --- a/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs +++ b/src/libraries/System.Threading.Tasks/tests/Task/TaskRtTests.cs @@ -512,6 +512,21 @@ public static void FromResult_KnownResults_Cached() Assert.Same(Task.FromResult(UIntPtr.Zero), Task.FromResult(UIntPtr.Zero)); Assert.Equal(UIntPtr.Zero, Task.FromResult(UIntPtr.Zero).Result); + Assert.Same(Task.FromResult((Half)default), Task.FromResult((Half)default)); + Assert.Equal((Half)default, Task.FromResult((Half)default).Result); + + Assert.Same(Task.FromResult((float)default), Task.FromResult((float)default)); + Assert.Equal((float)default, Task.FromResult((float)default).Result); + + Assert.Same(Task.FromResult((double)default), Task.FromResult((double)default)); + Assert.Equal((double)default, Task.FromResult((double)default).Result); + + Assert.Same(Task.FromResult((TimeSpan)default), Task.FromResult((TimeSpan)default)); + Assert.Equal((TimeSpan)default, Task.FromResult((TimeSpan)default).Result); + + Assert.Same(Task.FromResult((DateTime)default), Task.FromResult((DateTime)default)); + Assert.Equal((DateTime)default, Task.FromResult((DateTime)default).Result); + Assert.Same(Task.FromResult((object)null), Task.FromResult((object)null)); Assert.Null(Task.FromResult((object)null).Result); @@ -526,10 +541,11 @@ public static void FromResult_KnownResults_Cached() Assert.Equal(i, Task.FromResult(i).Result); } - Assert.NotSame(Task.FromResult((double)0), Task.FromResult((double)0)); - Assert.NotSame(Task.FromResult((float)0), Task.FromResult((float)0)); - Assert.NotSame(Task.FromResult((decimal)0), Task.FromResult((decimal)0)); - Assert.NotSame(Task.FromResult((Half)0), Task.FromResult((Half)0)); + Assert.NotSame(Task.FromResult((double)(+0.0)), Task.FromResult((double)(-0.0))); + Assert.NotSame(Task.FromResult((float)(+0.0)), Task.FromResult((float)(-0.0))); + Assert.NotSame(Task.FromResult((Half)(+0.0)), Task.FromResult((Half)(-0.0))); + + Assert.NotSame(Task.FromResult((decimal)default), Task.FromResult((decimal)default)); } [Fact]