Administrace komentářů

Myslím, že tu nie je žiaden memory leak. Ešte pred tým než sa pustím do mojej použitej metódy detekcie leakov by som chcel napísať pár všeobecných tvrdení o leakoch.

Memory leak je situácia kedy pamäť ostáva alokovaná, ale už nie je prístupná programátorovi (stratil na ňu referenciu). Detekcia memory leakov v nízkoúrovňových jazykoch je veľmi náročná pretože musí byť prekontrolované, či sú dostupné všetky alokované bloky (teda existuje pointer na začiatok alokovaného bloku pamäte). Problém je, že pointer nemusí vždy smerovať na začiatok a môže byť pre leak detektor akože stratený aj keď v skutočnosti je to nejaký posuvný pointer, ktorý pozná svoju pozíciu. To je jeden z dôvodov prečo môže vyhadzovať false positive. Taktiež bude vyhadzovať false positive ak pri ukončení aplikácie zostanú alokované napr. singletony, cache, ktoré by pri dalokácii zbytočne zdržovali ukončenie aplikácie.

Memory leak nebýva jediným dôvodom prečo môže rásť množstvo alokovanej pamäte. Môže to byť aj v dôsledku iných vecí napr. cache, kotrá sa nikdy neuvoľňuje a pravidelne sa plní novými údajmi (pred týmto typom chyby neochráni ani jazyk s GC). Preto často namiesto použitia špecializovaných nástrojov ako valgrind radšej nechám svoju aplikáciu v slučke vykonávať nejakú akciu a sledujem, či mi nerastie množstvo alokovanej pamäte. Takto dokážem odhaliť akékoľvek úniky pamäte, aj tie, pred ktorými by ma nechránil GC.

Teraz k tomu Qt príkladu. Najskôr som si vytvoril kostru, ktorá vykoná určitý počet iterácií určitej akcie. Je to škaredý kód (napr. lambda je tam zbytočne), ale umožňuje nastaviť napríklad čakanie aby aplikácia mala čas na zobrazenie okna, prípadne aj s animáciou. Kostra vyzerá takto:

#include <QtWidgets/QApplication>
#include <QtCore/QEventLoop>
#include <QtCore/QTimer>


int counter = 0;
const int cycle_count = 1;
const int cycle_duration = 1;


void show_charts()
{
    // Kód

    QEventLoop loop;
    QTimer::singleShot(cycle_duration, &loop, SLOT(quit()));
    loop.exec();

    counter++;
    if (counter >= cycle_count) {
        qApp->quit();
    }
}


int main(int argc, char *argv[]) {
    QApplication a(argc, argv);
    a.setQuitOnLastWindowClosed(false);
    QTimer timer;
    timer.setInterval(cycle_duration);
    timer.start();
    QObject::connect(&timer, &QTimer::timeout, []() { show_charts(); });
    return a.exec();
}

Na začiatok som skúsil 1 iteráciu zobrazenia okna [a.cpp]. Aplikáciu som spustil cez nástroj memusage:

memusage --png=a_1.png ./binarka

Vo výslednom grafe [a_1.png] je alokácia pamäte pre jedno okno.

Druhý pokus som urobil s 1 000 oknami. V grafe [a_2.png] je krásne vidieť, že maximálna alokovaná pamäť pri každej iterácii je konštantná.

To isté som zopakoval s kódom [b.cpp] (tento kód s grafmi) a pamäť opäť zostala konštantná [b.png].

Z nameraných údajov preto odhadujem, že hlásené straty pamäte súvisia len so singletonmi, cache a podobnými jednorázovými alokáciami, ktoré neboli uvoľnené pri ukončení.

Viem, že je to lamerský spôsob, ale všetky ostatné nástroje sa mi zdali skôr kontraproduktívne.