arunpandianp commented on code in PR #41444:
URL: https://github.com/apache/beam/pull/41444#discussion_r4636927608


##########
runners/google-cloud-dataflow-java/worker/src/test/java/org/apache/beam/runners/dataflow/worker/windmill/client/grpc/GrpcDirectGetWorkStreamTest.java:
##########
@@ -468,6 +474,346 @@ public void 
testConsumedWorkItems_itemsSplitAcrossResponses() throws Interrupted
     assertThat(scheduledWorkItems).containsExactly(workItem1, workItem2, 
workItem3);
   }
 
+  @Test
+  public void 
testSetBudget_rapidUpdatesBeforeAsyncSend_doesNotExceedMaxBudget()
+      throws InterruptedException {
+    ScheduledExecutorService singleThreadExecutor = 
Executors.newSingleThreadScheduledExecutor();
+    try {
+      int expectedRequests = 3;
+      CountDownLatch waitForRequests = new CountDownLatch(expectedRequests);
+      TestGetWorkRequestObserver requestObserver = new 
TestGetWorkRequestObserver(waitForRequests);
+      GetWorkStreamTestStub testStub = new 
GetWorkStreamTestStub(requestObserver);
+      serviceRegistry.addService(testStub);
+      stream =
+          createDirectGetWorkStream(
+              GetWorkBudget.noBudget(),
+              NO_OP_WORK_ITEM_SCHEDULER,
+              singleThreadExecutor,
+              Duration.ZERO);
+      stream.start();
+
+      // Hold the async sender thread so rapid updates queue up before any 
extension is sent.
+      CountDownLatch holdExecutor = holdExecutor(singleThreadExecutor);
+      
stream.setBudget(GetWorkBudget.builder().setItems(10).setBytes(100).build());
+      
stream.setBudget(GetWorkBudget.builder().setItems(20).setBytes(200).build());
+      
stream.setBudget(GetWorkBudget.builder().setItems(30).setBytes(300).build());
+      holdExecutor.countDown();
+
+      assertTrue(waitForRequests.await(5, TimeUnit.SECONDS));
+
+      List<Windmill.StreamingGetWorkRequest> requests = requestObserver.sent();
+      assertThat(requests).hasSize(expectedRequests);
+      assertHeader(requests.get(0), GetWorkBudget.noBudget());
+      assertThat(requests.get(1).hasRequestExtension()).isTrue();
+      assertThat(requests.get(2).hasRequestExtension()).isTrue();
+      // Extensions sent across all updates must sum to the 30/300 target 
without double-counting.
+      long totalExtensionItems =
+          requests.stream().skip(1).mapToLong(r -> 
r.getRequestExtension().getMaxItems()).sum();
+      long totalExtensionBytes =
+          requests.stream().skip(1).mapToLong(r -> 
r.getRequestExtension().getMaxBytes()).sum();
+      assertThat(totalExtensionItems).isEqualTo(30L);
+      assertThat(totalExtensionBytes).isEqualTo(300L);
+    } finally {
+      shutdownStreamAndExecutor(singleThreadExecutor);
+    }
+  }
+
+  @Test
+  public void testConsumedWorkItems_batchedChunkDoesNotOverRequestBudget()
+      throws InterruptedException {
+    ScheduledExecutorService singleThreadExecutor = 
Executors.newSingleThreadScheduledExecutor();
+    try {
+      int expectedRequests = 3;
+      CountDownLatch waitForRequests = new CountDownLatch(expectedRequests);
+      TestGetWorkRequestObserver requestObserver = new 
TestGetWorkRequestObserver(waitForRequests);
+      GetWorkStreamTestStub testStub = new 
GetWorkStreamTestStub(requestObserver);
+      GetWorkBudget initialBudget = 
GetWorkBudget.builder().setItems(3).setBytes(1000).build();
+      Set<Windmill.WorkItem> scheduledWorkItems = 
Collections.synchronizedSet(new HashSet<>());
+      serviceRegistry.addService(testStub);
+      stream =
+          createDirectGetWorkStream(
+              initialBudget,
+              (work,
+                  serializedWorkItemSize,
+                  watermarks,
+                  processingContext,
+                  drainMode,
+                  appliedFinalizeIds,
+                  getWorkStreamLatencies) -> scheduledWorkItems.add(work),
+              singleThreadExecutor,
+              Duration.ZERO);
+      stream.start();
+
+      Windmill.WorkItem workItem1 = createWorkItem("somewhat_long_key1", 1L);
+      Windmill.WorkItem workItem2 = createWorkItem("somewhat_long_key2", 2L);
+      Windmill.WorkItem workItem3 = createWorkItem("somewhat_long_key3", 3L);
+
+      CountDownLatch holdExecutor = holdExecutor(singleThreadExecutor);
+      // Inject 3 items in a single response while the executor is blocked. 
Item 2 brings
+      // in-flight items down to 1 (<= 2/2) and records a +2 extension; Item 3 
must observe that
+      // updated budget and NOT queue a duplicate extension.
+      testStub.injectResponse(createResponse(workItem1, workItem2, workItem3));
+      holdExecutor.countDown();
+
+      // Raise max budget; delta must reflect the +2 extension already 
recorded by Item 2.
+      GetWorkBudget finalBudget = 
GetWorkBudget.builder().setItems(10).setBytes(2000).build();
+      stream.setBudget(finalBudget);
+
+      assertTrue(waitForRequests.await(5, TimeUnit.SECONDS));
+      assertThat(scheduledWorkItems).containsExactly(workItem1, workItem2, 
workItem3);
+
+      List<Windmill.StreamingGetWorkRequest> requests = requestObserver.sent();
+      assertThat(requests).hasSize(expectedRequests);
+      assertHeader(requests.get(0), initialBudget);
+      long itemSize = workItem1.getSerializedSize();
+      assertThat(requests.get(1).getRequestExtension())
+          .isEqualTo(extension(GetWorkBudget.builder().setItems(2).setBytes(2 
* itemSize).build()));
+      assertThat(requests.get(2).getRequestExtension())
+          .isEqualTo(
+              extension(GetWorkBudget.builder().setItems(8).setBytes(1000 + 
itemSize).build()));
+    } finally {
+      shutdownStreamAndExecutor(singleThreadExecutor);
+    }
+  }
+
+  @Test
+  public void 
testHalfClosePhysicalStream_staleExtensionAndClosingResponse_isolatedFromNewEpoch()
+      throws InterruptedException {
+    DeferrableScheduledExecutorService executor = new 
DeferrableScheduledExecutorService();
+    try {
+      MultiStreamTestStub stub = new MultiStreamTestStub(2);
+      serviceRegistry.addService(stub);
+      GetWorkBudget initialBudget = 
GetWorkBudget.builder().setItems(1).setBytes(100).build();
+      Set<Windmill.WorkItem> scheduledWorkItems = 
Collections.synchronizedSet(new HashSet<>());
+      stream =
+          createDirectGetWorkStream(
+              initialBudget,
+              (work,
+                  serializedWorkItemSize,
+                  watermarks,
+                  processingContext,
+                  drainMode,
+                  appliedFinalizeIds,
+                  getWorkStreamLatencies) -> scheduledWorkItems.add(work),
+              executor,
+              Duration.ofSeconds(60));
+      stream.start();
+      assertHeader(stub.takeRequest(0), initialBudget);
+
+      // Deliver only the first chunk of workItem1 on stream 0 before 
half-close.
+      Windmill.WorkItem workItem1 = createWorkItem("split_across_half_close", 
1L);
+      Windmill.WorkItem workItem2 = createWorkItem("after_half_close", 2L);
+      ByteString item1Bytes = workItem1.toByteString();
+      int splitIdx = item1Bytes.size() / 2;
+      stub.injectResponse(
+          0,
+          createResponse(
+              Collections.singletonList(item1Bytes.substring(0, splitIdx)),
+              item1Bytes.size() - splitIdx));
+
+      // Queue an epoch-1 extension task without executing it yet, then 
half-close stream 0 into
+      // stream 1 (epoch 2).
+      GetWorkBudget intermediateBudget = 
GetWorkBudget.builder().setItems(4).setBytes(1000).build();
+      executor.deferring = true;
+      stream.setBudget(intermediateBudget);
+      executor.deferring = false;
+
+      assertTrue(executor.unblockNextFuture());
+      assertHeader(stub.takeRequest(1), intermediateBudget);
+
+      // Complete workItem1 and send workItem2 on closing stream 0; scheduler 
must deliver both
+      // items while epoch 2 ignores their budget consumption.
+      stub.injectResponse(
+          0,
+          createResponse(
+              Arrays.asList(item1Bytes.substring(splitIdx), 
workItem2.toByteString()), 0));
+      assertThat(scheduledWorkItems).containsExactly(workItem1, workItem2);
+
+      // Drain the stale epoch-1 extension task; streamEpoch gating must drop 
it.
+      executor.drainDeferred();
+      flushExecutor(executor);
+
+      GetWorkBudget finalBudget = 
GetWorkBudget.builder().setItems(20).setBytes(5000).build();
+      stream.setBudget(finalBudget);
+      Windmill.StreamingGetWorkRequest stream1Ext = stub.takeRequest(1);
+      assertTrue(stream1Ext.hasRequestExtension());
+      assertThat(stream1Ext.getRequestExtension())
+          .isEqualTo(extension(finalBudget.subtract(intermediateBudget)));
+      assertThat(stub.requests(0)).isEmpty();
+      assertThat(stub.requests(1)).isEmpty();
+      assertThat(stub.streamCount()).isEqualTo(2);
+    } finally {
+      shutdownStreamAndExecutor(executor);
+    }
+  }
+
+  // Blocks a single-threaded executor until countDown() so async sends queue 
deterministically.
+  private static CountDownLatch holdExecutor(ScheduledExecutorService executor)

Review Comment:
   can we make all new tests use DeferrableScheduledExecutorService and remove 
this?



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to