Add new priority class for inference that can tolerate starvation.

Mysticial · Mysticial · commit f0eb83d9d065 · 2025-06-21T14:08:23.000-07:00
diff --git a/SerialPrograms/Source/CommonFramework/Environment/Environment_Linux.h b/SerialPrograms/Source/CommonFramework/Environment/Environment_Linux.h
@@ -20,9 +20,10 @@ enum class ThreadPriority{
     Min,
 };
 
-constexpr ThreadPriority DEFAULT_PRIORITY_REALTIME  = ThreadPriority::Max;
-constexpr ThreadPriority DEFAULT_PRIORITY_INFERENCE = ThreadPriority::Max;
-constexpr ThreadPriority DEFAULT_PRIORITY_COMPUTE   = ThreadPriority::Min;
+constexpr ThreadPriority DEFAULT_PRIORITY_REALTIME              = ThreadPriority::Max;
+constexpr ThreadPriority DEFAULT_PRIORITY_REALTIME_INFERENCE    = ThreadPriority::Max;
+constexpr ThreadPriority DEFAULT_PRIORITY_NORMAL_INFERENCE      = ThreadPriority::Min;
+constexpr ThreadPriority DEFAULT_PRIORITY_COMPUTE               = ThreadPriority::Min;
 
 
 
diff --git a/SerialPrograms/Source/CommonFramework/Environment/Environment_Windows.h b/SerialPrograms/Source/CommonFramework/Environment/Environment_Windows.h
@@ -22,9 +22,10 @@ enum class ThreadPriority{
     Low,
 };
 
-constexpr ThreadPriority DEFAULT_PRIORITY_REALTIME  = ThreadPriority::High;
-constexpr ThreadPriority DEFAULT_PRIORITY_INFERENCE = ThreadPriority::AboveNormal;
-constexpr ThreadPriority DEFAULT_PRIORITY_COMPUTE   = ThreadPriority::BelowNormal;
+constexpr ThreadPriority DEFAULT_PRIORITY_REALTIME              = ThreadPriority::High;
+constexpr ThreadPriority DEFAULT_PRIORITY_REALTIME_INFERENCE    = ThreadPriority::AboveNormal;
+constexpr ThreadPriority DEFAULT_PRIORITY_NORMAL_INFERENCE      = ThreadPriority::BelowNormal;
+constexpr ThreadPriority DEFAULT_PRIORITY_COMPUTE               = ThreadPriority::BelowNormal;
 
 
 
diff --git a/SerialPrograms/Source/CommonFramework/Options/Environment/PerformanceOptions.h b/SerialPrograms/Source/CommonFramework/Options/Environment/PerformanceOptions.h
@@ -40,10 +40,17 @@ class PerformanceOptions : public GroupOption{
             "Restart the program for this to fully take effect.",
             DEFAULT_PRIORITY_REALTIME
         )
-        , INFERENCE_PRIORITY(
+        , REALTIME_INFERENCE_PRIORITY(
             "<b>Inference Priority:</b><br>"
-            "Thread priority of inference threads. (image/sound recognition)",
-            DEFAULT_PRIORITY_INFERENCE
+            "Thread priority of realtime inference threads that must run fast "
+            "enough to keep a program working properly.",
+            DEFAULT_PRIORITY_REALTIME_INFERENCE
+        )
+        , NORMAL_INFERENCE_PRIORITY(
+            "<b>normal Inference Priority:</b><br>"
+            "Thread priority of non-realtime inference threads that can be slow "
+            "without negatively affecting a program.",
+            DEFAULT_PRIORITY_NORMAL_INFERENCE
         )
         , COMPUTE_PRIORITY(
             "<b>Compute Priority:</b><br>"
@@ -53,7 +60,8 @@ class PerformanceOptions : public GroupOption{
     {
         PA_ADD_OPTION(PRECISE_WAKE_MARGIN);
         PA_ADD_OPTION(REALTIME_THREAD_PRIORITY);
-        PA_ADD_OPTION(INFERENCE_PRIORITY);
+        PA_ADD_OPTION(REALTIME_INFERENCE_PRIORITY);
+        PA_ADD_OPTION(NORMAL_INFERENCE_PRIORITY);
         PA_ADD_OPTION(COMPUTE_PRIORITY);
         PA_ADD_OPTION(PROCESSOR_LEVEL);
     }
@@ -62,7 +70,8 @@ class PerformanceOptions : public GroupOption{
     MicrosecondsOption PRECISE_WAKE_MARGIN;
 
     ThreadPriorityOption REALTIME_THREAD_PRIORITY;
-    ThreadPriorityOption INFERENCE_PRIORITY;
+    ThreadPriorityOption REALTIME_INFERENCE_PRIORITY;
+    ThreadPriorityOption NORMAL_INFERENCE_PRIORITY;
     ThreadPriorityOption COMPUTE_PRIORITY;
 
     ProcessorLevelOption PROCESSOR_LEVEL;
diff --git a/SerialPrograms/Source/CommonFramework/Tools/ProgramEnvironment.cpp b/SerialPrograms/Source/CommonFramework/Tools/ProgramEnvironment.cpp
@@ -21,7 +21,8 @@ struct ProgramEnvironmentData{
     const ProgramInfo& m_program_info;
 
     AsyncDispatcher m_realtime_dispatcher;
-    AsyncDispatcher m_inference_dispatcher;
+    AsyncDispatcher m_realtime_inference_dispatcher;
+    AsyncDispatcher m_normal_inference_dispatcher;
 
     ProgramEnvironmentData(
         const ProgramInfo& program_info
@@ -33,9 +34,15 @@ struct ProgramEnvironmentData{
             },
             0
         )
-        , m_inference_dispatcher(
+        , m_realtime_inference_dispatcher(
             [](){
-                GlobalSettings::instance().PERFORMANCE->INFERENCE_PRIORITY.set_on_this_thread();
+                GlobalSettings::instance().PERFORMANCE->REALTIME_INFERENCE_PRIORITY.set_on_this_thread();
+            },
+            0
+        )
+        , m_normal_inference_dispatcher(
+            [](){
+                GlobalSettings::instance().PERFORMANCE->NORMAL_INFERENCE_PRIORITY.set_on_this_thread();
             },
             0
         )
@@ -66,8 +73,11 @@ const ProgramInfo& ProgramEnvironment::program_info() const{
 AsyncDispatcher& ProgramEnvironment::realtime_dispatcher(){
     return m_data->m_realtime_dispatcher;
 }
-AsyncDispatcher& ProgramEnvironment::inference_dispatcher(){
-    return m_data->m_inference_dispatcher;
+AsyncDispatcher& ProgramEnvironment::realtime_inference_dispatcher(){
+    return m_data->m_realtime_inference_dispatcher;
+}
+AsyncDispatcher& ProgramEnvironment::normal_inference_dispatcher(){
+    return m_data->m_normal_inference_dispatcher;
 }
 
 
diff --git a/SerialPrograms/Source/CommonFramework/Tools/ProgramEnvironment.h b/SerialPrograms/Source/CommonFramework/Tools/ProgramEnvironment.h
@@ -41,8 +41,18 @@ class ProgramEnvironment{
 
 public:
     //  Thread Pools
+
+    //  A high-priority dispatcher for program and logic threads that cannot
+    //  tolerate being delayed.
     AsyncDispatcher& realtime_dispatcher();
-    AsyncDispatcher& inference_dispatcher();
+
+    //  A high-priority dispatcher for inference where starvation may cause the
+    //  program to encounter issues.
+    AsyncDispatcher& realtime_inference_dispatcher();
+
+    //  A low-priority dispatcher for inference where starvation will not affect
+    //  the functionality of the program.
+    AsyncDispatcher& normal_inference_dispatcher();
 
 public:
     //  Stats Management
diff --git a/SerialPrograms/Source/CommonTools/GlobalInferenceRunner.cpp b/SerialPrograms/Source/CommonTools/GlobalInferenceRunner.cpp
@@ -15,7 +15,7 @@ namespace PokemonAutomation{
 ParallelTaskRunner& global_inference_runner(){
     static ParallelTaskRunner runner(
         [](){
-            GlobalSettings::instance().PERFORMANCE->INFERENCE_PRIORITY.set_on_this_thread();
+            GlobalSettings::instance().PERFORMANCE->NORMAL_INFERENCE_PRIORITY.set_on_this_thread();
         },
         0, std::thread::hardware_concurrency()
     );
diff --git a/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase3_ProController.cpp b/SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase3_ProController.cpp
@@ -37,10 +37,10 @@ ProController_SysbotBase3::~ProController_SysbotBase3(){
 
 const ControllerFeatures& ProController_SysbotBase3::controller_features() const{
     static const ControllerFeatures features{
-        ControllerFeature::TickPrecise,   //  TODO: Prove it is tick precise.
+        ControllerFeature::TickPrecise,
         ControllerFeature::TimingFlexibleMilliseconds,
         ControllerFeature::NintendoSwitch_ProController,
-        ControllerFeature::NintendoSwitch_DateSkip,   //  TODO: Prove this works
+        ControllerFeature::NintendoSwitch_DateSkip,
     };
     return features;
 }
diff --git a/SerialPrograms/Source/NintendoSwitch/DevPrograms/TestProgramSwitch.cpp b/SerialPrograms/Source/NintendoSwitch/DevPrograms/TestProgramSwitch.cpp
@@ -325,6 +325,8 @@ void TestProgram::program(MultiSwitchProgramEnvironment& env, CancellableScope&
     ProControllerContext context(scope, console.pro_controller());
     VideoOverlaySet overlays(overlay);
 
+    FastCodeEntry::numberpad_enter_code(console, context, "708538991006", true);
+
 
 
 #if 0
@@ -416,14 +418,14 @@ void TestProgram::program(MultiSwitchProgramEnvironment& env, CancellableScope&
 #endif
 
 
-#if 0
-    HomeMenuDetector detector0;
-    StartGameUserSelectDetector detector1;
-    UpdatePopupDetector detector2;
-    detector0.make_overlays(overlays);
-    detector1.make_overlays(overlays);
+#if 1
+    HomeMenuDetector detector0(console);
+    StartGameUserSelectDetector detector1(console);
+    UpdatePopupDetector detector2(console);
+//    detector0.make_overlays(overlays);
+//    detector1.make_overlays(overlays);
     detector2.make_overlays(overlays);
-    cout << detector1.detect(feed.snapshot()) << endl;
+    cout << detector2.detect(feed.snapshot()) << endl;
 #endif
 
 
diff --git a/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_MultiSwitchProgram.cpp b/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_MultiSwitchProgram.cpp
@@ -31,7 +31,7 @@ MultiSwitchProgramEnvironment::MultiSwitchProgramEnvironment(
     , consoles(std::move(p_switches))
 {
     for (ConsoleHandle& console : consoles){
-        console.initialize_inference_threads(scope, inference_dispatcher());
+        console.initialize_inference_threads(scope, realtime_inference_dispatcher());
     }
 }
 
diff --git a/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h b/SerialPrograms/Source/NintendoSwitch/NintendoSwitch_SingleSwitchProgram.h
@@ -44,7 +44,7 @@ class SingleSwitchProgramEnvironment : public ProgramEnvironment{
         : ProgramEnvironment(program_info, session, current_stats, historical_stats)
         , console(0, std::forward<Args>(args)...)
     {
-        console.initialize_inference_threads(scope, inference_dispatcher());
+        console.initialize_inference_threads(scope, realtime_inference_dispatcher());
     }
 };
 
diff --git a/SerialPrograms/Source/PokemonSV/Programs/Eggs/PokemonSV_EggAutonomous.cpp b/SerialPrograms/Source/PokemonSV/Programs/Eggs/PokemonSV_EggAutonomous.cpp
@@ -198,7 +198,7 @@ void EggAutonomous::program(SingleSwitchProgramEnvironment& env, ProControllerCo
         //     process_one_baby(env, context, i, 5);
         // }
 
-        // eat_egg_sandwich_at_picnic(env.program_info(), env.realtime_dispatcher(), env.console, context,
+        // eat_egg_sandwich_at_picnic(env.program_info(), env.normal_inference_dispatcher(), env.console, context,
         //     EGG_SANDWICH_TYPE, SWEET_HERB_INDEX_BACKWARDS.current_value());
         // return;
     }
diff --git a/SerialPrograms/Source/PokemonSV/Programs/Eggs/PokemonSV_EggRoutines.cpp b/SerialPrograms/Source/PokemonSV/Programs/Eggs/PokemonSV_EggRoutines.cpp
@@ -305,7 +305,12 @@ bool eat_egg_sandwich_at_picnic(
         if (language == Language::None){
             throw UserSetupError(stream.logger(), "Must set game language option to read ingredient lists to make herb sandwich.");
         }
-        make_two_herbs_sandwich(env.program_info(), env.realtime_dispatcher(), stream, context, sandwich_type, language);
+        make_two_herbs_sandwich(
+            env.program_info(), env.realtime_inference_dispatcher(),
+            stream, context,
+            sandwich_type,
+            language
+        );
         finish_sandwich_eating(env.program_info(), stream, context);
         break;
     default:
diff --git a/SerialPrograms/Source/PokemonSV/Programs/ItemPrinter/PokemonSV_AutoItemPrinter.cpp b/SerialPrograms/Source/PokemonSV/Programs/ItemPrinter/PokemonSV_AutoItemPrinter.cpp
@@ -134,8 +134,15 @@ void AutoItemPrinter::program(SingleSwitchProgramEnvironment& env, ProController
     enter_printing_mode(env, context);
 
     for (uint16_t i = 0; i < NUM_ROUNDS; i++){
-        item_printer_start_print(env.inference_dispatcher(), env.console, context, LANGUAGE, ItemPrinterJobs::Jobs_10);
-        item_printer_finish_print(env.inference_dispatcher(), env.console, context, Language::None);
+        item_printer_start_print(
+            env.normal_inference_dispatcher(),
+            env.console, context, LANGUAGE,
+            ItemPrinterJobs::Jobs_10
+        );
+        item_printer_finish_print(
+            env.normal_inference_dispatcher(),
+            env.console, context, Language::None
+        );
 
         env.console.log("Print completed.");
         stats.m_rounds++;
diff --git a/SerialPrograms/Source/PokemonSV/Programs/ItemPrinter/PokemonSV_ItemPrinterRNG.cpp b/SerialPrograms/Source/PokemonSV/Programs/ItemPrinter/PokemonSV_ItemPrinterRNG.cpp
@@ -418,11 +418,11 @@ ItemPrinterPrizeResult ItemPrinterRNG::run_print_at_date(
                 pbf_press_button(context, BUTTON_B, 20, 30);
                 continue;
             }
-            item_printer_start_print(env.inference_dispatcher(), env.console, context, LANGUAGE, jobs);
+            item_printer_start_print(env.normal_inference_dispatcher(), env.console, context, LANGUAGE, jobs);
             stats.prints++;
             env.update_stats();
             printed = true;
-            prize_result = item_printer_finish_print(env.inference_dispatcher(), env.console, context, LANGUAGE);
+            prize_result = item_printer_finish_print(env.normal_inference_dispatcher(), env.console, context, LANGUAGE);
             std::array<std::string, 10> print_results = prize_result.prizes;
             uint64_t seed = to_seconds_since_epoch(date);
             int distance_from_target = get_distance_from_target(env.console, stats, print_results, seed);
@@ -609,11 +609,11 @@ void ItemPrinterRNG::print_again(
             if (printed){
                 return;
             }
-            item_printer_start_print(env.inference_dispatcher(), env.console, context, LANGUAGE, jobs);
+            item_printer_start_print(env.normal_inference_dispatcher(), env.console, context, LANGUAGE, jobs);
             stats.prints++;
             env.update_stats();
             printed = true;
-            item_printer_finish_print(env.inference_dispatcher(), env.console, context, LANGUAGE);
+            item_printer_finish_print(env.normal_inference_dispatcher(), env.console, context, LANGUAGE);
             continue;
         }
         default:
@@ -985,8 +985,15 @@ uint32_t ItemPrinterRNG::check_num_happiny_dust(
             env.log("Detected material selection.");
             ItemPrinterMaterialDetector detector(COLOR_RED, LANGUAGE);
             
-            int8_t happiny_dust_row_num = detector.find_happiny_dust_row_index(env.inference_dispatcher(), env.console, context);
-            num_happiny_dust = detector.detect_material_quantity(env.inference_dispatcher(), env.console, context, happiny_dust_row_num);
+            int8_t happiny_dust_row_num = detector.find_happiny_dust_row_index(
+                env.normal_inference_dispatcher(),
+                env.console, context
+            );
+            num_happiny_dust = detector.detect_material_quantity(
+                env.normal_inference_dispatcher(),
+                env.console, context,
+                happiny_dust_row_num
+            );
             pbf_mash_button(context, BUTTON_B, 100);
             return num_happiny_dust;
         }
diff --git a/SerialPrograms/Source/PokemonSV/Programs/Sandwiches/PokemonSV_SandwichRoutines.cpp b/SerialPrograms/Source/PokemonSV/Programs/Sandwiches/PokemonSV_SandwichRoutines.cpp
@@ -576,7 +576,14 @@ ImageFloatBox move_sandwich_hand(
     const ImageFloatBox& start_box,
     const ImageFloatBox& end_box
 ){
-    return move_sandwich_hand_and_check_if_plates_empty(info, dispatcher, stream, context, hand_type, pressing_A, start_box, end_box, SandwichPlateDetector::Side::NOT_APPLICABLE, Language::None).end_box;
+    return move_sandwich_hand_and_check_if_plates_empty(
+        info, dispatcher,
+        stream, context,
+        hand_type, pressing_A,
+        start_box, end_box,
+        SandwichPlateDetector::Side::NOT_APPLICABLE,
+        Language::None
+    ).end_box;
 }
 
 } // end anonymous namespace
@@ -1046,7 +1053,7 @@ void make_sandwich_preset(ProgramEnvironment& env, VideoStream& stream, ProContr
     std::map<std::string, uint8_t> fillings_copy(fillings); //Making a copy as we need the map for later
     enter_custom_sandwich_mode(env.program_info(), stream, context);
     add_sandwich_ingredients(
-        env.realtime_dispatcher(),
+        env.normal_inference_dispatcher(),
         stream, context,
         language,
         std::move(fillings_copy),
@@ -1184,15 +1191,15 @@ void run_sandwich_maker(ProgramEnvironment& env, VideoStream& stream, ProControl
     ImageFloatBox target_plate = center_plate;
     //Initial position handling
     auto end_box = move_sandwich_hand(
-        env.program_info(), env.realtime_dispatcher(),
+        env.program_info(), env.realtime_inference_dispatcher(),
         stream, context,
         SandwichHandType::FREE,
         false,
         HAND_INITIAL_BOX,
         HAND_INITIAL_BOX
     );
     move_sandwich_hand(
-        env.program_info(), env.realtime_dispatcher(),
+        env.program_info(), env.realtime_inference_dispatcher(),
         stream, context,
         SandwichHandType::GRABBING,
         true,
@@ -1263,7 +1270,7 @@ void run_sandwich_maker(ProgramEnvironment& env, VideoStream& stream, ProControl
                 }
 
                 end_box = move_sandwich_hand(
-                    env.program_info(), env.realtime_dispatcher(),
+                    env.program_info(), env.realtime_inference_dispatcher(),
                     stream, context,
                     SandwichHandType::FREE,
                     false,
@@ -1277,7 +1284,7 @@ void run_sandwich_maker(ProgramEnvironment& env, VideoStream& stream, ProControl
                     (int)fillings.find(i)->second).at(placement_number);
 
                 HandMoveData hand_move_data = move_sandwich_hand_and_check_if_plates_empty(
-                    env.program_info(), env.realtime_dispatcher(),
+                    env.program_info(), env.realtime_inference_dispatcher(),
                     stream, context,
                     SandwichHandType::GRABBING,
                     true,
@@ -1326,7 +1333,7 @@ void run_sandwich_maker(ProgramEnvironment& env, VideoStream& stream, ProControl
     auto hand_box = hand_location_to_box(grabbing_hand.location());
 
     end_box = move_sandwich_hand(
-        env.program_info(), env.realtime_dispatcher(),
+        env.program_info(), env.realtime_inference_dispatcher(),
         stream, context,
         SandwichHandType::GRABBING,
         false,
diff --git a/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_AutoHost.cpp b/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_AutoHost.cpp
@@ -134,7 +134,7 @@ WallClock AutoHost::wait_for_lobby_open(
 ){
     VideoOverlaySet overlays(env.console.overlay());
 
-    TeraLobbyWatcher lobby(env.logger(), env.realtime_dispatcher(), COLOR_RED);
+    TeraLobbyWatcher lobby(env.logger(), env.normal_inference_dispatcher(), COLOR_RED);
     lobby.make_overlays(overlays);
 
     int ret = wait_until(
@@ -153,8 +153,8 @@ WallClock AutoHost::wait_for_lobby_open(
     context.wait_for(std::chrono::seconds(1));
 
     VideoSnapshot snapshot = env.console.video().snapshot();
-    lobby_code = lobby.raid_code(env.logger(), env.inference_dispatcher(), snapshot);
-    std::string code = lobby.raid_code(env.logger(), env.inference_dispatcher(), snapshot);
+    lobby_code = lobby.raid_code(env.logger(), env.normal_inference_dispatcher(), snapshot);
+    std::string code = lobby.raid_code(env.logger(), env.normal_inference_dispatcher(), snapshot);
     normalize_code(lobby_code, code);
 
     send_host_announcement(
diff --git a/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_AutoHostLobbyWaiter.cpp b/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_AutoHostLobbyWaiter.cpp
@@ -40,8 +40,8 @@ TeraLobbyWaiter::TeraLobbyWaiter(
     , m_notification_raid_start(NOTIFICATION_RAID_START)
     , m_dialog(COLOR_YELLOW)
     , m_start_raid(COLOR_BLUE)
-    , m_join_watcher(stream.logger(), env.realtime_dispatcher(), COLOR_RED, host_players)
-    , m_name_watcher(stream.logger(), env.realtime_dispatcher(), COLOR_RED, JOIN_REPORT, BAN_LIST, host_players)
+    , m_join_watcher(stream.logger(), env.normal_inference_dispatcher(), COLOR_RED, host_players)
+    , m_name_watcher(stream.logger(), env.normal_inference_dispatcher(), COLOR_RED, JOIN_REPORT, BAN_LIST, host_players)
 {}
 
 VideoSnapshot TeraLobbyWaiter::synchronize_state(){
diff --git a/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_TeraMultiFarmer.cpp b/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_TeraMultiFarmer.cpp
diff --git a/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_TeraRoutines.cpp b/SerialPrograms/Source/PokemonSV/Programs/TeraRaids/PokemonSV_TeraRoutines.cpp

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,8 @@ struct ProgramEnvironmentData{`
`21`	`21`	`const ProgramInfo& m_program_info;`
`22`	`22`
`23`	`23`	`AsyncDispatcher m_realtime_dispatcher;`
`24`		`- AsyncDispatcher m_inference_dispatcher;`
	`24`	`+ AsyncDispatcher m_realtime_inference_dispatcher;`
	`25`	`+ AsyncDispatcher m_normal_inference_dispatcher;`
`25`	`26`
`26`	`27`	`ProgramEnvironmentData(`
`27`	`28`	`const ProgramInfo& program_info`
`@@ -33,9 +34,15 @@ struct ProgramEnvironmentData{`
`33`	`34`	`},`
`34`	`35`	`0`
`35`	`36`	`)`
`36`		`- , m_inference_dispatcher(`
	`37`	`+ , m_realtime_inference_dispatcher(`
`37`	`38`	`[](){`
`38`		`- GlobalSettings::instance().PERFORMANCE->INFERENCE_PRIORITY.set_on_this_thread();`
	`39`	`+ GlobalSettings::instance().PERFORMANCE->REALTIME_INFERENCE_PRIORITY.set_on_this_thread();`
	`40`	`+ },`
	`41`	`+ 0`
	`42`	`+ )`
	`43`	`+ , m_normal_inference_dispatcher(`
	`44`	`+ [](){`
	`45`	`+ GlobalSettings::instance().PERFORMANCE->NORMAL_INFERENCE_PRIORITY.set_on_this_thread();`
`39`	`46`	`},`
`40`	`47`	`0`
`41`	`48`	`)`
`@@ -66,8 +73,11 @@ const ProgramInfo& ProgramEnvironment::program_info() const{`
`66`	`73`	`AsyncDispatcher& ProgramEnvironment::realtime_dispatcher(){`
`67`	`74`	`return m_data->m_realtime_dispatcher;`
`68`	`75`	`}`
`69`		`-AsyncDispatcher& ProgramEnvironment::inference_dispatcher(){`
`70`		`- return m_data->m_inference_dispatcher;`
	`76`	`+AsyncDispatcher& ProgramEnvironment::realtime_inference_dispatcher(){`
	`77`	`+ return m_data->m_realtime_inference_dispatcher;`
	`78`	`+}`
	`79`	`+AsyncDispatcher& ProgramEnvironment::normal_inference_dispatcher(){`
	`80`	`+ return m_data->m_normal_inference_dispatcher;`
`71`	`81`	`}`
`72`	`82`
`73`	`83`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ MultiSwitchProgramEnvironment::MultiSwitchProgramEnvironment(`
`31`	`31`	`, consoles(std::move(p_switches))`
`32`	`32`	`{`
`33`	`33`	`for (ConsoleHandle& console : consoles){`
`34`		`- console.initialize_inference_threads(scope, inference_dispatcher());`
	`34`	`+ console.initialize_inference_threads(scope, realtime_inference_dispatcher());`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ class SingleSwitchProgramEnvironment : public ProgramEnvironment{`
`44`	`44`	`: ProgramEnvironment(program_info, session, current_stats, historical_stats)`
`45`	`45`	`, console(0, std::forward<Args>(args)...)`
`46`	`46`	`{`
`47`		`- console.initialize_inference_threads(scope, inference_dispatcher());`
	`47`	`+ console.initialize_inference_threads(scope, realtime_inference_dispatcher());`
`48`	`48`	`}`
`49`	`49`	`};`
`50`	`50`