90 lines
2.4 KiB
Mathematica
90 lines
2.4 KiB
Mathematica
|
% SPDX-License-Identifier: GPL-2.0
|
||
|
|
%
|
||
|
|
% run as: octave-cli memcg_protection.m
|
||
|
|
%
|
||
|
|
% This script simulates reclaim protection behavior on a single level of memcg
|
||
|
|
% hierarchy to illustrate how overcommitted protection spreads among siblings
|
||
|
|
% (as it depends also on their current consumption).
|
||
|
|
%
|
||
|
|
% Simulation assumes siblings consumed the initial amount of memory (w/out
|
||
|
|
% reclaim) and then the reclaim starts, all memory is reclaimable, i.e. treated
|
||
|
|
% same. It simulates only non-low reclaim and assumes all memory.min = 0.
|
||
|
|
%
|
||
|
|
% Input configurations
|
||
|
|
% --------------------
|
||
|
|
% E number parent effective protection
|
||
|
|
% n vector nominal protection of siblings set at the given level (memory.low)
|
||
|
|
% c vector current consumption -,,- (memory.current)
|
||
|
|
|
||
|
|
% example from testcase (values in GB)
|
||
|
|
E = 50 / 1024;
|
||
|
|
n = [75 25 0 500 ] / 1024;
|
||
|
|
c = [50 50 50 0] / 1024;
|
||
|
|
|
||
|
|
% Reclaim parameters
|
||
|
|
% ------------------
|
||
|
|
|
||
|
|
% Minimal reclaim amount (GB)
|
||
|
|
cluster = 32*4 / 2**20;
|
||
|
|
|
||
|
|
% Reclaim coefficient (think as 0.5^sc->priority)
|
||
|
|
alpha = .1
|
||
|
|
|
||
|
|
% Simulation parameters
|
||
|
|
% ---------------------
|
||
|
|
epsilon = 1e-7;
|
||
|
|
timeout = 1000;
|
||
|
|
|
||
|
|
% Simulation loop
|
||
|
|
% ---------------
|
||
|
|
|
||
|
|
ch = [];
|
||
|
|
eh = [];
|
||
|
|
rh = [];
|
||
|
|
|
||
|
|
for t = 1:timeout
|
||
|
|
% low_usage
|
||
|
|
u = min(c, n);
|
||
|
|
siblings = sum(u);
|
||
|
|
|
||
|
|
% effective_protection()
|
||
|
|
protected = min(n, c); % start with nominal
|
||
|
|
e = protected * min(1, E / siblings); % normalize overcommit
|
||
|
|
|
||
|
|
% recursive protection
|
||
|
|
unclaimed = max(0, E - siblings);
|
||
|
|
parent_overuse = sum(c) - siblings;
|
||
|
|
if (unclaimed > 0 && parent_overuse > 0)
|
||
|
|
overuse = max(0, c - protected);
|
||
|
|
e += unclaimed * (overuse / parent_overuse);
|
||
|
|
endif
|
||
|
|
|
||
|
|
% get_scan_count()
|
||
|
|
r = alpha * c; % assume all memory is in a single LRU list
|
||
|
|
|
||
|
|
% commit 1bc63fb1272b ("mm, memcg: make scan aggression always exclude protection")
|
||
|
|
sz = max(e, c);
|
||
|
|
r .*= (1 - (e+epsilon) ./ (sz+epsilon));
|
||
|
|
|
||
|
|
% uncomment to debug prints
|
||
|
|
% e, c, r
|
||
|
|
|
||
|
|
% nothing to reclaim, reached equilibrium
|
||
|
|
if max(r) < epsilon
|
||
|
|
break;
|
||
|
|
endif
|
||
|
|
|
||
|
|
% SWAP_CLUSTER_MAX roundup
|
||
|
|
r = max(r, (r > epsilon) .* cluster);
|
||
|
|
% XXX here I do parallel reclaim of all siblings
|
||
|
|
% in reality reclaim is serialized and each sibling recalculates own residual
|
||
|
|
c = max(c - r, 0);
|
||
|
|
|
||
|
|
ch = [ch ; c];
|
||
|
|
eh = [eh ; e];
|
||
|
|
rh = [rh ; r];
|
||
|
|
endfor
|
||
|
|
|
||
|
|
t
|
||
|
|
c, e
|