lkml.org 
[lkml]   [2022]   [May]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH 3/4] selftests: memcg: Adjust expected reclaim values of protected cgroups
    On Fri, May 13, 2022 at 07:18:10PM +0200, Michal Koutny wrote:
    > The numbers are not easy to derive in a closed form (certainly mere
    > protections ratios do not apply), therefore use a simulation to obtain
    > expected numbers.
    >
    > The new values make the protection tests succeed more precisely.
    >
    > % run as: octave-cli script
    > %
    > % Input configurations
    > % -------------------
    > % E parent effective protection
    > % n nominal protection of siblings set at the givel level
    > % c current consumption -,,-
    >
    > % 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
    > % ---------------------
    > % 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.
    >
    > 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
    > 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

    This is a cool stuff!

    How about to place it into a separate file and add a comment into the code
    with a reference?

    Thanks!

    \
     
     \ /
      Last update: 2022-05-13 20:54    [W:3.345 / U:0.144 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site