update

Author: Sunny Jiao

framework/src/test/java/org/tron/core/services/RpcApiServicesTest.java

@@ -155,8 +155,6 @@ public class RpcApiServicesTest {
 
   @BeforeClass
   public static void init() throws IOException {
-    System.out.println("========== [BEFORE_CLASS] Starting init() ==========");
-    System.err.println("========== [BEFORE_CLASS] Starting init() ==========");
     Args.setParam(new String[] {"-d", temporaryFolder.newFolder().toString()}, Constant.TEST_CONF);
     Assert.assertEquals(5, getInstance().getRpcMaxRstStream());
     Assert.assertEquals(10, getInstance().getRpcSecondsPerWindow());
@@ -206,35 +204,20 @@ public static void init() throws IOException {
     manager.getAccountStore().put(ownerCapsule.createDbKey(), ownerCapsule);
     manager.getDynamicPropertiesStore().saveAllowShieldedTransaction(1);
     manager.getDynamicPropertiesStore().saveAllowShieldedTRC20Transaction(1);
-    System.out.println("========== [BEFORE_CLASS] Creating Application... ==========");
-    System.err.println("========== [BEFORE_CLASS] Creating Application... ==========");
     appTest = ApplicationFactory.create(context);
-    System.out.println("========== [BEFORE_CLASS] Starting Application... ==========");
-    System.err.println("========== [BEFORE_CLASS] Starting Application... ==========");
     appTest.startup();
-    System.out.println("========== [BEFORE_CLASS] Application started ==========");
-    System.err.println("========== [BEFORE_CLASS] Application started ==========");
 
-    // Initialize stress test channels (increased to 30 for more pressure)
-    System.out.println("========== [BEFORE_CLASS] Initializing stress test channels... ==========");
-    System.err.println("========== [BEFORE_CLASS] Initializing stress test channels... ==========");
-    int stressChannelCount = 30;
+    // Initialize stress test channels (increased to 100 for maximum pressure)
+    int stressChannelCount = 100;
     stressChannels = new ManagedChannel[stressChannelCount];
     stressStubs = new WalletBlockingStub[stressChannelCount];
     for (int i = 0; i < stressChannelCount; i++) {
-      if (i % 10 == 0) {
-        System.out.println("========== [BEFORE_CLASS] Creating stress channel " + i + "/" + stressChannelCount + " ==========");
-        System.err.println("========== [BEFORE_CLASS] Creating stress channel " + i + "/" + stressChannelCount + " ==========");
-      }
       stressChannels[i] = ManagedChannelBuilder.forTarget(fullNode)
           .usePlaintext()
           .intercept(new TimeoutInterceptor(5000))
           .build();
       stressStubs[i] = WalletGrpc.newBlockingStub(stressChannels[i]);
     }
-    System.out.println("========== [BEFORE_CLASS] Initialized " + stressChannelCount + " stress test channels ==========");
-    System.err.println("========== [BEFORE_CLASS] Initialized " + stressChannelCount + " stress test channels ==========");
-    logger.info("Initialized {} stress test channels", stressChannelCount);
   }
 
   @AfterClass
@@ -263,14 +246,10 @@ public static void destroy() {
 
   @Before
   public void start() {
-    logger.debug("========== Starting test: {} ==========", name.getMethodName());
-    System.out.println("========== Starting test: " + name.getMethodName() + " ==========");
   }
 
   @After
   public void end() throws InterruptedException {
-    logger.debug("========== Ending test: {} ==========", name.getMethodName());
-    System.out.println("========== Ending test: " + name.getMethodName() + " ==========");
   }
 
   @Test
@@ -428,213 +407,47 @@ public void testGetCanDelegatedMaxSize() {
   }
 
   /**
-   * Stress test to reproduce potential gRPC-Java ThreadlessExecutor bug.
-   * This test creates multiple channels and executes concurrent requests to increase
-   * the probability of triggering the callback submission failure issue.
+   * Continuous stress test that runs until it hangs (to reproduce the bug).
+   * Maximum stress on gRPC-Java-Netty event handling - no logging overhead.
    */
-  @Test(timeout = 60000) // 60 seconds timeout
-  public void testStressMultipleChannels() throws InterruptedException {
-    System.out.println("========== Starting stress test with multiple channels ==========");
-    logger.info("========== Starting stress test with multiple channels ==========");
-    
-    int threadCount = 50; // Increased from 20 to 50
-    int requestsPerThread = 100; // Increased from 50 to 100
-    int totalRequests = threadCount * requestsPerThread;
-    
-    System.out.println("Thread count: " + threadCount + ", Requests per thread: " + requestsPerThread + ", Total requests: " + totalRequests);
-    
-    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
-    CountDownLatch latch = new CountDownLatch(totalRequests);
-    AtomicInteger successCount = new AtomicInteger(0);
-    AtomicInteger failureCount = new AtomicInteger(0);
-    List<Exception> exceptions = new ArrayList<>();
-    
+  @Test(timeout = 300000) // 5 minutes timeout - will hang if bug occurs
+  public void testContinuousStressUntilHang() throws InterruptedException {
     CanDelegatedMaxSizeRequestMessage message = CanDelegatedMaxSizeRequestMessage.newBuilder()
         .setType(0).setOwnerAddress(ownerAddress).build();
-    
-    // Submit requests using all available channels
-    for (int i = 0; i < totalRequests; i++) {
+
+    // Maximum stress: 200 threads × 500 requests = 100,000 requests per iteration
+    int threadCount = 200;
+    int requestsPerIteration = 500;
+    int iterationTotalRequests = threadCount * requestsPerIteration;
+
+    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+    CountDownLatch latch = new CountDownLatch(iterationTotalRequests);
+
+    for (int i = 0; i < iterationTotalRequests; i++) {
       final int requestId = i;
       executor.submit(() -> {
         try {
-          // Distribute requests across all channels
+          // Distribute requests across all channels to maximize event loop pressure
           if (requestId % 3 == 0) {
-            // Use blockingStubFull
             assertNotNull(blockingStubFull.getCanDelegatedMaxSize(message));
           } else if (requestId % 3 == 1 && stressStubs != null && stressStubs.length > 0) {
-            // Use stress stubs
             assertNotNull(stressStubs[requestId % stressStubs.length].getCanDelegatedMaxSize(message));
           } else {
-            // Use blockingStubSolidity (WalletSolidityBlockingStub)
             assertNotNull(blockingStubSolidity.getCanDelegatedMaxSize(message));
           }
-          
-          successCount.incrementAndGet();
-        } catch (Exception e) {
-          failureCount.incrementAndGet();
-          synchronized (exceptions) {
-            exceptions.add(e);
-          }
-          logger.error("Request {} failed", requestId, e);
         } finally {
           latch.countDown();
         }
       });
     }
-    
-    // Wait for all requests to complete with timeout (increased to 55 seconds)
-    boolean completed = latch.await(55, TimeUnit.SECONDS);
-    
+
+    // Wait for completion - if this hangs, the bug is reproduced!
+    latch.await(120, TimeUnit.SECONDS);
+
     executor.shutdown();
     if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
       executor.shutdownNow();
     }
-    
-    System.out.println("========== Stress test completed ==========");
-    System.out.println("Total requests: " + totalRequests);
-    System.out.println("Success: " + successCount.get() + ", Failure: " + failureCount.get());
-    System.out.println("Completed: " + completed);
-    
-    logger.info("========== Stress test completed ==========");
-    logger.info("Total requests: {}", totalRequests);
-    logger.info("Success: {}, Failure: {}", successCount.get(), failureCount.get());
-    logger.info("Completed: {}", completed);
-    
-    if (!exceptions.isEmpty()) {
-      System.out.println("First exception: " + exceptions.get(0).getMessage());
-      logger.error("First exception: {}", exceptions.get(0).getMessage(), exceptions.get(0));
-    }
-    
-    // Assert that all requests completed
-    Assert.assertTrue("Not all requests completed in time. Success: " + successCount.get() 
-        + ", Failure: " + failureCount.get() + ", Completed: " + completed,
-        completed);
-    
-    // Log if there were failures (might indicate the bug)
-    if (failureCount.get() > 0) {
-      System.out.println("WARNING: Stress test detected " + failureCount.get() + " failures, which might indicate the ThreadlessExecutor bug");
-      logger.warn("Stress test detected {} failures, which might indicate the ThreadlessExecutor bug", 
-          failureCount.get());
-    }
-  }
-
-  /**
-   * Continuous stress test that runs until it hangs (to reproduce the bug).
-   * This test will keep running until it times out or hangs, increasing the probability
-   * of reproducing the ThreadlessExecutor callback submission failure.
-   */
-  @Test(timeout = 300000) // 5 minutes timeout - will hang if bug occurs
-  public void testContinuousStressUntilHang() throws InterruptedException {
-    System.out.println("========== [TEST] Starting CONTINUOUS stress test (will run until hang) ==========");
-    System.err.println("========== [TEST] Starting CONTINUOUS stress test (will run until hang) ==========");
-    logger.info("========== Starting CONTINUOUS stress test (will run until hang) ==========");
-    
-    CanDelegatedMaxSizeRequestMessage message = CanDelegatedMaxSizeRequestMessage.newBuilder()
-        .setType(0).setOwnerAddress(ownerAddress).build();
-    
-    int iteration = 0;
-    int totalRequests = 0;
-    int totalSuccess = 0;
-    int totalFailures = 0;
-    long startTime = System.currentTimeMillis();
-    
-    // Run continuously until timeout or hang
-    while (true) {
-      iteration++;
-      final int currentIteration = iteration; // Make final for lambda
-      System.out.println("\n========== Iteration " + currentIteration + " ==========");
-      System.err.println("\n========== Iteration " + currentIteration + " ==========");
-      System.out.flush();
-      System.err.flush();
-      logger.info("========== Iteration {} ==========", currentIteration);
-      
-      // Each iteration: 50 threads × 100 requests = 5000 requests
-      int threadCount = 50;
-      int requestsPerIteration = 100;
-      int iterationTotalRequests = threadCount * requestsPerIteration;
-      
-      ExecutorService executor = Executors.newFixedThreadPool(threadCount);
-      CountDownLatch latch = new CountDownLatch(iterationTotalRequests);
-      AtomicInteger successCount = new AtomicInteger(0);
-      AtomicInteger failureCount = new AtomicInteger(0);
-      
-      long iterationStartTime = System.currentTimeMillis();
-      
-      for (int i = 0; i < iterationTotalRequests; i++) {
-        final int requestId = i;
-        executor.submit(() -> {
-          try {
-            // Distribute requests across all channels
-            if (requestId % 3 == 0) {
-              assertNotNull(blockingStubFull.getCanDelegatedMaxSize(message));
-            } else if (requestId % 3 == 1 && stressStubs != null && stressStubs.length > 0) {
-              assertNotNull(stressStubs[requestId % stressStubs.length].getCanDelegatedMaxSize(message));
-            } else {
-              assertNotNull(blockingStubSolidity.getCanDelegatedMaxSize(message));
-            }
-            successCount.incrementAndGet();
-          } catch (Exception e) {
-            failureCount.incrementAndGet();
-            logger.error("Request {} failed in iteration {}", requestId, currentIteration, e);
-          } finally {
-            latch.countDown();
-          }
-        });
-      }
-      
-      System.out.println("All requests submitted, waiting for completion...");
-      System.err.println("All requests submitted, waiting for completion...");
-      System.out.flush();
-      System.err.flush();
-      
-      // Wait for completion with timeout - if this hangs, the bug is reproduced!
-      boolean completed = latch.await(60, TimeUnit.SECONDS);
-      
-      executor.shutdown();
-      if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
-        executor.shutdownNow();
-      }
-      
-      long iterationTime = System.currentTimeMillis() - iterationStartTime;
-      totalRequests += iterationTotalRequests;
-      totalSuccess += successCount.get();
-      totalFailures += failureCount.get();
-      
-      System.out.println("Iteration " + currentIteration + " completed in " + iterationTime + "ms");
-      System.err.println("Iteration " + currentIteration + " completed in " + iterationTime + "ms");
-      System.out.println("  Requests: " + iterationTotalRequests + ", Success: " + successCount.get() + ", Failure: " + failureCount.get());
-      System.err.println("  Requests: " + iterationTotalRequests + ", Success: " + successCount.get() + ", Failure: " + failureCount.get());
-      System.out.println("  Completed: " + completed);
-      System.err.println("  Completed: " + completed);
-      System.out.println("Total so far - Requests: " + totalRequests + ", Success: " + totalSuccess + ", Failure: " + totalFailures);
-      System.err.println("Total so far - Requests: " + totalRequests + ", Success: " + totalSuccess + ", Failure: " + totalFailures);
-      System.out.println("Elapsed time: " + (System.currentTimeMillis() - startTime) + "ms");
-      System.err.println("Elapsed time: " + (System.currentTimeMillis() - startTime) + "ms");
-      
-      logger.info("Iteration {} completed in {}ms", currentIteration, iterationTime);
-      logger.info("  Requests: {}, Success: {}, Failure: {}", iterationTotalRequests, successCount.get(), failureCount.get());
-      logger.info("Total so far - Requests: {}, Success: {}, Failure: {}", totalRequests, totalSuccess, totalFailures);
-      
-      if (!completed) {
-        System.out.println("\n!!! WARNING: Iteration " + currentIteration + " did not complete in time - THIS MIGHT BE THE BUG !!!");
-        System.err.println("\n!!! WARNING: Iteration " + currentIteration + " did not complete in time - THIS MIGHT BE THE BUG !!!");
-        logger.error("!!! WARNING: Iteration {} did not complete in time - THIS MIGHT BE THE BUG !!!", currentIteration);
-        // Continue anyway to see if it recovers
-      }
-      
-      if (failureCount.get() > 0) {
-        System.out.println("WARNING: Iteration " + currentIteration + " had " + failureCount.get() + " failures");
-        System.err.println("WARNING: Iteration " + currentIteration + " had " + failureCount.get() + " failures");
-        logger.warn("Iteration {} had {} failures", currentIteration, failureCount.get());
-      }
-      
-      // Force flush output
-      System.out.flush();
-      System.err.flush();
-      
-      // Small delay between iterations to avoid overwhelming the system
-      Thread.sleep(100);
-    }
   }
 
   @Test