You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
316 lines
13 KiB
316 lines
13 KiB
/**
|
|
*
|
|
* Simple CPU throttling implementation.
|
|
*
|
|
* For this setup, a sandbox attempting to use 100% of cpu over an
|
|
* extended period will end up throttled, in the steady-state, to
|
|
* 10% of cpu.
|
|
*
|
|
* Very simple mechanism to begin with. "ctime" is measured for the
|
|
* sandbox, being the cumulative time charged to the user (directly or
|
|
* indirectly) by the OS for that process. If the average increase in
|
|
* ctime over a time period is over 10% (targetRate) of that time period,
|
|
* throttling kicks in, and the process will be paused/unpaused via
|
|
* signals on a duty cycle.
|
|
*
|
|
* Left for future work: more careful shaping of CPU throttling, and
|
|
* factoring in a team-site level credit system or similar.
|
|
*
|
|
*/
|
|
|
|
import pidusage from '@gristlabs/pidusage';
|
|
import log from 'app/server/lib/log';
|
|
|
|
/**
|
|
* Parameters related to throttling.
|
|
*/
|
|
export interface ThrottleTiming {
|
|
dutyCyclePositiveMs: number; // when throttling, how much uninterrupted time to give
|
|
// the process before pausing it. The length of the
|
|
// non-positive cycle is chosen to achieve the desired
|
|
// cpu usage.
|
|
samplePeriodMs: number; // how often to sample cpu usage and update throttling
|
|
targetAveragingPeriodMs: number; // (rough) time span to average cpu usage over.
|
|
minimumAveragingPeriodMs: number; // minimum time span before throttling is considered.
|
|
// No throttling will occur before a process has run
|
|
// for at least this length of time.
|
|
minimumLogPeriodMs: number; // minimum time between log messages about throttling.
|
|
targetRate: number; // when throttling, aim for this fraction of cpu usage
|
|
// per unit time.
|
|
maxThrottle: number; // maximum ratio of negative duty cycle phases to
|
|
// positive.
|
|
traceNudgeOffset: number; // milliseconds to wait before sending a second signal
|
|
// to a traced process.
|
|
}
|
|
|
|
/**
|
|
* Some parameters that seem reasonable defaults.
|
|
*/
|
|
const defaultThrottleTiming: ThrottleTiming = {
|
|
dutyCyclePositiveMs: 50,
|
|
samplePeriodMs: 1000,
|
|
targetAveragingPeriodMs: 20000,
|
|
minimumAveragingPeriodMs: 6000,
|
|
minimumLogPeriodMs: 10000,
|
|
targetRate: 0.25,
|
|
maxThrottle: 10,
|
|
traceNudgeOffset: 5, // unlikely to be honored very precisely, but doesn't need to be.
|
|
};
|
|
|
|
/**
|
|
* A sample of cpu usage.
|
|
*/
|
|
interface MeterSample {
|
|
time: number; // time at which sample was made (as reported by Date.now())
|
|
cpuDuration: number; // accumulated "ctime" measured by pidusage
|
|
offDuration: number; // accumulated clock time for which process was paused (approximately)
|
|
}
|
|
|
|
/**
|
|
* A throttling implementation for a process. Supply a pid, and it will try to keep that
|
|
* process from consuming too much cpu until stop() is called.
|
|
*/
|
|
export class Throttle {
|
|
private _timing: ThrottleTiming; // overall timing parameters
|
|
private _meteringInterval: NodeJS.Timeout | undefined; // timer for cpu measurements
|
|
private _dutyCycleTimeout: NodeJS.Timeout | undefined; // driver for throttle duty cycle
|
|
private _traceNudgeTimeout: NodeJS.Timeout | undefined; // schedule a nudge to a traced process
|
|
private _throttleFactor: number = 0; // relative length of paused phase
|
|
private _sample: MeterSample | undefined; // latest measurement.
|
|
private _anchor: MeterSample | undefined; // sample from past for averaging
|
|
private _nextAnchor: MeterSample | undefined; // upcoming replacement for _anchor
|
|
private _lastLogTime: number | undefined; // time of last throttle log message
|
|
private _offDuration: number = 0; // cumulative time spent paused
|
|
private _stopped: boolean = false; // set when stop has been called
|
|
private _active: boolean = true; // set when we are not trying to pause process
|
|
|
|
/**
|
|
* Start monitoring the given process and throttle as needed.
|
|
* If readPid is set, CPU usage will be read for that process.
|
|
* If tracedPid is set, then that process will be sent a STOP signal
|
|
* whenever the main process is sent a STOP, and then another STOP
|
|
* signal will be sent again shortly after.
|
|
*
|
|
* The tracedPid wrinkle is to deal with gvisor on a ptrace platform.
|
|
* From `man ptrace`:
|
|
*
|
|
* "While being traced, the tracee will stop each time a signal is
|
|
* delivered, even if the signal is being ignored. (An exception is
|
|
* SIGKILL, which has its usual effect.) The tracer will be
|
|
* notified at its next call to waitpid(2) (or one of the related
|
|
* "wait" system calls); that call will return a status value
|
|
* containing information that indicates the cause of the stop in
|
|
* the tracee. While the tracee is stopped, the tracer can use
|
|
* various ptrace requests to inspect and modify the tracee. The
|
|
* tracer then causes the tracee to continue, optionally ignoring
|
|
* the delivered signal (or even delivering a different signal
|
|
* instead)."
|
|
*
|
|
* So what sending a STOP to a process being traced by gvisor will
|
|
* do is not obvious. In practice it appears to have no effect
|
|
* (other than presumably giving gvisor a change to examine it).
|
|
* So for gvisor, we send a STOP to the tracing process, and a STOP
|
|
* to the tracee, and then a little later a STOP to the tracee again
|
|
* (since there's no particular guarantee about order of signal
|
|
* delivery). This isn't particularly elegant, but in tests, this
|
|
* seems to do the job, while sending STOP to any one process does
|
|
* not.
|
|
*
|
|
* Alternatively, gvisor runsc does have "pause" and "resume"
|
|
* commands that could be looked into more.
|
|
*
|
|
*/
|
|
constructor(private readonly _options: {
|
|
pid: number, // main pid to stop/continue
|
|
readPid?: number, // pid to read cpu usage of, if different to main
|
|
tracedPid?: number, // pid of a traced process to signal
|
|
logMeta: log.ILogMeta,
|
|
timing?: ThrottleTiming
|
|
}) {
|
|
this._timing = this._options.timing || defaultThrottleTiming;
|
|
this._meteringInterval = setInterval(() => this._update(), this._timing.samplePeriodMs);
|
|
}
|
|
|
|
/**
|
|
* Stop all activity.
|
|
*/
|
|
public stop() {
|
|
this._stopped = true;
|
|
this._stopMetering();
|
|
this._stopTraceNudge();
|
|
this._stopThrottling();
|
|
}
|
|
|
|
/**
|
|
* Read the last cpu usage sample made, for test purposes.
|
|
*/
|
|
public get testStats(): MeterSample|undefined {
|
|
return this._sample;
|
|
}
|
|
|
|
/**
|
|
* Measure cpu usage and update whether and how much we are throttling the process.
|
|
*/
|
|
private async _update() {
|
|
// Measure cpu usage to date.
|
|
let cpuDuration: number;
|
|
try {
|
|
cpuDuration = (await pidusage(this._options.readPid || this._options.pid)).ctime;
|
|
} catch (e) {
|
|
// process may have disappeared.
|
|
this._log(`Throttle measurement error: ${e}`, this._options.logMeta);
|
|
return;
|
|
}
|
|
const now = Date.now();
|
|
const current: MeterSample = { time: now, cpuDuration, offDuration: this._offDuration };
|
|
this._sample = current;
|
|
|
|
// Measuring cpu usage was an async operation, so check that we haven't been stopped
|
|
// in the meantime. Otherwise we could sneak in and restart a throttle duty cycle.
|
|
if (this._stopped) { return; }
|
|
|
|
// We keep a reference point in the past called the "anchor". Whenever the anchor
|
|
// becomes sufficiently old, we replace it with something newer.
|
|
if (!this._anchor) { this._anchor = current; }
|
|
if (this._nextAnchor && now - this._anchor.time > this._timing.targetAveragingPeriodMs * 2) {
|
|
this._anchor = this._nextAnchor;
|
|
this._nextAnchor = undefined;
|
|
}
|
|
// Keep a replacement for the current anchor in mind.
|
|
if (!this._nextAnchor && now - this._anchor.time > this._timing.targetAveragingPeriodMs) {
|
|
this._nextAnchor = current;
|
|
}
|
|
// Check if the anchor is sufficiently old for averages to be meaningful enough
|
|
// to support throttling.
|
|
const dt = current.time - this._anchor.time;
|
|
if (dt < this._timing.minimumAveragingPeriodMs) { return; }
|
|
|
|
// Calculate the average cpu use per second since the anchor.
|
|
const rate = (current.cpuDuration - this._anchor.cpuDuration) / dt;
|
|
|
|
// If that rate is less than our target rate, don't bother throttling.
|
|
const targetRate = this._timing.targetRate;
|
|
if (rate <= targetRate) {
|
|
this._updateThrottle(0);
|
|
return;
|
|
}
|
|
|
|
// Calculate how much time the sandbox was paused since the anchor. This is
|
|
// approximate, since we don't line up duty cycles with this update function,
|
|
// but it should be good enough for throttling purposes.
|
|
const off = current.offDuration - this._anchor.offDuration;
|
|
// If the sandbox was never allowed to run, wait a bit longer for a duty cycle to complete.
|
|
// This should never happen unless time constants are set too tight relative to the
|
|
// maximum length of duty cycle.
|
|
const on = dt - off;
|
|
if (on <= 0) { return; }
|
|
|
|
// Calculate the average cpu use per second while the sandbox is unpaused.
|
|
const rateWithoutThrottling = (current.cpuDuration - this._anchor.cpuDuration) / on;
|
|
|
|
// Now pick a throttle level such that, if the sandbox continues using cpu
|
|
// at rateWithoutThrottling when it is unpaused, the overall rate matches
|
|
// the targetRate.
|
|
// one duty cycle lasts: quantum * (1 + throttleFactor)
|
|
// (positive cycle lasts 1 quantum; non-positive cycle duration is that of
|
|
// positive cycle scaled by throttleFactor)
|
|
// cpu use for this cycle is: quantum * rateWithoutThrottling
|
|
// cpu use per second is therefore: rateWithoutThrottling / (1 + throttleFactor)
|
|
// so: throttleFactor = (rateWithoutThrottling / targetRate) - 1
|
|
const throttleFactor = rateWithoutThrottling / targetRate - 1;
|
|
|
|
// Apply the throttle. Place a cap on it so the duty cycle does not get too long.
|
|
// This cap means that low targetRates could be unobtainable.
|
|
this._updateThrottle(Math.min(throttleFactor, this._timing.maxThrottle));
|
|
|
|
if (!this._lastLogTime || now - this._lastLogTime > this._timing.minimumLogPeriodMs) {
|
|
this._lastLogTime = now;
|
|
this._log('throttle', {...this._options.logMeta,
|
|
throttle: Math.round(this._throttleFactor),
|
|
throttledRate: Math.round(rate * 100),
|
|
rate: Math.round(rateWithoutThrottling * 100)});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start/stop the throttling duty cycle as necessary.
|
|
*/
|
|
private _updateThrottle(factor: number) {
|
|
// For small factors, let the process run continuously.
|
|
if (factor < 0.001) {
|
|
if (this._dutyCycleTimeout) { this._stopThrottling(); }
|
|
this._throttleFactor = 0;
|
|
return;
|
|
}
|
|
// Set the throttle factor to apply and make sure the duty cycle is running.
|
|
this._throttleFactor = factor;
|
|
if (!this._dutyCycleTimeout) { this._throttle(true); }
|
|
}
|
|
|
|
/**
|
|
* Send CONTinue or STOP signal to process.
|
|
*/
|
|
private _letProcessRun(on: boolean) {
|
|
this._active = on;
|
|
try {
|
|
process.kill(this._options.pid, on ? 'SIGCONT' : 'SIGSTOP');
|
|
const tracedPid = this._options.tracedPid;
|
|
if (tracedPid && !on) {
|
|
process.kill(tracedPid, 'SIGSTOP');
|
|
if (this._timing.traceNudgeOffset > 0) {
|
|
this._stopTraceNudge();
|
|
this._traceNudgeTimeout = setTimeout(() => {
|
|
if (!this._active) { process.kill(tracedPid, 'SIGSTOP'); }
|
|
}, this._timing.traceNudgeOffset);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// process may have disappeared
|
|
this._log(`Throttle error: ${e}`, this._options.logMeta);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send CONTinue or STOP signal to process, and schedule next step
|
|
* in duty cycle.
|
|
*/
|
|
private _throttle(on: boolean) {
|
|
this._letProcessRun(on);
|
|
const dt = this._timing.dutyCyclePositiveMs * (on ? 1.0 : this._throttleFactor);
|
|
if (!on) { this._offDuration += dt; }
|
|
this._dutyCycleTimeout = setTimeout(() => this._throttle(!on), dt);
|
|
}
|
|
|
|
/**
|
|
* Make sure measurement of cpu is stopped.
|
|
*/
|
|
private _stopMetering() {
|
|
if (this._meteringInterval) {
|
|
clearInterval(this._meteringInterval);
|
|
this._meteringInterval = undefined;
|
|
}
|
|
}
|
|
|
|
private _stopTraceNudge() {
|
|
if (this._traceNudgeTimeout) {
|
|
clearTimeout(this._traceNudgeTimeout);
|
|
this._traceNudgeTimeout = undefined;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Make sure duty cycle is stopped and process is left in running state.
|
|
*/
|
|
private _stopThrottling() {
|
|
if (this._dutyCycleTimeout) {
|
|
clearTimeout(this._dutyCycleTimeout);
|
|
this._dutyCycleTimeout = undefined;
|
|
this._letProcessRun(true);
|
|
}
|
|
}
|
|
|
|
private _log(msg: string, meta: log.ILogMeta) {
|
|
log.rawDebug(msg, meta);
|
|
}
|
|
}
|