From 54f238c510b5b704c826afc80f043f96a38fce2c Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Fri, 5 Jan 2024 22:31:42 +0100 Subject: [PATCH] Scheduler-test: further configuration options for flexible testing The next goal is to determine basic performance characteristics of the Scheduler implementation written thus far; to help with these investigations some added flexibility seems expedient - the ability to define a per-job base expense - added flexibility regarding the scheduling of dependencies This changeset introduces configuration options --- tests/vault/gear/test-chain-load.hpp | 57 +++++++++++--- wiki/thinkPad.ichthyo.mm | 112 +++++++++++++++++++++++++++ 2 files changed, 157 insertions(+), 12 deletions(-) diff --git a/tests/vault/gear/test-chain-load.hpp b/tests/vault/gear/test-chain-load.hpp index 6ab7715e0..9ee2616b0 100644 --- a/tests/vault/gear/test-chain-load.hpp +++ b/tests/vault/gear/test-chain-load.hpp @@ -191,7 +191,10 @@ namespace test { const microseconds LOAD_DEFAULT_TIME = 100us; ///< default time delay produced by ComputationalLoad at `Node.weight==1` const size_t LOAD_DEFAULT_MEM_SIZE = 1000; ///< default allocation base size used if ComputationalLoad.useAllocation const Duration SCHEDULE_LEVEL_STEP{_uTicks(1ms)}; ///< time budget to plan for the calculation of each »time level« of jobs + const Duration SCHEDULE_NODE_STEP{Duration::NIL}; ///< additional time step to include in the plan for each job (node). const Duration SCHEDULE_PLAN_STEP{_uTicks(100us)}; ///< time budget to reserve for each node to be planned and scheduled + const bool SCHEDULE_DEPENDENCY = false; ///< explicitly schedule a dependent job (or rely on NOTIFY) + const bool SCHEDULE_NOTIFY = true; ///< explicitly set notify dispatch time to the dependencie's start time. inline uint defaultConcurr() @@ -1666,7 +1669,10 @@ namespace test { lib::UninitialisedDynBlock schedule_; FrameRate levelSpeed_{1, SCHEDULE_LEVEL_STEP}; + FrameRate nodeSpeed_{1, SCHEDULE_NODE_STEP}; FrameRate planSpeed_{1, SCHEDULE_PLAN_STEP}; + double schedNotify_{SCHEDULE_NOTIFY? 1.0:0.0}; + bool schedDepends_{SCHEDULE_DEPENDENCY}; uint blockLoadFactor_{2}; size_t chunkSize_{DEFAULT_CHUNKSIZE}; TimeVar startTime_{Time::ANYTIME}; @@ -1793,13 +1799,6 @@ namespace test { /* ===== Setter / builders for custom configuration ===== */ - ScheduleCtx&& - withLevelDuration (microseconds plannedTime_per_level) - { - levelSpeed_ = FrameRate{1, Duration{_uTicks(plannedTime_per_level)}}; - return move(*this); - } - ScheduleCtx&& withPlanningStep (microseconds planningTime_per_node) { @@ -1824,9 +1823,44 @@ namespace test { } ScheduleCtx&& - withJobDeadline (microseconds deadline_after_start) + withUpfrontPlanning() + { + withChunkSize (chainLoad_.size()); + preRoll_ *= UPFRONT_PLANNING_BOOST; + return move(*this); + } + + ScheduleCtx&& + withLevelDuration (microseconds fixedTime_per_level) + { + levelSpeed_ = FrameRate{1, Duration{_uTicks(fixedTime_per_level)}}; + return move(*this); + } + + ScheduleCtx&& + withBaseExpense (microseconds fixedTime_per_node) + { + nodeSpeed_ = FrameRate{1, Duration{_uTicks(fixedTime_per_node)}}; + return move(*this); + } + + ScheduleCtx&& + withScheduleDependency (bool explicitly) + { + schedDepends_ = explicitly; + return move(*this); + } + + ScheduleCtx&& + withScheduleNotify (double degree) + { + schedNotify_ = degree; + return move(*this); + } + + ScheduleCtx&& + withBaseExpense () { - deadline_ = deadline_after_start; return move(*this); } @@ -1842,10 +1876,9 @@ namespace test { } ScheduleCtx&& - withUpfrontPlanning() + withJobDeadline (microseconds deadline_after_start) { - withChunkSize (chainLoad_.size()); - preRoll_ *= UPFRONT_PLANNING_BOOST; + deadline_ = deadline_after_start; return move(*this); } diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index 6a71e352f..ff842b43d 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -107889,6 +107889,118 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
+ + + + + + + + + + + + + + + + + + + +

+ eigentlich wäre das eine Ja/Nein-Entscheidung, aber da sie über einen Zeit-Parameter gesteuert wird, kann man hier alles zwischen Time::ANYTIME und dem nominellen Zeitpunkt des Folge-Jobs explizit setzen; dieser Parameter hat sich akzidentell aus der Implementierung  ergeben und wird im NOTIFY-Verb gespeichert; das vorliegen dieses Parameters ist es auch, wodurch der eigentliche explizite Trigger für den Folge-Job wegfallen kann. Setzt man hier die nominelle Zeit ein, so wird das NOTIFY tatsächlich erst zu dieser Zeit zugestellt, und das bedeutet, daß auch Dependency-Ketten nach dem nominellen Schedule „getaktet“ sind. Im anderen Extremfall gibt es keine Limitierung und das NOTIFY wird vom Scheduler zur nächstmöglichen Gelegenheit zugestellt. Sofern allerdings die Berechnung ohnehin im Verzug ist, spielt diese Unterscheidung keine Rolle mehr (dann wird nämlich immer sofort getriggert); es könnte aber für zusätzlichen Flexibilitäts-Puffer sorgen, wenn ein Schedule zeitweilig zu dünn besetzt ist, denn erst dadurch könnte der Scheduler sogar vorzeitig fertig werden. +

+ + + + + + + + + + + +

+ deshalb habe ich gezögert, diese Möglichkeit gleich vorzusehen; letztlich aber wiegt das »Ausleuchten« von Verhaltensmustern im Test mehr (und ich erwarte keinen westentlichen Einfluß auf die Performance) +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ Das war anfangs ein erhebliches Problem, bis ich mich dazu durchgerungen hatte, den unmittelbaren Dispatch aufzugeben. Seither kann ein Job auch verspätet abgesetzt werden, und wandert dann sofort an die Spitze der Queue. Und da wir das komplette Array mit den Activity-Termen Aufrufu-übergreifend erhalten, können dann eben Jobs auch »schleppend« abgesetzt werden. Genau das nutzen wir hier aus +

+ + + + + + + + + + + + + + + + + +

+ bisher mußte er explizit per post() erzeugt werden — nun meint post() wirklich die Übergabe an den Scheduler, und der Term wird hier nur noch erzeugt, wenn er nicht schon besteht. Dies rechtfertigt dann auch das optional<ActitityTerm> und wirkt so viel natürlicher +

+ + + + + + + + + + + + + + + + + + + + + + +