Dotaz: Čekání na volnou paměť

[Jan Zahornadsky]

Zdravím!

Řeším následující problém: z různých zdrojů přichází na jeden stroj asynchronně požadavky na jistý (paměťově náročný) výpočet, inicializovaný z bash skriptu. Chtěl bych, aby pokud je paměti dost, tak se samotný výpočet pustil přímo, jinak počkal chvíli, než se paměť uvolní.

Naivní přístup (v cyklu kontrolovat free a případně sleep) neuspěl, protože pokud přijde padesát požadavků najednou, tak se všechny vesele pustí a v polovině výpočtu jim všem dojde paměť. Proto navíc požaduji, aby paměť byla volná několik testů po sobě a taky testuji, jestli už neběží nějaké velké množství výpočtů (ony ty potvory alokují paměť až řádově během desítek vteřin, takže když vidím deset procesů a kopec volné paměti, je lepší čekat než se mezi ně pouštět).

Současný kód vypadá zhruba takto:

function get_freemem() {
    # "our" free memory = free RAM + buffers/cache - used swap
    # minus "give way" (custom list of simple command names and
    # amount of memory they might grow)
    reserve=0
    progs="`ps -eo comm | tail -n +2`"
    for i in $@; do
        cmd="`sed 's/=.*$//' <<< "$i"`"
        res="`sed 's/^.*=//; s/[^0-9]//g' <<< "$i"`"
        [ -z "$res" ] && continue

        reserve=$(( $reserve + `grep "$cmd" <<< "$progs" | wc -l` * $res ))
    done

    f="`free`"
    mem="`tail -n 2 <<< "$f" | head -n 1 | sed 's/^.* //'`"
    swap="`tail -n 1 <<< "$f" | sed 's/ \+/ /g' | cut -d ' ' -f 3`"

    echo $mem - $swap - $reserve | bc
}

function wait_freemem() {
    counter=0
    max_timeout=36000

    timein_counter=0
    timein_required=5

    mem_needed=1048576

    # we reserve additional 512M for each "java" we find in ps
    reserves="java=524288"

    while [ $counter -lt $max_timeout ]; do
        mem="`get_freemem $reserves`"
        [ $mem -gt $mem_needed ] && timein_counter=$(( $timein_counter + 1 )) || timein_counter=0
        [ $timein_counter -ge $timein_required -a $(( $counter % $timein_required )) == 0  ] && return 0

        sleep 1
        timeout_counter=$(( $timeout_counter + 1 ))
    done

    return 1
}

Každopádně i přes tyto opatření pokud přijde hodně dotazů, je schopno se jich kvůli race condition dost pustit najednou (ono asi bych mohl zvednout timein_required na nějakou velkou hodnotu a pak prostě doufat, že to bude stačit, ale to taky prodlouží čekání jediného procesu pokud je stroj nečinný).

Tak bych se rád zeptal, jestli někdo neví o spolehlivé metodě, jak potenciálně velké množství procesů zesynchronizovat tak, aby se v případě dostatku paměti pustily paralelně, ale pokud je paměti míň, tak se většina z nich zablokovala a pouštěli se po jednom (dvou, třech, atd., podle volné paměti)? Ideálně v bashi, ale nebráním se jiným metodám.

Díky!

Odpovědi

[Jan Zahornadsky]

V tom kódu je timeout_counter a counter jedna a ta samá proměnná, jde o mou nepozornost při úpravě

[CandySan]

Zkus si vytvorit frontu. Jednotlive pozadavky stosuj do fronty tak, ze kazdy prichozi se tam rovnou zaradi a zustava v ni viset dokud neni obslouzen. Bud napevno urcis pocet paralelnich vypoctu a jen tolik jich dovolis, nebo tomu jeste predradis nejakou logiku tesne pred obslouzeni dalsiho pozadavku.

Obsluha fronty bude muset mit prehled o poctu bezicich procesu a vzdy kdyz jeden skonci, tak spusti dalsi, pokud stale bude platit, ze je povoleny takovy pocet vypoctu (tedy zde se muze zase porovnat stav pameti, ale popisujes to jako tezko predvidatelne, takze bych se spis uchylil k pevnemu poctu).

Chce to samozrejme doladit. Ja to strelil jen od boku jako smer, kterym bych se nejspis vydal ja.

[Jan Zahornadsky]

Fronta jako taková není špatný nápad, dokonce by stálo za úvahu nechat běžět nějakého "workera" na té mašině, který třeba na nějakém portu poslouchá požadavky a vykonává je v rozumném kompromisu na počet současně běžících úloh a jejich paměťovou náročnost.

Ale to bych asi musel dost přepsat současný stav věcí, kde vstupním bodem výpočtu je bash skript, který může pustit kdekdo, ať už z terminálu, nebo zprostředkovaně přes apache...

Pokud bych nehleděl na paměť, ale jenom chtěl zajistit, že jich nepoběží víc než X najednou, tak můžu vytvářet zámky někde v tmp typu /tmp/muj_program_lock_0 až /tmp/muj_program_lock_X...

[Michal Kubeček]

Možná by bylo jednodušší udělat to tak, že program si potřebnou paměť zkusí naalokovat hned na začátku (pokud ví, kolik bude potřebovat) a pokud to selže, tak se prostě vrátí do fronty.

[Jan Zahornadsky]

Právě že ono to selhat nemusí. Jaderný OOM killer se může rozhodnout zabít jiný program a ten nově spuštěný nechat běžet (co může způsobit kdejaké problémy), většinou ale paměť dostane a bude se velmi aktivně swapovat, co zpomalí všechno, a tak by mnohem rychlejší bylo je pouštět po jednom.

[Sten]

Tak vypněte overcommit

[rADOn]

Jestli se vejde do swapu, tak by se fronta dala zrealizovat jednoduse tak ze nejakej hlidaci proces bude rozesilat SIGSTOP pak to zase ozivovat az napeti klesne. Sice se ti to odswapuje, ale stopnutej proces je v bloku a nebude se snazit z toho swapu zase proboxovat ven nerkuli pretahovat o posledni kousek fyzicky pameti.

[v]

Nebylo by nejjednodušší použít pojmenované roury? Vytvořit si další skript, který by se spustil jako daemon a pravidelně nějakou frekvecí zapisoval do nějaké pojmenované roury např. "1" nebo "0" podle dostupné paměti. V tom inicializačním skriptu pravidelně (v cyklu) přečítat rouru dokud nedostanu 1, pak skript poběží dál. V podstatě se pak dostane 1, 0 nebo nic podle toho, kolik skriptů najednou se snaží rouru přečíst - vždy se dostane na jednoho a ten má pak nárok, pokud dostane 1 běžet dál.

[Jan Zahornadsky]

Toto zní hodně zajímavě, jak bych mohl nějak zařídit spuštění takového démona? Na tom stroji to všechno běží pod obyčejným uživatelem a tak bych se rád vyhnul požadování nějakých vlastních initskriptů při startu...

[rADOn]

Na to ani nepotrebujes psat do ty roury nuly - staci nezapsat nic a vsichni citatele zustanou viset v bloku.

[Josef Kufner]

Na to není potřeba roura. Stačí posílat SIGSTOP a SIGCONT. A ani nejspíš nebude nutné jakkoliv upravovat aplikace (výchozí obsluha těchto signálů je jak název napovídá).