{"id":111046,"date":"2025-04-04T07:00:00","date_gmt":"2025-04-04T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=111046"},"modified":"2025-04-04T09:43:50","modified_gmt":"2025-04-04T16:43:50","slug":"20250404-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20250404-00\/?p=111046","title":{"rendered":"Adding delays to our task sequencer, part 3"},"content":{"rendered":"

Last time, we added task throttling to our task_sequencer<\/code><\/a> by limiting requests to one per second. To do this, we used the steady_clock<\/code>. The standard leaves unspecified the resolution of the steady clock, but we can see how it is implemented on Windows by the three major libraries.<\/p>\n

On Windows, stl (msvc)<\/a> and libcxx (clang)<\/a>, and libstdc++ (gcc)<\/a>\/mingw<\/a> use Query\u00adPerformance\u00adCounter<\/code> as the source of the steady_clock<\/code>,\u00b9 reporting the time to nanosecond resolution. This is excellent resolution, but at a cost of significant arithmetic gymnastics.<\/p>\n

We can go cheaper.<\/p>\n

Our throttling delay of 1 second doesn’t have to be precise down to the nanosecond. In reality, it’ll only be as good as the hardware timer tick resolution, which is nowhere near 1 nanosecond. In practice, it’s closer to 10 milliseconds per tick, so an error of one or two milliseconds is well under measurement error.<\/p>\n

Therefore, we can choose to use Get\u00adTick\u00adCount\u00ad64<\/code> as our steady clock source. The Get\u00adTick\u00adCount\u00ad64<\/code> function is quite fast (just reading a 64-bit value from memory), and it reports at millisecond resolution, which means that it converts to TimeSpan<\/code> with multiplication and not division.<\/p>\n

struct task_sequencer\r\n{\r\n    \u27e6 ... \u27e7\r\n\r\n    struct completer\r\n    {\r\n        ~completer()\r\n        {\r\n            [](auto chain, auto delay) -> winrt::fire_and_forget {\r\n                co_await winrt::resume_after(delay);\r\n                chain->complete();\r\n            }(std::move(chain),\r\n              std::chrono::milliseconds(static_cast<int64_t><\/span>\r\n                (earliest - GetTickCount64()))<\/span>);            <\/span>\r\n        }\r\n        std::shared_ptr<chained_task> chain;\r\n        ULONGLONG earliest = GetTickCount64();<\/span>\r\n    };\r\n\r\n\r\npublic:\r\n    template<typename Maker>\r\n    auto QueueTaskAsync(Maker&& maker) ->decltype(maker())\r\n    {\r\n        auto node = std::make_shared<chained_task>();\r\n\r\n        suspender suspend;\r\n\r\n        using Async = decltype(maker());\r\n        auto task = [&]() -> Async\r\n        {\r\n            completer completer{ current };\r\n            auto local_maker = std::forward<Maker>(maker);\r\n            auto context = winrt::apartment_context();\r\n\r\n            co_await suspend;\r\n            co_await context;\r\n            completer.earliest = GetTickCount64() + 1000;<\/span>\r\n            co_return co_await local_maker();\r\n        }();\r\n\r\n        {\r\n            winrt::slim_lock_guard guard(m_mutex);\r\n            m_latest.swap(node);\r\n        }\r\n\r\n        node->continue_with(suspend.handle);\r\n\r\n        return task;\r\n    }\r\n\r\n    \u27e6 ... \u27e7\r\n};\r\n<\/pre>\n
If we really wanted to minimize the number of calls to Get\u00adTick\u00adCount64()<\/code>, we could use a std::optional<\/code>:<\/p>\n
struct task_sequencer\r\n{\r\n    \u27e6 ... \u27e7\r\n\r\n    struct completer\r\n    {\r\n        ~completer()\r\n        {\r\n            [](auto chain, auto delay) -> winrt::fire_and_forget {\r\n                co_await winrt::resume_after(delay);\r\n                chain->complete();\r\n            }(std::move(chain),\r\n              std::chrono::milliseconds(static_cast<int64_t>\r\n                (earliest ? *earliest - GetTickCount64() : 0)<\/span>));\r\n        }\r\n        std::shared_ptr<chained_task> chain;\r\n        std::optional<ULONGLONG><\/span> earliest;\r\n    };\r\n\r\n    \u27e6 ... \u27e7\r\n};\r\n<\/pre>\n
Or we could reserve the sentinel value of 0 to mean “no delay”.<\/p>\n
struct task_sequencer\r\n{\r\n    \u27e6 ... \u27e7\r\n\r\n    struct completer\r\n    {\r\n        ~completer()\r\n        {\r\n            [](auto chain, auto delay) -> winrt::fire_and_forget {\r\n                co_await winrt::resume_after(delay);\r\n                chain->complete();\r\n            }(std::move(chain),\r\n              std::chrono::milliseconds(static_cast<int64_t>\r\n                (earliest ? earliest - GetTickCount64() : 0)<\/span>));\r\n        }\r\n        std::shared_ptr<chained_task> chain;\r\n        ULONGLONG earliest = 0<\/span>;\r\n    };\r\n\r\n\r\npublic:\r\n    template<typename Maker>\r\n    auto QueueTaskAsync(Maker&& maker) ->decltype(maker())\r\n    {\r\n        auto node = std::make_shared<chained_task>();\r\n\r\n        suspender suspend;\r\n\r\n        using Async = decltype(maker());\r\n        auto task = [&]() -> Async\r\n        {\r\n            completer completer{ current };\r\n            auto local_maker = std::forward<Maker>(maker);\r\n            auto context = winrt::apartment_context();\r\n\r\n            co_await suspend;\r\n            co_await context;\r\n            completer.earliest = (GetTickCount64() + 1000) | 1<\/span>;\r\n            co_return co_await local_maker();\r\n        }();\r\n\r\n        {\r\n            winrt::slim_lock_guard guard(m_mutex);\r\n            m_latest.swap(node);\r\n        }\r\n\r\n        node->continue_with(suspend.handle);\r\n\r\n        return task;\r\n    }\r\n\r\n    \u27e6 ... \u27e7\r\n};\r\n<\/pre>\n
We force the bottom bit of earliest<\/code> to 1 when recording the start time, so that the value is never zero. This introduces a potential error of 1 millisecond, but one millisecond error out of 1 second is not going to be noticeable in practice for this type of work.<\/p>\n
Bonus chatter<\/b>: You may have figured out that the point of this exercise, aside from actually adding a feature to the task scheduler, is just showing the process of studying the implementation of a chunk of code, getting an idea, following through the implementation, and then refining the implementation.<\/p>\n","protected":false},"excerpt":{"rendered":"
Waiting more cheaply.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-111046","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Waiting more cheaply.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111046","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=111046"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/111046\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=111046"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=111046"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=111046"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}