Shorten UTD marker file

src/Build/Evaluation/IntrinsicFunctions.cs

@@ -398,11 +398,11 @@ internal static string ConvertFromBase64(string toDecode)
         }
 
         /// <summary>
-        /// Hash the string independent of bitness and target framework.
+        /// Hash the string independent of bitness, target framework and default codepage of the environment.
         /// </summary>
         internal static int StableStringHash(string toHash)
         {
-            return CommunicationsUtilities.GetHashCode(toHash);
+            return FowlerNollVo1aHash.ComputeHash32(toHash);
         }
 
         /// <summary>

src/Build/Logging/BinaryLogger/BuildEventArgsWriter.cs

@@ -14,6 +14,7 @@
 using Microsoft.Build.Framework;
 using Microsoft.Build.Framework.Profiler;
 using Microsoft.Build.Shared;
+using Microsoft.Build.Utilities;
 
 #nullable disable
 
@@ -1274,13 +1275,13 @@ public HashKey(string text)
                 }
                 else
                 {
-                    value = FnvHash64.GetHashCode(text);
+                    value = FowlerNollVo1aHash.ComputeHash64Fast(text);
                 }
             }
 
             public static HashKey Combine(HashKey left, HashKey right)
             {
-                return new HashKey(FnvHash64.Combine(left.value, right.value));
+                return new HashKey(FowlerNollVo1aHash.Combine64(left.value, right.value));
             }
 
             public HashKey Add(HashKey other) => Combine(this, other);
@@ -1310,35 +1311,5 @@ public override string ToString()
                 return value.ToString();
             }
         }
-
-        internal static class FnvHash64
-        {
-            public const ulong Offset = 14695981039346656037;
-            public const ulong Prime = 1099511628211;
-
-            public static ulong GetHashCode(string text)
-            {
-                ulong hash = Offset;
-
-                unchecked
-                {
-                    for (int i = 0; i < text.Length; i++)
-                    {
-                        char ch = text[i];
-                        hash = (hash ^ ch) * Prime;
-                    }
-                }
-
-                return hash;
-            }
-
-            public static ulong Combine(ulong left, ulong right)
-            {
-                unchecked
-                {
-                    return (left ^ right) * Prime;
-                }
-            }
-        }
     }
 }

src/Build/Microsoft.Build.csproj

@@ -153,6 +153,7 @@
     <Compile Include="BackEnd\Components\SdkResolution\SdkResolverException.cs" />
     <Compile Include="BackEnd\Components\SdkResolution\TranslationHelpers.cs" />
     <Compile Include="FileSystem\*.cs" />
+    <Compile Include="Utilities\FowlerNollVo1aHash.cs" />
     <Compile Include="Evaluation\IItemTypeDefinition.cs" />
     <Compile Include="FileAccess\DesiredAccess.cs" />
     <Compile Include="FileAccess\FileAccessData.cs" />

src/Build/Utilities/FowlerNollVo1aHash.cs

@@ -0,0 +1,107 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Build.Utilities
+{
+    internal static class FowlerNollVo1aHash
+    {
+        // Fowler/Noll/Vo hashing.
+        // http://www.isthe.com/chongo/tech/comp/fnv/
+        // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
+        // http://www.isthe.com/chongo/src/fnv/hash_32a.c
+
+        // 32 bit FNV prime and offset basis for FNV-1a.
+        private const uint fnvPrimeA32Bit = 16777619;
+        private const uint fnvOffsetBasisA32Bit = 2166136261;
+
+        // 64 bit FNV prime and offset basis for FNV-1a.
+        private const ulong fnvPrimeA64Bit = 1099511628211;
+        private const ulong fnvOffsetBasisA64Bit = 14695981039346656037;
+
+        /// <summary>
+        /// Computes 32 bit Fowler/Noll/Vo-1a hash of a string (regardless of encoding).
+        /// </summary>
+        /// <param name="text">String to be hashed.</param>
+        /// <returns>32 bit signed hash</returns>
+        internal static int ComputeHash32(string text)
+        {
+            uint hash = fnvOffsetBasisA32Bit;
+
+            unchecked
+            {
+                for (int i = 0; i < text.Length; i++)
+                {
+                    char ch = text[i];
+                    byte b = (byte)ch;
+                    hash ^= b;
+                    hash *= fnvPrimeA32Bit;
+
+                    b = (byte)(ch >> 8);
+                    hash ^= b;
+                    hash *= fnvPrimeA32Bit;
+                }
+            }
+
+            return unchecked((int)hash);
+        }
+
+        /// <summary>
+        /// Computes 64 bit Fowler/Noll/Vo-1a hash optimized for ASCII strings.
+        /// The hashing algorithm considers only the first 8 bits of each character.
+        /// Analysis: https://github.com/KirillOsenkov/MSBuildStructuredLog/wiki/String-Hashing#faster-fnv-1a
+        /// </summary>
+        /// <param name="text">String to be hashed.</param>
+        /// <returns>64 bit unsigned hash</returns>
+        internal static ulong ComputeHash64Fast(string text)
+        {
+            ulong hash = fnvOffsetBasisA64Bit;
+
+            unchecked
+            {
+                for (int i = 0; i < text.Length; i++)
+                {
+                    char ch = text[i];
+
+                    hash = (hash ^ ch) * fnvPrimeA64Bit;
+                }
+            }
+
+            return hash;
+        }
+
+        /// <summary>
+        /// Computes 64 bit Fowler/Noll/Vo-1a hash of a string (regardless of encoding).
+        /// </summary>
+        /// <param name="text">String to be hashed.</param>
+        /// <returns>64 bit unsigned hash</returns>
+        internal static ulong ComputeHash64(string text)
+        {
+            ulong hash = fnvOffsetBasisA64Bit;
+
+            unchecked
+            {
+                for (int i = 0; i < text.Length; i++)
+                {
+                    char ch = text[i];
+                    byte b = (byte)ch;
+                    hash ^= b;
+                    hash *= fnvPrimeA64Bit;
+
+                    b = (byte)(ch >> 8);
+                    hash ^= b;
+                    hash *= fnvPrimeA64Bit;
+                }
+            }
+
+            return hash;
+        }
+
+        internal static ulong Combine64(ulong left, ulong right)
+        {
+            unchecked
+            {
+                return (left ^ right) * fnvPrimeA64Bit;
+            }
+        }
+    }
+}

src/Tasks/Microsoft.Common.CurrentVersion.targets

@@ -385,11 +385,19 @@ Copyright (C) Microsoft Corporation. All rights reserved.
   <PropertyGroup>
     <_GenerateBindingRedirectsIntermediateAppConfig>$(IntermediateOutputPath)$(TargetFileName).config</_GenerateBindingRedirectsIntermediateAppConfig>
   </PropertyGroup>
+
+  <PropertyGroup>
+    <MSBuildCopyMarkerName Condition ="'$(MSBuildCopyMarkerName)' == ''">$(MSBuildProjectFile)</MSBuildCopyMarkerName>
+	<!-- For a long MSBuildProjectFile let's shorten this to 17 chars - using the first 8 chars of the filename and either the ProjectGuid if it exists -->
+    <MSBuildCopyMarkerName Condition ="'$(MSBuildCopyMarkerName.Length)' &gt; '17' and '$(ProjectGuid)' != ''">$(MSBuildProjectFile.Substring(0,8)).$(ProjectGuid.Substring(1,8))</MSBuildCopyMarkerName>
+	<!-- or a filename hash if the guid is not present (in such case the filename was not shortened and is still over 17 chars long). -->
+	<MSBuildCopyMarkerName Condition ="'$(MSBuildCopyMarkerName.Length)' &gt; '17'">$(MSBuildProjectFile.Substring(0,8)).$([MSBuild]::StableStringHash($(MSBuildProjectFile)).ToString("X8"))</MSBuildCopyMarkerName>
+  </PropertyGroup>
 
   <ItemGroup>
     <IntermediateAssembly Include="$(IntermediateOutputPath)$(TargetName)$(TargetExt)"/>
     <FinalDocFile Include="@(DocFileItem->'$(OutDir)%(Filename)%(Extension)')"/>
-    <CopyUpToDateMarker Include="$([MSBuild]::NormalizePath('$(MSBuildProjectDirectory)', '$(IntermediateOutputPath)', '$(MSBuildProjectFile).CopyComplete'))" />
+    <CopyUpToDateMarker Include="$([MSBuild]::NormalizePath('$(MSBuildProjectDirectory)', '$(IntermediateOutputPath)', '$(MSBuildCopyMarkerName).Up2Date'))" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(ProduceReferenceAssembly)' == 'true'">