Compare and contrast Adaptive to PID algorithm

[jakirkham]

In various control systems, the PID controller algorithm (for those unfamiliar) is a common strategy to approach a target (a.k.a. setpoint) by adjusting a control variable to affect approach taking into account distance, history, and rate of approach. This algorithm has been successfully employed in a wide range of technologies with some common examples including cruise controller in cars, temperature regulation by thermostats, and various industrial applications.

In many ways the Adaptive scheduler seems to overlap with this use case. It would be interesting to see if there is anything the Adaptive scheduler could learn from PID (assuming it hasn't already learned everything 😄).

[mrocklin]

I'll push back on this a bit. PID controllers are particularly useful when you don't have a strong understanding of the system between the control and observable, and so might overshoot, etc.. I think that in our case we have almost perfect understanding. If we can get up to perfect understanding then a PID system may be overkill, and may introduce more parameters to tune.

Currently the uncertainty is "workers that have been launched, but not yet arrived". I think that if we can monitor these (perhaps by sending along metadata with the workers) then we should be able to take actions to optimally hit our target without relying on systems like PID.

[jakirkham]

That depends on what you think the setpoint is (and more importantly what space it lives in).

If we consider the space of number of running jobs within bounds, maybe it is not needed. Then again there has been a fair bit of time spent tinkering with timeouts and the like, which suggests a better approach is needed (though that may or may not draw influence from PID).

For me personally (and expect many others find this interesting as well), the space is how quickly we can complete a computation. Increasing jobs certainly affect rate of completion just as pumping electricity into a heating coil raises temperature. However they are somewhat removed from each other. There are points where throwing more jobs at a problem will speed it up and others where additional jobs have diminishing (if any) returns. The value of additional jobs can even change throughout the same computation. We can certainly affect that to some extent by bumping the number of workers manually (as long as Adaptive doesn't fight us on it :). Though it would be better if we didn't have to. This is where I think PID (or potentially some other algorithm) comes into play (in my mind at least).