Queue up state sends instead of sending from inside lock.

Author: Mysticial

SerialPrograms/Source/Controllers/SuperscalarScheduler.cpp

@@ -40,9 +40,9 @@ void SuperscalarScheduler::clear() noexcept{
     m_pending_clear.store(false, std::memory_order_release);
 }
 
-std::vector<std::shared_ptr<const SchedulerResource>> SuperscalarScheduler::current_live_commands(){
+SuperscalarScheduler::State SuperscalarScheduler::current_live_commands(){
     WallClock device_sent_time = m_device_sent_time;
-    std::vector<std::shared_ptr<const SchedulerResource>> ret;
+    State ret;
     for (auto& item : m_live_commands){
         if (item.second.busy_time <= device_sent_time && device_sent_time < item.second.done_time){
             ret.emplace_back(item.second.command);
@@ -61,11 +61,7 @@ void SuperscalarScheduler::clear_finished_commands(){
         }
     }
 }
-bool SuperscalarScheduler::iterate_schedule(const Cancellable* cancellable){
-    if (cancellable){
-        cancellable->throw_if_cancelled();
-    }
-
+bool SuperscalarScheduler::iterate_schedule(Schedule& schedule){
 //    cout << "----------------------------> " << m_state_changes.size() << endl;
 //    cout << "m_device_sent_time = " << std::chrono::duration_cast<Milliseconds>(m_device_sent_time - m_local_start) << endl;
 
@@ -113,7 +109,9 @@ bool SuperscalarScheduler::iterate_schedule(const Cancellable* cancellable){
         m_state_changes.erase(iter);
     }
 
-    this->push_state(cancellable, duration, std::move(state));
+    ScheduleEntry& entry = schedule.emplace_back();
+    entry.duration = duration;
+    entry.state = std::move(state);
 
 //    SpinLockGuard lg(m_lock);
 
@@ -153,18 +151,18 @@ bool SuperscalarScheduler::iterate_schedule(const Cancellable* cancellable){
 
     return true;
 }
-void SuperscalarScheduler::process_schedule(const Cancellable* cancellable){
+void SuperscalarScheduler::process_schedule(Schedule& schedule){
     //  Any exception is either an unrecoverable error, or an async-cancel.
     //  Both cases should clear the scheduler.
     try{
-        while (iterate_schedule(cancellable));
+        while (iterate_schedule(schedule));
     }catch (...){
         clear();
         throw;
     }
 }
 
-void SuperscalarScheduler::issue_wait_for_all(const Cancellable* cancellable){
+void SuperscalarScheduler::issue_wait_for_all(Schedule& schedule){
     if (m_pending_clear.load(std::memory_order_acquire)){
         clear();
         return;
@@ -177,9 +175,9 @@ void SuperscalarScheduler::issue_wait_for_all(const Cancellable* cancellable){
 //         << endl;
     m_device_issue_time = std::max(m_device_issue_time, m_max_free_time);
     m_max_free_time = m_device_issue_time;
-    process_schedule(cancellable);
+    process_schedule(schedule);
 }
-void SuperscalarScheduler::issue_nop(const Cancellable* cancellable, WallDuration delay){
+void SuperscalarScheduler::issue_nop(Schedule& schedule, WallDuration delay){
     if (delay <= WallDuration::zero()){
         return;
     }
@@ -196,12 +194,9 @@ void SuperscalarScheduler::issue_nop(const Cancellable* cancellable, WallDuratio
     m_device_issue_time = next_issue_time;
     m_max_free_time = std::max(m_max_free_time, m_device_issue_time);
     m_local_last_activity = current_time();
-    process_schedule(cancellable);
+    process_schedule(schedule);
 }
-void SuperscalarScheduler::issue_wait_for_resource(
-    const Cancellable* cancellable,
-    size_t resource_id
-){
+void SuperscalarScheduler::issue_wait_for_resource(Schedule& schedule, size_t resource_id){
     if (m_pending_clear.load(std::memory_order_acquire)){
         clear();
         return;
@@ -219,10 +214,10 @@ void SuperscalarScheduler::issue_wait_for_resource(
         m_local_last_activity = current_time();
     }
 
-    process_schedule(cancellable);
+    process_schedule(schedule);
 }
 void SuperscalarScheduler::issue_to_resource(
-    const Cancellable* cancellable,
+    Schedule& schedule,
     std::shared_ptr<const SchedulerResource> resource,
     WallDuration delay, WallDuration hold, WallDuration cooldown
 ){
@@ -268,7 +263,7 @@ void SuperscalarScheduler::issue_to_resource(
     m_max_free_time = std::max(m_max_free_time, m_device_issue_time);
     m_local_last_activity = current_time();
 
-    process_schedule(cancellable);
+    process_schedule(schedule);
 }
 
 

SerialPrograms/Source/Controllers/SuperscalarScheduler.h

@@ -11,8 +11,10 @@
 #include <set>
 #include <map>
 #include <atomic>
+#include "Common/Compiler.h"
+#include "Common/Cpp/Time.h"
 #include "Common/Cpp/AbstractLogger.h"
-#include "Common/Cpp/CancellableScope.h"
+//#include "Common/Cpp/CancellableScope.h"
 
 namespace PokemonAutomation{
 
@@ -37,6 +39,14 @@ class SchedulerResource{
 
 
 class SuperscalarScheduler{
+public:
+    using State = std::vector<std::shared_ptr<const SchedulerResource>>;
+    struct ScheduleEntry{
+        WallDuration duration;
+        State state;
+    };
+    using Schedule = std::vector<ScheduleEntry>;
+
 public:
     SuperscalarScheduler(Logger& logger, WallDuration flush_threshold);
 
@@ -53,7 +63,9 @@ class SuperscalarScheduler{
 public:
     //  These are the standard "issue" commands.
     //
-    //  These functions may or may not block.
+    //  These functions are non-blocking and will append any new schedule
+    //  entries to "schedule".
+    //
     //  These are not thread-safe with each other.
     //
 
@@ -66,52 +78,30 @@ class SuperscalarScheduler{
 
     //  Wait until the pipeline has completely cleared and all resources have
     //  returned to the ready state.
-    void issue_wait_for_all(const Cancellable* cancellable);
+    void issue_wait_for_all(Schedule& schedule);
 
     //  Issue a do-nothing command for the specified delay.
     //  This will advance the issue timestamp.
-    void issue_nop(const Cancellable* cancellable, WallDuration delay);
+    void issue_nop(Schedule& schedule, WallDuration delay);
 
     //  Wait until the specified resource is ready to be used.
     //  This will advance the issue timestamp until the resource is ready.
-    void issue_wait_for_resource(
-        const Cancellable* cancellable,
-        size_t resource_id
-    );
+    void issue_wait_for_resource(Schedule& schedule, size_t resource_id);
 
     //  Issue a resource with the specified timing parameters.
     void issue_to_resource(
-        const Cancellable* cancellable,
+        Schedule& schedule,
         std::shared_ptr<const SchedulerResource> resource,
         WallDuration delay, WallDuration hold, WallDuration cooldown
     );
 
 
-protected:
-    //
-    //  This class will automatically call "push_state()" when a state is ready.
-    //  The child class should send/queue this state to the device/Switch.
-    //
-    //  This function is allowed to block. In other words, it can wait until
-    //  there is space in the queue before returning.
-    //
-    //  This will always be called inside one of the above "issue_XXX()"
-    //  functions. Implementations of this method should be aware of this
-    //  re-entrancy when this gets called on them with respect to locking.
-    //
-    virtual void push_state(
-        const Cancellable* cancellable,
-        WallDuration duration,
-        std::vector<std::shared_ptr<const SchedulerResource>> state
-    ) = 0;
-
-
 private:
     void clear() noexcept;
-    std::vector<std::shared_ptr<const SchedulerResource>> current_live_commands();
+    State current_live_commands();
     void clear_finished_commands();
-    bool iterate_schedule(const Cancellable* cancellable);
-    void process_schedule(const Cancellable* cancellable);
+    bool iterate_schedule(Schedule& schedule);
+    void process_schedule(Schedule& schedule);
 
 
 private: