2525
2626#include < atomic>
2727#include < chrono>
28+ #include < functional>
2829#include < list>
2930#include < memory>
3031#include < mutex>
3132#include < thread>
3233#include < tuple>
34+ #include < vector>
3335
3436#include " common/config.h"
3537#include " common/object_pool.h"
@@ -967,19 +969,34 @@ TEST_F(ScannerContextTest, thread_pool_admission_state) {
967969 EXPECT_TRUE (scanner_context->is_context_queued (context_transfer_lock));
968970 scanner_context->set_context_queued (false , context_transfer_lock);
969971
970- // The Context admits exactly one scanner and counts it as scheduled. The time its runnable
971- // waited in the pool queue is credited to the admitted scanner's wait-worker time.
972- const int64_t wait_worker_time = scanner->get_scanner_wait_worker_timer ();
973- auto admitted_task = scanner_context->try_get_next_scan_task (context_transfer_lock, 1000 );
972+ // The Context admits exactly one scanner and counts it as scheduled. Its runnable was queued
973+ // (at 1000) before the scanner was returned to pending (at 2500), as with LIFO re-admission
974+ // of a scanner whose previous attempt ran while the runnable waited. Only the part of the
975+ // runnable's wait during which the scanner was pending is its wait-worker time.
976+ EXPECT_GT (consumed_task->pending_since_ns , 0 );
977+ consumed_task->pending_since_ns = 2500 ;
978+ int64_t wait_worker_time = scanner->get_scanner_wait_worker_timer ();
979+ auto admitted_task = scanner_context->try_get_next_scan_task (context_transfer_lock, 1000 , 3000 );
974980 EXPECT_EQ (admitted_task, consumed_task);
975- EXPECT_EQ (scanner->get_scanner_wait_worker_timer (), wait_worker_time + 1000 );
981+ EXPECT_EQ (scanner->get_scanner_wait_worker_timer (), wait_worker_time + 500 );
976982 EXPECT_EQ (scanner_context->_num_scheduled_scanners , 1 );
977983 EXPECT_TRUE (scanner_context->_pending_scanners .empty ());
978984
985+ // A scanner already pending when the runnable was queued waited for the whole queue time.
986+ scanner_context->_num_scheduled_scanners = 0 ;
987+ auto early_task = std::make_shared<ScanTask>(scanners.front ());
988+ scanner_context->push_pending_scan_task (early_task, context_transfer_lock);
989+ early_task->pending_since_ns = 500 ;
990+ wait_worker_time = scanner->get_scanner_wait_worker_timer ();
991+ EXPECT_EQ (scanner_context->try_get_next_scan_task (context_transfer_lock, 1000 , 3000 ),
992+ early_task);
993+ EXPECT_EQ (scanner->get_scanner_wait_worker_timer (), wait_worker_time + 2000 );
994+ EXPECT_EQ (scanner_context->_num_scheduled_scanners , 1 );
995+
979996 auto blocked_task = std::make_shared<ScanTask>(std::make_shared<ScannerDelegate>(scanner));
980997 scanner_context->push_pending_scan_task (blocked_task, context_transfer_lock);
981998 EXPECT_FALSE (scanner_context->can_admit_scan_task (context_transfer_lock, false ));
982- EXPECT_EQ (scanner_context->try_get_next_scan_task (context_transfer_lock, 0 ), nullptr );
999+ EXPECT_EQ (scanner_context->try_get_next_scan_task (context_transfer_lock, 0 , 0 ), nullptr );
9831000
9841001 // A stopped Context admits nothing even when nothing is progressing.
9851002 scanner_context->_num_scheduled_scanners = 0 ;
@@ -988,6 +1005,51 @@ TEST_F(ScannerContextTest, thread_pool_admission_state) {
9881005 EXPECT_FALSE (scanner_context->can_admit_scan_task (context_transfer_lock, false ));
9891006}
9901007
1008+ TEST_F (ScannerContextTest, thread_pool_admission_reads_queue_before_active_threads) {
1009+ const int parallel_tasks = 2 ;
1010+ auto scan_operator = std::make_unique<OlapScanOperatorX>(obj_pool.get (), tnode, 0 , *descs,
1011+ parallel_tasks, TQueryCacheParam {});
1012+ auto olap_scan_local_state =
1013+ OlapScanLocalState::create_unique (state.get (), scan_operator.get ());
1014+
1015+ OlapScanner::Params scanner_params;
1016+ scanner_params.state = state.get ();
1017+ scanner_params.profile = profile.get ();
1018+ scanner_params.limit = -1 ;
1019+ scanner_params.key_ranges = std::vector<OlapScanRange*>();
1020+ std::shared_ptr<Scanner> scanner =
1021+ OlapScanner::create_shared (olap_scan_local_state.get (), std::move (scanner_params));
1022+ std::list<std::shared_ptr<ScannerDelegate>> scanners;
1023+ for (int i = 0 ; i < 2 ; ++i) {
1024+ scanners.push_back (std::make_shared<ScannerDelegate>(scanner));
1025+ }
1026+ auto scanner_context = ScannerContext::create_shared (
1027+ state.get (), olap_scan_local_state.get (), output_tuple_desc, output_row_descriptor,
1028+ scanners, -1 , scan_dependency, parallel_tasks);
1029+
1030+ // A worker moves a task from queued to active under one pool lock, while admission reads the
1031+ // two counters under separate locks. Reading the queue first means a dequeue in between is
1032+ // counted twice (defer) rather than missed (overbook the last slot and fail the submission).
1033+ std::unique_ptr<MockSimplifiedScanScheduler> scheduler =
1034+ std::make_unique<MockSimplifiedScanScheduler>(cgroup_cpu_ctl);
1035+ {
1036+ testing::InSequence sequence;
1037+ EXPECT_CALL (*scheduler, get_queue_size ()).WillOnce (testing::Return (1 ));
1038+ EXPECT_CALL (*scheduler, get_active_threads ()).WillOnce (testing::Return (3 ));
1039+ }
1040+ scanner_context->_scanner_scheduler = scheduler.get ();
1041+ scanner_context->_min_scan_concurrency_of_scan_scheduler = 4 ;
1042+ scanner_context->_max_scan_concurrency = parallel_tasks;
1043+ scanner_context->_min_scan_concurrency = 1 ;
1044+ scanner_context->_scan_starving = false ;
1045+ scanner_context->_num_scheduled_scanners = 1 ;
1046+
1047+ std::unique_lock<std::mutex> transfer_lock (scanner_context->transfer_lock ());
1048+ ASSERT_FALSE (scanner_context->_pending_scanners .empty ());
1049+ // The over-counted pool looks full, so the Context stays at its minimum concurrency.
1050+ EXPECT_FALSE (scanner_context->can_admit_scan_task (transfer_lock, false ));
1051+ }
1052+
9911053TEST_F (ScannerContextTest, thread_pool_admission_follows_margin_limits) {
9921054 const int parallel_tasks = 4 ;
9931055 auto scan_operator = std::make_unique<OlapScanOperatorX>(obj_pool.get (), tnode, 0 , *descs,
@@ -1174,6 +1236,108 @@ TEST_F(ScannerContextTest, thread_pool_submit_failure_policy) {
11741236 EXPECT_TRUE (scanner_context->is_context_queued (transfer_lock));
11751237}
11761238
1239+ TEST_F (ScannerContextTest, thread_pool_budget_check_and_submit_are_atomic_across_contexts) {
1240+ // Three workers and no queue capacity. Two workers are parked, as if each ran a scanner of
1241+ // another Context, so the pool can accept exactly one more runnable.
1242+ ThreadPoolSimplifiedScanScheduler scheduler (" budget_race_test" , cgroup_cpu_ctl);
1243+ ASSERT_TRUE (scheduler.start (3 , 3 , 0 , 3 ).ok ());
1244+ CountDownLatch tasks_started (2 );
1245+ CountDownLatch release_tasks (1 );
1246+ Defer cleanup = [&] {
1247+ release_tasks.count_down ();
1248+ scheduler.stop ();
1249+ };
1250+ for (int i = 0 ; i < 2 ; ++i) {
1251+ ASSERT_TRUE (scheduler
1252+ .submit_scan_task (SimplifiedScanTask (
1253+ [&] {
1254+ tasks_started.count_down ();
1255+ release_tasks.wait ();
1256+ return true ;
1257+ },
1258+ nullptr , nullptr ))
1259+ .ok ());
1260+ }
1261+ ASSERT_TRUE (tasks_started.wait_for (std::chrono::seconds (5 )));
1262+ ASSERT_EQ (scheduler.get_active_threads (), 2 );
1263+
1264+ const int parallel_tasks = 4 ;
1265+ auto scan_operator = std::make_unique<OlapScanOperatorX>(obj_pool.get (), tnode, 0 , *descs,
1266+ parallel_tasks, TQueryCacheParam {});
1267+ auto olap_scan_local_state =
1268+ OlapScanLocalState::create_unique (state.get (), scan_operator.get ());
1269+ OlapScanner::Params scanner_params;
1270+ scanner_params.state = state.get ();
1271+ scanner_params.profile = profile.get ();
1272+ scanner_params.limit = -1 ;
1273+ scanner_params.key_ranges = std::vector<OlapScanRange*>();
1274+ std::shared_ptr<Scanner> scanner =
1275+ OlapScanner::create_shared (olap_scan_local_state.get (), std::move (scanner_params));
1276+
1277+ // Each Context has one scanner running and another pending, and has reached its minimum
1278+ // concurrency. It may only ramp up while the pool has slack.
1279+ std::vector<std::shared_ptr<ScannerContext>> contexts;
1280+ for (int i = 0 ; i < 2 ; ++i) {
1281+ std::list<std::shared_ptr<ScannerDelegate>> scanners;
1282+ for (int j = 0 ; j < 2 ; ++j) {
1283+ scanners.push_back (std::make_shared<ScannerDelegate>(scanner));
1284+ }
1285+ auto scanner_context = ScannerContext::create_shared (
1286+ state.get (), olap_scan_local_state.get (), output_tuple_desc, output_row_descriptor,
1287+ scanners, -1 , scan_dependency, parallel_tasks);
1288+ scanner_context->_scanner_scheduler = &scheduler;
1289+ scanner_context->_min_scan_concurrency_of_scan_scheduler = 3 ;
1290+ scanner_context->_max_scan_concurrency = parallel_tasks;
1291+ scanner_context->_min_scan_concurrency = 1 ;
1292+ scanner_context->_scan_starving = false ;
1293+ scanner_context->_num_scheduled_scanners = 1 ;
1294+ ASSERT_FALSE (scanner_context->_pending_scanners .empty ());
1295+ contexts.push_back (std::move (scanner_context));
1296+ }
1297+
1298+ // Park the first Context between its budget check and its submission until the second one
1299+ // reaches the same point, or for a bounded time if the scheduler serializes them. Without a
1300+ // scheduler-wide lock both pass the check on the last free slot and one submission fails.
1301+ std::atomic<int > entered {0 };
1302+ CountDownLatch second_entered (1 );
1303+ const bool old_enable_debug_points = config::enable_debug_points;
1304+ config::enable_debug_points = true ;
1305+ DebugPoints::instance ()->add_with_callback (
1306+ " ThreadPoolSimplifiedScanScheduler.schedule_scan_task.before_submit" ,
1307+ std::function<void ()>([&] {
1308+ if (entered.fetch_add (1 ) == 0 ) {
1309+ static_cast <void >(second_entered.wait_for (std::chrono::milliseconds (500 )));
1310+ } else {
1311+ second_entered.count_down ();
1312+ }
1313+ }));
1314+ Defer cleanup_debug_point = [&] {
1315+ DebugPoints::instance ()->remove (
1316+ " ThreadPoolSimplifiedScanScheduler.schedule_scan_task.before_submit" );
1317+ config::enable_debug_points = old_enable_debug_points;
1318+ };
1319+
1320+ Status statuses[2 ];
1321+ std::vector<std::thread> threads;
1322+ for (int i = 0 ; i < 2 ; ++i) {
1323+ threads.emplace_back ([&, i] {
1324+ std::unique_lock<std::mutex> transfer_lock (contexts[i]->transfer_lock ());
1325+ statuses[i] = scheduler.schedule_scan_task (contexts[i], nullptr , transfer_lock);
1326+ });
1327+ }
1328+ for (auto & thread : threads) {
1329+ thread.join ();
1330+ }
1331+
1332+ // The Context that lost the last slot defers instead of failing its query.
1333+ for (int i = 0 ; i < 2 ; ++i) {
1334+ EXPECT_TRUE (statuses[i].ok ()) << statuses[i].to_string ();
1335+ EXPECT_FALSE (contexts[i]->done ());
1336+ std::unique_lock<std::mutex> transfer_lock (contexts[i]->transfer_lock ());
1337+ EXPECT_TRUE (contexts[i]->_process_status .ok ());
1338+ }
1339+ }
1340+
11771341TEST_F (ScannerContextTest, run_context_publishes_admission_failure) {
11781342 const bool old_enable_debug_points = config::enable_debug_points;
11791343 config::enable_debug_points = true ;
0 commit comments