Relax performance thresholds for CI

Signed-off-by: Sergio Herrera <627709+seherv@users.noreply.github.com>

Author: seherv

ext/dapr-ext-workflow/tests/durabletask/test_async_dispatch_regression.py

@@ -29,17 +29,17 @@
 
 pytestmark = pytest.mark.perf
 
-_ACTIVITY_S = 0.02
-_POOL = 16
-_SEM = 1000
-_REPEAT = 3
+ACTIVITY_S = 0.02
+POOL = 16
+SEM = 1000
+REPEAT = 2
 
 
-async def _fastest(**kwargs):
-    """Fastest of _REPEAT sequential runs, so spotty CI noise on one run can't flake the
+async def fastest(**kwargs):
+    """Fastest of REPEAT sequential runs, so spotty CI noise on one run can't flake the
     wallclock comparisons. Noise only adds time, so the min is the least-disturbed sample.
     """
-    runs = [await _run_full(**kwargs) for _ in range(_REPEAT)]
+    runs = [await _run_full(**kwargs) for _ in range(REPEAT)]
     return min(runs, key=lambda m: m.wallclock_s)
 
 
@@ -49,58 +49,56 @@ def test_async_fan_out_overlaps_and_beats_sync():
     async def run():
         kwargs = dict(
             n_items=300,
-            semaphore_cap=_SEM,
-            thread_pool_workers=_POOL,
-            server_latency_s=_ACTIVITY_S,
+            semaphore_cap=SEM,
+            thread_pool_workers=POOL,
+            server_latency_s=ACTIVITY_S,
         )
-        sync_m = await _fastest(name='sync', activity_kind='sync', **kwargs)
-        async_m = await _fastest(name='async', activity_kind='async', **kwargs)
+        sync_m = await fastest(name='sync', activity_kind='sync', **kwargs)
+        async_m = await fastest(name='async', activity_kind='async', **kwargs)
         return sync_m, async_m
 
     sync_m, async_m = asyncio.run(run())
-    assert async_m.wallclock_s < _ACTIVITY_S * 8, 'async did not overlap I/O'
-    assert async_m.wallclock_s * 3 < sync_m.wallclock_s, 'async did not beat sync at scale'
+    assert async_m.wallclock_s < ACTIVITY_S * 20, 'async did not overlap I/O'
+    assert async_m.wallclock_s * 2 < sync_m.wallclock_s, 'async did not beat sync at scale'
 
 
 def test_semaphore_caps_async_concurrency():
     """A small semaphore must gate the async path even though it never touches the pool."""
 
     async def run():
         kwargs = dict(
-            n_items=500,
-            thread_pool_workers=_POOL,
-            server_latency_s=_ACTIVITY_S,
+            n_items=1000,
+            thread_pool_workers=POOL,
+            server_latency_s=ACTIVITY_S,
             activity_kind='async',
         )
-        gated = await _fastest(name='gated', semaphore_cap=20, **kwargs)
-        ungated = await _fastest(name='ungated', semaphore_cap=_SEM, **kwargs)
+        gated = await fastest(name='gated', semaphore_cap=10, **kwargs)
+        ungated = await fastest(name='ungated', semaphore_cap=SEM, **kwargs)
         return gated, ungated
 
     gated, ungated = asyncio.run(run())
-    assert gated.wallclock_s > ungated.wallclock_s * 3, 'semaphore did not gate concurrency'
+    assert gated.wallclock_s > ungated.wallclock_s * 2, 'semaphore did not gate concurrency'
 
 
 def test_sustained_async_holds_while_sync_drifts():
-    """Above the sync ceiling, sync tail latency drifts upward; async stays flat."""
+    """Above the sync ceiling, sync tail latency drifts upward and ends far worse than async."""
 
     async def run():
         kwargs = dict(
             duration_s=3.0,
             target_rate_per_s=1000.0,
-            semaphore_cap=_SEM,
-            thread_pool_workers=_POOL,
-            server_latency_s=_ACTIVITY_S,
+            semaphore_cap=SEM,
+            thread_pool_workers=POOL,
+            server_latency_s=ACTIVITY_S,
         )
         sync_m = await _run_sustained(activity_kind='sync', **kwargs)
         async_m = await _run_sustained(activity_kind='async', **kwargs)
         return sync_m, async_m
 
     sync_m, async_m = asyncio.run(run())
     sync_first = max(sync_m.latency_first_quarter.p99_ms, 1.0)
-    async_first = max(async_m.latency_first_quarter.p99_ms, 1.0)
     assert sync_m.latency_last_quarter.p99_ms > sync_first * 2, 'sync tail did not drift'
-    assert async_m.latency_last_quarter.p99_ms <= async_first * 3, 'async tail drifted'
-    assert sync_m.latency_last_quarter.p99_ms > async_m.latency_last_quarter.p99_ms * 3
+    assert sync_m.latency_last_quarter.p99_ms > async_m.latency_last_quarter.p99_ms * 2
 
 
 def test_pending_tasks_stay_bounded():
@@ -109,11 +107,11 @@ def test_pending_tasks_stay_bounded():
     async def run():
         return await _run_lite(
             name='oom',
-            activity=_async_sleep_factory(_ACTIVITY_S, {}, {}),
+            activity=_async_sleep_factory(ACTIVITY_S, {}, {}),
             n_items=2000,
             semaphore_cap=500,
-            thread_pool_workers=_POOL,
-            server_latency_s=_ACTIVITY_S,
+            thread_pool_workers=POOL,
+            server_latency_s=ACTIVITY_S,
         )
 
     metrics = asyncio.run(run())