Rename TaskHostResource* to TaskHostCores* for specificity

The packet pair only handles RequestCores/ReleaseCores (IBuildEngine9),
not generic 'resources'. Rename to TaskHostCoresRequest/Response to make
this explicit, matching the Stage 1 pattern (TaskHostIsRunningMultipleNodes*).

Also rename HandleResourceRequest to HandleCoresRequest in TaskHostTask.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: JanProvaznik

documentation/specs/multithreading/taskhost-threading.md

@@ -102,18 +102,18 @@ The following `IBuildEngine` members are forwarded from TaskHost to the owning w
 | IBuildEngine | Request Packet | Response Packet | Fallback |
 |---|---|---|---|
 | `IBuildEngine2.IsRunningMultipleNodes` | `TaskHostIsRunningMultipleNodesRequest` (0x24) | `TaskHostIsRunningMultipleNodesResponse` (0x25) | `false` |
-| `IBuildEngine9.RequestCores(int)` | `TaskHostResourceRequest` (0x22, `IsRelease=false`) | `TaskHostResourceResponse` (0x23) | `0` |
-| `IBuildEngine9.ReleaseCores(int)` | `TaskHostResourceRequest` (0x22, `IsRelease=true`) | `TaskHostResourceResponse` (0x23) | no-op |
+| `IBuildEngine9.RequestCores(int)` | `TaskHostCoresRequest` (0x22, `IsRelease=false`) | `TaskHostCoresResponse` (0x23) | `0` |
+| `IBuildEngine9.ReleaseCores(int)` | `TaskHostCoresRequest` (0x22, `IsRelease=true`) | `TaskHostCoresResponse` (0x23) | no-op |
 
 ### Resource Management (RequestCores/ReleaseCores)
 
 The TaskHost node is a thin proxy for resource management. The real implicit-core/additional-core accounting happens in the in-process `TaskHost` class on the worker node:
 
 1. Task calls `RequestCores(N)` in OutOfProcTaskHostNode
-2. Sends `TaskHostResourceRequest` with `IsRelease=false` and `RequestedCores=N`
-3. Worker node's `TaskHostTask.HandleResourceRequest()` calls `_buildEngine.RequestCores(N)` on the in-process TaskHost
+2. Sends `TaskHostCoresRequest` with `IsRelease=false` and `RequestedCores=N`
+3. Worker node's `TaskHostTask.HandleCoresRequest()` calls `_buildEngine.RequestCores(N)` on the in-process TaskHost
 4. In-process TaskHost handles implicit core logic, communicates with scheduler, returns granted count
-5. Worker node sends `TaskHostResourceResponse` with `GrantedCores`
+5. Worker node sends `TaskHostCoresResponse` with `GrantedCores`
 6. OutOfProcTaskHostNode returns the granted count to the task
 
 `ReleaseCores` follows the same pattern with `IsRelease=true`. The response is an acknowledgment (GrantedCores=0).

src/Build.UnitTests/BackEnd/TaskHostCallbackPacket_Tests.cs

@@ -50,39 +50,39 @@ public void TaskHostIsRunningMultipleNodesResponse_RoundTrip_Serialization(bool
         [Theory]
         [InlineData(4, false)]  // RequestCores(4)
         [InlineData(2, true)]   // ReleaseCores(2)
-        public void TaskHostResourceRequest_RoundTrip_Serialization(int cores, bool isRelease)
+        public void TaskHostCoresRequest_RoundTrip_Serialization(int cores, bool isRelease)
         {
-            var request = new TaskHostResourceRequest(cores, isRelease);
+            var request = new TaskHostCoresRequest(cores, isRelease);
             request.RequestId = 77;
 
             ITranslator writeTranslator = TranslationHelpers.GetWriteTranslator();
             request.Translate(writeTranslator);
 
             ITranslator readTranslator = TranslationHelpers.GetReadTranslator();
-            var deserialized = (TaskHostResourceRequest)TaskHostResourceRequest.FactoryForDeserialization(readTranslator);
+            var deserialized = (TaskHostCoresRequest)TaskHostCoresRequest.FactoryForDeserialization(readTranslator);
 
             deserialized.RequestId.ShouldBe(77);
             deserialized.RequestedCores.ShouldBe(cores);
             deserialized.IsRelease.ShouldBe(isRelease);
-            deserialized.Type.ShouldBe(NodePacketType.TaskHostResourceRequest);
+            deserialized.Type.ShouldBe(NodePacketType.TaskHostCoresRequest);
         }
 
         [Theory]
         [InlineData(0)]   // ReleaseCores acknowledgment
         [InlineData(3)]   // RequestCores granted 3
-        public void TaskHostResourceResponse_RoundTrip_Serialization(int grantedCores)
+        public void TaskHostCoresResponse_RoundTrip_Serialization(int grantedCores)
         {
-            var response = new TaskHostResourceResponse(99, grantedCores);
+            var response = new TaskHostCoresResponse(99, grantedCores);
 
             ITranslator writeTranslator = TranslationHelpers.GetWriteTranslator();
             response.Translate(writeTranslator);
 
             ITranslator readTranslator = TranslationHelpers.GetReadTranslator();
-            var deserialized = (TaskHostResourceResponse)TaskHostResourceResponse.FactoryForDeserialization(readTranslator);
+            var deserialized = (TaskHostCoresResponse)TaskHostCoresResponse.FactoryForDeserialization(readTranslator);
 
             deserialized.RequestId.ShouldBe(99);
             deserialized.GrantedCores.ShouldBe(grantedCores);
-            deserialized.Type.ShouldBe(NodePacketType.TaskHostResourceResponse);
+            deserialized.Type.ShouldBe(NodePacketType.TaskHostCoresResponse);
         }
     }
 }

src/Build/Instance/TaskFactories/TaskHostTask.cs

@@ -204,7 +204,7 @@ public TaskHostTask(
             (this as INodePacketFactory).RegisterPacketHandler(NodePacketType.TaskHostTaskComplete, TaskHostTaskComplete.FactoryForDeserialization, this);
             (this as INodePacketFactory).RegisterPacketHandler(NodePacketType.NodeShutdown, NodeShutdown.FactoryForDeserialization, this);
             (this as INodePacketFactory).RegisterPacketHandler(NodePacketType.TaskHostIsRunningMultipleNodesRequest, TaskHostIsRunningMultipleNodesRequest.FactoryForDeserialization, this);
-            (this as INodePacketFactory).RegisterPacketHandler(NodePacketType.TaskHostResourceRequest, TaskHostResourceRequest.FactoryForDeserialization, this);
+            (this as INodePacketFactory).RegisterPacketHandler(NodePacketType.TaskHostCoresRequest, TaskHostCoresRequest.FactoryForDeserialization, this);
 
             _packetReceivedEvent = new AutoResetEvent(false);
             _receivedPackets = new ConcurrentQueue<INodePacket>();
@@ -514,8 +514,8 @@ private void HandlePacket(INodePacket packet, out bool taskFinished)
                 case NodePacketType.TaskHostIsRunningMultipleNodesRequest:
                     HandleIsRunningMultipleNodesRequest(packet as TaskHostIsRunningMultipleNodesRequest);
                     break;
-                case NodePacketType.TaskHostResourceRequest:
-                    HandleResourceRequest(packet as TaskHostResourceRequest);
+                case NodePacketType.TaskHostCoresRequest:
+                    HandleCoresRequest(packet as TaskHostCoresRequest);
                     break;
                 default:
                     ErrorUtilities.ThrowInternalErrorUnreachable();
@@ -671,7 +671,7 @@ private void HandleIsRunningMultipleNodesRequest(TaskHostIsRunningMultipleNodesR
         /// Forwards the call to the in-process TaskHost's IBuildEngine9 implementation,
         /// which handles implicit core accounting and scheduler communication.
         /// </summary>
-        private void HandleResourceRequest(TaskHostResourceRequest request)
+        private void HandleCoresRequest(TaskHostCoresRequest request)
         {
             int grantedCores = 0;
 
@@ -690,7 +690,7 @@ private void HandleResourceRequest(TaskHostResourceRequest request)
                 }
             }
 
-            var response = new TaskHostResourceResponse(request.RequestId, grantedCores);
+            var response = new TaskHostCoresResponse(request.RequestId, grantedCores);
             _taskHostProvider.SendData(_taskHostNodeKey, response);
         }
 

src/Build/Microsoft.Build.csproj

@@ -125,8 +125,8 @@
     <Compile Include="..\Shared\ITaskHostCallbackPacket.cs" />
     <Compile Include="..\Shared\TaskHostIsRunningMultipleNodesRequest.cs" />
     <Compile Include="..\Shared\TaskHostIsRunningMultipleNodesResponse.cs" />
-    <Compile Include="..\Shared\TaskHostResourceRequest.cs" />
-    <Compile Include="..\Shared\TaskHostResourceResponse.cs" />
+    <Compile Include="..\Shared\TaskHostCoresRequest.cs" />
+    <Compile Include="..\Shared\TaskHostCoresResponse.cs" />
     <Compile Include="..\Shared\OutOfProcTaskHostTaskResult.cs" />
     <Compile Include="..\Shared\TaskLoader.cs" />
     <Compile Include="..\Shared\NodeEngineShutdownReason.cs" />

src/MSBuild/MSBuild.csproj

@@ -120,8 +120,8 @@
     <Compile Include="..\Shared\ITaskHostCallbackPacket.cs" />
     <Compile Include="..\Shared\TaskHostIsRunningMultipleNodesRequest.cs" />
     <Compile Include="..\Shared\TaskHostIsRunningMultipleNodesResponse.cs" />
-    <Compile Include="..\Shared\TaskHostResourceRequest.cs" />
-    <Compile Include="..\Shared\TaskHostResourceResponse.cs" />
+    <Compile Include="..\Shared\TaskHostCoresRequest.cs" />
+    <Compile Include="..\Shared\TaskHostCoresResponse.cs" />
     <Compile Include="..\Shared\TaskLoader.cs" />
     <Compile Include="..\Shared\MSBuildLoadContext.cs" Condition="'$(TargetFrameworkIdentifier)'!='.NETFramework'" />
     <Compile Include="..\Shared\TypeLoader.cs" />

src/MSBuild/OutOfProcTaskHostNode.cs

@@ -248,7 +248,7 @@ public OutOfProcTaskHostNode()
 
 #if !CLR2COMPATIBILITY
             thisINodePacketFactory.RegisterPacketHandler(NodePacketType.TaskHostIsRunningMultipleNodesResponse, TaskHostIsRunningMultipleNodesResponse.FactoryForDeserialization, this);
-            thisINodePacketFactory.RegisterPacketHandler(NodePacketType.TaskHostResourceResponse, TaskHostResourceResponse.FactoryForDeserialization, this);
+            thisINodePacketFactory.RegisterPacketHandler(NodePacketType.TaskHostCoresResponse, TaskHostCoresResponse.FactoryForDeserialization, this);
 #endif
 
 #if !CLR2COMPATIBILITY
@@ -578,8 +578,8 @@ public int RequestCores(int requestedCores)
                 return 0;
             }
 
-            var request = new TaskHostResourceRequest(requestedCores, isRelease: false);
-            var response = SendCallbackRequestAndWaitForResponse<TaskHostResourceResponse>(request);
+            var request = new TaskHostCoresRequest(requestedCores, isRelease: false);
+            var response = SendCallbackRequestAndWaitForResponse<TaskHostCoresResponse>(request);
             return response.GrantedCores;
 #endif
         }
@@ -598,8 +598,8 @@ public void ReleaseCores(int coresToRelease)
                 return;
             }
 
-            var request = new TaskHostResourceRequest(coresToRelease, isRelease: true);
-            SendCallbackRequestAndWaitForResponse<TaskHostResourceResponse>(request);
+            var request = new TaskHostCoresRequest(coresToRelease, isRelease: true);
+            SendCallbackRequestAndWaitForResponse<TaskHostCoresResponse>(request);
 #endif
         }
 
@@ -817,7 +817,7 @@ private void HandlePacket(INodePacket packet)
 #if !CLR2COMPATIBILITY
                 // Callback response packets - route to pending request
                 case NodePacketType.TaskHostIsRunningMultipleNodesResponse:
-                case NodePacketType.TaskHostResourceResponse:
+                case NodePacketType.TaskHostCoresResponse:
                     HandleCallbackResponse(packet);
                     break;
 #endif

src/Shared/INodePacket.cs

@@ -246,12 +246,12 @@ internal enum NodePacketType : byte
         /// <summary>
         /// Request from TaskHost to owning worker node for RequestCores/ReleaseCores.
         /// </summary>
-        TaskHostResourceRequest = 0x22,
+        TaskHostCoresRequest = 0x22,
 
         /// <summary>
-        /// Response from owning worker node to TaskHost with resource allocation result.
+        /// Response from owning worker node to TaskHost with core allocation result.
         /// </summary>
-        TaskHostResourceResponse = 0x23,
+        TaskHostCoresResponse = 0x23,
 
         /// <summary>
         /// Request from TaskHost to owning worker node for IsRunningMultipleNodes.

src/Shared/TaskHostResourceRequest.cs src/Shared/TaskHostCoresRequest.cssrc/Shared/TaskHostResourceRequest.cs renamed to src/Shared/TaskHostCoresRequest.cs

@@ -8,23 +8,23 @@ namespace Microsoft.Build.BackEnd
     /// When <see cref="IsRelease"/> is false, this is a RequestCores call with <see cref="RequestedCores"/> cores requested.
     /// When <see cref="IsRelease"/> is true, this is a ReleaseCores call with <see cref="RequestedCores"/> cores to release.
     /// </summary>
-    internal class TaskHostResourceRequest : INodePacket, ITaskHostCallbackPacket
+    internal class TaskHostCoresRequest : INodePacket, ITaskHostCallbackPacket
     {
         private int _requestId;
         private int _requestedCores;
         private bool _isRelease;
 
-        public TaskHostResourceRequest()
+        public TaskHostCoresRequest()
         {
         }
 
-        public TaskHostResourceRequest(int requestedCores, bool isRelease)
+        public TaskHostCoresRequest(int requestedCores, bool isRelease)
         {
             _requestedCores = requestedCores;
             _isRelease = isRelease;
         }
 
-        public NodePacketType Type => NodePacketType.TaskHostResourceRequest;
+        public NodePacketType Type => NodePacketType.TaskHostCoresRequest;
 
         public int RequestId
         {
@@ -51,7 +51,7 @@ public void Translate(ITranslator translator)
 
         internal static INodePacket FactoryForDeserialization(ITranslator translator)
         {
-            var packet = new TaskHostResourceRequest();
+            var packet = new TaskHostCoresRequest();
             packet.Translate(translator);
             return packet;
         }

src/Shared/TaskHostResourceResponse.cs src/Shared/TaskHostCoresResponse.cssrc/Shared/TaskHostResourceResponse.cs renamed to src/Shared/TaskHostCoresResponse.cs

@@ -4,26 +4,26 @@
 namespace Microsoft.Build.BackEnd
 {
     /// <summary>
-    /// Response packet from owning worker node to TaskHost with the resource allocation result.
+    /// Response packet from owning worker node to TaskHost with the core allocation result.
     /// For RequestCores: <see cref="GrantedCores"/> is the number of cores granted.
     /// For ReleaseCores: <see cref="GrantedCores"/> is 0 (acknowledgment only).
     /// </summary>
-    internal class TaskHostResourceResponse : INodePacket, ITaskHostCallbackPacket
+    internal class TaskHostCoresResponse : INodePacket, ITaskHostCallbackPacket
     {
         private int _requestId;
         private int _grantedCores;
 
-        public TaskHostResourceResponse()
+        public TaskHostCoresResponse()
         {
         }
 
-        public TaskHostResourceResponse(int requestId, int grantedCores)
+        public TaskHostCoresResponse(int requestId, int grantedCores)
         {
             _requestId = requestId;
             _grantedCores = grantedCores;
         }
 
-        public NodePacketType Type => NodePacketType.TaskHostResourceResponse;
+        public NodePacketType Type => NodePacketType.TaskHostCoresResponse;
 
         public int RequestId
         {
@@ -45,7 +45,7 @@ public void Translate(ITranslator translator)
 
         internal static INodePacket FactoryForDeserialization(ITranslator translator)
         {
-            var packet = new TaskHostResourceResponse();
+            var packet = new TaskHostCoresResponse();
             packet.Translate(translator);
             return packet;
         }