use it in qt

[bizehao]

This is the scheduling I implemented in QT, but it has issues and sometimes it won't be scheduled. Occasionally, I am confused and can't find where the problem lies

using namespace std::chrono_literals;
namespace {
    uint64_t milliseconds_until(
        const std::chrono::steady_clock::time_point& abs_time)
    {
        using std::chrono::duration_cast;
        auto now = std::chrono::steady_clock::now();
        if (now >= abs_time) return 0;
        return duration_cast<std::chrono::milliseconds>(abs_time - now).count() + 1;
    }
    bool is_max_time(const std::chrono::steady_clock::time_point& abs_time)
    {
        return abs_time == std::chrono::steady_clock::time_point::max();
    }
}

class scheduler : public boost::fibers::algo::algorithm
{
public:
    scheduler() {
        QTimer::singleShot(0, [this]() mutable {
            QEventLoop eventLoop;
            while (true) {
                if (has_ready_fibers()) {
                    //eventLoop.processEvents(QEventLoop::ApplicationExec | QEventLoop::EventLoopExec);
                    while (eventLoop.processEvents(QEventLoop::AllEvents));
                    std::unique_lock< boost::fibers::mutex > lk(mtx_);
                    cnd_.wait(lk);
                }
                else {
                    eventLoop.processEvents(QEventLoop::WaitForMoreEvents);
                }
            }
            });
    };

    ~scheduler() override {};

    void awakened(boost::fibers::context* ctx) noexcept override {
        BOOST_ASSERT(nullptr != ctx);
        BOOST_ASSERT(!ctx->ready_is_linked());
        ctx->ready_link(rqueue_); /*< fiber, enqueue on ready queue >*/
        if (!ctx->is_context(boost::fibers::type::dispatcher_context)) {
            ++counter_;
        }
    }

    boost::fibers::context* pick_next() noexcept override {
        boost::fibers::context* ctx = nullptr;
        if (!rqueue_.empty()) {
            ctx = &rqueue_.front();
            rqueue_.pop_front();
            BOOST_ASSERT(nullptr != ctx);
            BOOST_ASSERT(boost::fibers::context::active() != ctx);
            if (!ctx->is_context(boost::fibers::type::dispatcher_context)) {
                --counter_;
            }
        }
        return ctx;
    }

    bool has_ready_fibers() const noexcept override {
        return 0 < counter_;
    }

    void suspend_until(std::chrono::steady_clock::time_point const& abs_time) noexcept override {
        if (!is_max_time(abs_time)) {
            QTimer::singleShot(milliseconds_until(abs_time), []() {
                boost::this_fiber::yield();
                });
        }
        cnd_.notify_one();
    }

    void notify() noexcept override {
        QTimer::singleShot(0, []() {
            boost::this_fiber::yield();
            });
    }

    // Non-copyable and non-movable
    scheduler(const scheduler&) = delete;
    scheduler& operator=(const scheduler&) = delete;
    scheduler(scheduler&&) = delete;
    scheduler& operator=(scheduler&&) = delete;

private:
    boost::fibers::mutex                            mtx_;
    boost::fibers::condition_variable               cnd_;
    std::size_t                                     counter_{ 0 };
    boost::fibers::scheduler::ready_queue_type      rqueue_;
};

//test code
boost::fibers::use_scheduling_algorithm<scheduler>();

boost::fibers::fiber ff{ []() {
        for (int i = 0; i < 10; i++) {
            boost::this_fiber::sleep_for(5s);
            qDebug() << "i: " << i;
        }
        } };

ff.detach();