Valgrind-Ausgabe interpretieren

[SeppJ]

Darf ich erst einmal den bescheidenen Verdacht äußern, dass die Bibliothek vielleicht nicht selber die Fehler hat, sondern diese durch falsche Benutzung zustande kommen? Falls die Bibliothek selber solche Fehler hätte, sollte man das sofort den Entwicklern melden, das sind schwere Fehler! Aber das hätte bestimmt schon jemand getan, sofern du nicht der einzige Nutzer bist. Speicherlecks mit valgrind suchen ist eine Standardphase in der Entwicklung und das wäre gewiss schon aufgefallen.

Und, nichts für ungut, ich habe jetzt schon ein paar Programme von dir gesehen. Die sind...nicht so sauber. Speicherlecks verwundern mich da gar nicht.

[Jay1980]

Naja, ich bin gewiss noch nicht gut, aber ich denke schon, dass ich stetig lerne, wenn ich hier viel poste und mir Rückmeldung hole und derweil versuche, dass mein Code besser wird. So jetzt schaue ich da mal Schritt für Schritt, was ich da bessern kann.

==9817==
==9817== FILE DESCRIPTORS: 3 open at exit.
==9817== Open file descriptor 2: /dev/pts/3
==9817== <inherited from parent>
==9817==
==9817== Open file descriptor 1: /dev/pts/3
==9817== <inherited from parent>
==9817==
==9817== Open file descriptor 0: /dev/pts/3
==9817== <inherited from parent>
==9817==
==9817==
==9817== HEAP SUMMARY:
==9817== in use at exit: 54,650 bytes in 202 blocks
==9817== total heap usage: 389,633 allocs, 389,431 frees, 10,013,298 bytes allocated
==9817==
==9817== 33 bytes in 1 blocks are definitely lost in loss record 1 of 18
==9817== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==9817== by 0x807D9FA: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (basic_allocator_interface.h:199)
==9817== by 0x8080A35: Msa::readMsaFromFile(std::string) (msa.h:417)
==9817== by 0x80735F5: main (msa.h:384)
==9817==
==9817== 80 bytes in 10 blocks are definitely lost in loss record 2 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056D70: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:688)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 100 bytes in 1 blocks are definitely lost in loss record 3 of 18
==9817== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==9817== by 0x807D9FA: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (basic_allocator_interface.h:199)
==9817== by 0x8080A12: Msa::readMsaFromFile(std::string) (msa.h:415)
==9817== by 0x80735F5: main (msa.h:384)
==9817==
==9817== 160 bytes in 10 blocks are definitely lost in loss record 4 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056CFE: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:671)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 160 bytes in 10 blocks are definitely lost in loss record 5 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056D33: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:680)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 160 bytes in 10 blocks are definitely lost in loss record 6 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056D82: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:689)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 160 bytes in 10 blocks are definitely lost in loss record 7 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056D94: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:690)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 160 bytes in 10 blocks are definitely lost in loss record 8 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056DA6: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:691)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 160 bytes in 10 blocks are definitely lost in loss record 9 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056DB8: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:692)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 800 bytes in 1 blocks are still reachable in loss record 10 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056C18: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:659)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 800 bytes in 1 blocks are still reachable in loss record 11 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056C2B: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:660)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 1,320 bytes in 40 blocks are definitely lost in loss record 12 of 18
==9817== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==9817== by 0x807D6A7: seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type seqan::_Resize_String<seqan::Tagseqan::TagGenerous_ const>::resize_<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >(seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> >&, seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type) (basic_allocator_interface.h:199)
==9817== by 0x807D98D: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (string_base.h:1705)
==9817== by 0x8080A35: Msa::readMsaFromFile(std::string) (msa.h:417)
==9817== by 0x80735F5: main (msa.h:384)
==9817==
==9817== 4,157 bytes in 40 blocks are definitely lost in loss record 13 of 18
==9817== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==9817== by 0x807D6A7: seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type seqan::_Resize_String<seqan::Tagseqan::TagGenerous_ const>::resize_<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >(seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> >&, seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type) (basic_allocator_interface.h:199)
==9817== by 0x807D98D: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (string_base.h:1705)
==9817== by 0x8080A12: Msa::readMsaFromFile(std::string) (msa.h:415)
==9817== by 0x80735F5: main (msa.h:384)
==9817==
==9817== 7,200 bytes in 9 blocks are definitely lost in loss record 14 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056C18: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:659)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 7,200 bytes in 9 blocks are definitely lost in loss record 15 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056C2B: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:660)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 8,000 bytes in 10 blocks are definitely lost in loss record 16 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056D21: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:674)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 8,000 bytes in 10 blocks are definitely lost in loss record 17 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056DCC: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:693)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== 16,000 bytes in 10 blocks are definitely lost in loss record 18 of 18
==9817== at 0x402532E: operator new[](unsigned int) (vg_replace_malloc.c:299)
==9817== by 0x8056D5E: global::computeCurveFit(global::pairDependancyItem, global::pairDependancyItem, global::Dice&, seqan::String<char, seqan::Alloc<void> >, seqan::String<char, seqan::Alloc<void> >, int, double, double, std::string, double, double, double, double, double, double) (global.h:686)
==9817== by 0x8084803: H2r::computeDependancies() (h2r.h:245)
==9817== by 0x8074BBA: main (h2r.h:115)
==9817==
==9817== LEAK SUMMARY:
==9817== definitely lost: 53,050 bytes in 200 blocks
==9817== indirectly lost: 0 bytes in 0 blocks
==9817== possibly lost: 0 bytes in 0 blocks
==9817== still reachable: 1,600 bytes in 2 blocks
==9817== suppressed: 0 bytes in 0 blocks
==9817==
==9817== For counts of detected and suppressed errors, rerun with: -v
==9817== ERROR SUMMARY: 16 errors from 16 contexts (suppressed: 22 from 7)

[Nexus]

Viel besser als Speicherlecks zu beheben ist sie gar nicht erst entstehen zu lassen. Wenn du schön RAII einsetzt und Speicherverwaltung ordentlich wegkapselst, gehören solche Probleme der Vergangenheit an...

[Jay1980]

Ich suche nun nach den einzelnen Stellen:

==9817==
==9817== FILE DESCRIPTORS: 3 open at exit.
==9817== Open file descriptor 2: /dev/pts/3
==9817== <inherited from parent>
==9817==
==9817== Open file descriptor 1: /dev/pts/3
==9817== <inherited from parent>
==9817==
==9817== Open file descriptor 0: /dev/pts/3
==9817== <inherited from parent>
==9817==

Okay, das scheint etwas mit dem Öffnen der Dateien zu tun zu haben. Bis jetzt habe ich da wenn ich eine Datei schreibe zu Beginn die C-Variante mit Handles genommen, jetzt versuche ich das mit fstreams. Ich wusste nicht, ob es besser ist, die Datei direkt wieder via meinfstream.close() zu schließen oder sich auf den Default-Destruktor zu verlassen. Ich nehme mal die C-Datei-Handles raus und verlasse mich auf den Destruktor und teste dann nochmal. Den Wikipedia-Artikel zu RAII habe ich mir angesehen, ist aber Neuland. Speichermanagement bin ich auch unerfahren, bis jetzt gabs in meiner Welt immer nen GarbageCollector. Dazu habe ich eigentlich nirgends im Code ein new() stehen und dachte, da bin ich dann auf der sicheren Seite?!

... weiter ...

[Jay1980]

==9817== 33 bytes in 1 blocks are definitely lost in loss record 1 of 18
==9817== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==9817== by 0x807D9FA: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (basic_allocator_interface.h:199)
==9817== by 0x8080A35: Msa::readMsaFromFile(std::string) (msa.h:417)
==9817== by 0x80735F5: main (msa.h:384)

Wenn ich das richtig verstehe, dann bleiben da 33 Bytes liegen, das Einleseprozedere findet aber nur einmal statt und meine Klasse ist MSA, dann geht es in die externe Bibliothek.

Hier ist mal die entsprechende Methode, bei allem mit seqan::... geht es in die externe Bibliothek:

inline void Msa::readMsaFromFile(std::string path) {

    std::fstream fstrm;
    fstrm.open(path.c_str(), ::std::ios_base::in | ::std::ios_base::binary);
    if (!fstrm) {
        std::cout << "XXX Fehler: Datei nicht gefunden!\n";
        exit(0);
    } // Datei nicht vorhanden
    seqan::String<char> fasta_tag;
    seqan::String<char> fasta_seq;

    while (!fstrm.eof()) { // siehe seqan.de, Tutorial
        seqan::readMeta(fstrm, fasta_tag, seqan::Fasta()); // Namenstag der Sequenz-aufnehmen
        seqan::appendValue(sequencesTagList, fasta_tag); // Name einhängen
        seqan::read(fstrm, fasta_seq, seqan::Fasta()); // Sequenz aufgreifen
        seqan::appendValue(sequencesList, fasta_seq); // Sequenz einhängen
    }
    fstrm.close();
    int i = seqan::length(sequencesList); // letzte Sequenz entfernen, da diese immer leer ist
    seqan::removeValueById(sequencesList, (i - 1)); // Sequenz i-1 aus dem StringSet löschen
    seqan::removeValueById(sequencesTagList, (i - 1)); // Sequenznamen aus dem StringSet löschen
}

Edit: ... da haben wir direkt so einen Fall mit dem fstream.close() - sollte ich das da nun lassen oder lieber raus nehmen?

[Nexus]

Jay1980 schrieb:

Edit: ... da haben wir direkt so einen Fall mit dem fstream.close() - sollte ich das da nun lassen oder lieber raus nehmen?

Raus nehmen, C++-Filestreams können RAII. Hast du meinen oberen Beitrag gelesen?

[Jay1980]

Ah okay, nächster Valgrind-Punkt ... da stimmt was nicht, was ich beheben kann.

// --- Levenberg-Marquardt-Fit to Gumbel-dist, see model in fcn(), cumulated relative bin heights and cumulated model
        int m = binsInteger;                            // number of observations or functions
        int n = 2;                                      // number of parameters to fit, here mue and beta
        independent_variables = new double[m];          // vector of independent variables, x-values = bin-mids
        oberved_values = new double[m];                 // vector of observed variables, y-values of observations, data to fit
        VecDoub nrRealVecCumulated( binsInteger );      // data points of experiment, cumulated
        for (int i = 0; i < m; i++) {
            // set x and y value, x = bin-mid, y = realCumBinHeight
            double curBinMid = binMidList.at(i);
            double absBinElementsCumulated = gsl_histogram_get(hcum, i);   
            nrRealVecCumulated[i] = absBinElementsCumulated;                  
            independent_variables[i] = curBinMid;
            oberved_values[i] = nrRealVecCumulated[ i ] / elementsDouble;
            //std::cout << " -> PreMinpack-Run - " << i << "; x - " << independent_variables[i] << "; y - " << oberved_values[i] << ";\n";
        }
        double* x = new double[n];      // initial estimate of parameters vector
        x[0] = 0.01;                    // mue-Guess
        x[1] = 0.005;                   // beta-Guess
        double* fvec = new double[m];   // no need to populate 
        double ftol = 1e-08;            // tolerance
        double xtol = 1e-08;            // tolerance
        double gtol = 1e-08;            // tolerance
        int maxfev = 400;               // maximum function evaluations
        double epsfcn = 1e-08;          // tolerance
        double* diag = new double[n];   // some internal thing
        int mode = 1;                   // some internal thing
        double factor = 1;              // a default recommended value
        int nprint = 0;                 // don't know what it does
        int info = 0;                   // output variable
        int nfev = 0;                   // output variable will store no. of function evals
        double* fjac = new double[m * n]; // output array of jacobian
        int ldfjac = m;                 // recommended setting
        int* ipvt = new int[n];         // for internal use
        double* qtf = new double[n];    // for internal use
        double* wa1 = new double[n];    // for internal use
        double* wa2 = new double[n];    // for internal use
        double* wa3 = new double[n];    // for internal use
        double* wa4 = new double[m];    // for internal use
        QuantLib::MINPACK::lmdif(m, n, x, fvec, ftol, xtol, gtol, maxfev, epsfcn, diag, mode, factor, nprint, &info, &nfev, fjac, ldfjac, ipvt, qtf, wa1, wa2, wa3, wa4);
        // the below is out result. compare it with the values used in fcn function
        double a = x[0];
        double b = x[1];
        double minpackGumbelMue = a;
        double minpackGumbelBeta = b;
        std::cout << "| ... ... mueMinpackFit: " << minpackGumbelMue << " betaMinpackFit: " << minpackGumbelBeta << std::endl;

das Problem, ich werde die dann einfach via delete freigeben, das war ein Snippet den ich übernommen habe ... ohne valgrind wäre mir das wohl durchgerutscht.

[SeppJ]

So allgemein: Die drei Filehandles die am Ende noch offen sind, sind stdout, stderr und stdin. Das ist normal, dass die offen bleiben. Wenn du soweit bist, dass das alles ist, dann ist alles in Butter.

das Problem, ich werde die dann einfach via delete freigeben, das war ein Snippet den ich übernommen habe ... ohne valgrind wäre mir das wohl durchgerutscht.

Hallo? Was soll so was? Liest du überhaupt, was man dir schreibt? Warum ist das kein std::vector?

[seldon]

Benutz besser gleich std::vector, dann bist du exception-sicher.

Was die Dateideskriptoren angeht, 0 ist stdin, 1 ist stdout, 2 ist stderr. /dev/pts/3 ist ein Pseudo-Terminal, in diese Fall vermutlich xterm oder so. Die dürfen am Ende ruhig offen sein.

[Jay1980]

Sodala, jetzt schaut das schon besser aus, danke euch. Klar lese ich die Sachen und mache mir darüber Gedanken, in dem Thread war es aber einige Mal so, dass die Antwort noch nicht vor meinen Augen war, weil ich den Thread offen hatte und direkt auf meinen eigenen Beitrag antwortete, ohne die Seite vorab zu aktualisieren.

==13588==
==13588== HEAP SUMMARY:
==13588== in use at exit: 5,610 bytes in 82 blocks
==13588== total heap usage: 389,628 allocs, 389,546 frees, 10,013,178 bytes allocated
==13588==
==13588== 33 bytes in 1 blocks are definitely lost in loss record 1 of 4
==13588== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==13588== by 0x807DB7A: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (basic_allocator_interface.h:199)
==13588== by 0x8080BB5: Msa::readMsaFromFile(std::string) (msa.h:417)
==13588== by 0x80733F1: main (msa.h:384)
==13588==
==13588== 100 bytes in 1 blocks are definitely lost in loss record 2 of 4
==13588== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==13588== by 0x807DB7A: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (basic_allocator_interface.h:199)
==13588== by 0x8080B92: Msa::readMsaFromFile(std::string) (msa.h:415)
==13588== by 0x80733F1: main (msa.h:384)
==13588==
==13588== 1,320 bytes in 40 blocks are definitely lost in loss record 3 of 4
==13588== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==13588== by 0x807D827: seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type seqan::_Resize_String<seqan::Tagseqan::TagGenerous_ const>::resize_<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >(seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> >&, seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type) (basic_allocator_interface.h:199)
==13588== by 0x807DB0D: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (string_base.h:1705)
==13588== by 0x8080BB5: Msa::readMsaFromFile(std::string) (msa.h:417)
==13588== by 0x80733F1: main (msa.h:384)
==13588==
==13588== 4,157 bytes in 40 blocks are definitely lost in loss record 4 of 4
==13588== at 0x402569A: operator new(unsigned int) (vg_replace_malloc.c:255)
==13588== by 0x807D827: seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type seqan::_Resize_String<seqan::Tagseqan::TagGenerous_ const>::resize_<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >(seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> >&, seqan::Size<seqan::String<seqan::String<char, seqan::Alloc<void> >, seqan::Alloc<void> > >::Type) (basic_allocator_interface.h:199)
==13588== by 0x807DB0D: void seqan::appendValue<seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >, seqan::String<char, seqan::Alloc<void> > >(seqan::StringSet<seqan::String<char, seqan::Alloc<void> >, seqan::Owner<seqan::Tagseqan::Default_ const> >&, seqan::String<char, seqan::Alloc<void> > const&) (string_base.h:1705)
==13588== by 0x8080B92: Msa::readMsaFromFile(std::string) (msa.h:415)
==13588== by 0x80733F1: main (msa.h:384)
==13588==
==13588== LEAK SUMMARY:
==13588== definitely lost: 5,610 bytes in 82 blocks
==13588== indirectly lost: 0 bytes in 0 blocks
==13588== possibly lost: 0 bytes in 0 blocks
==13588== still reachable: 0 bytes in 0 blocks
==13588== suppressed: 0 bytes in 0 blocks
==13588==
==13588== For counts of detected and suppressed errors, rerun with: -v
==13588== ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 22 from 7)