[Insight-developers] how to attack memory leaks

[Kent Williams]

We use valgrind, which is Linux- and Intel- specific.  It doesn't 
require anything specific of the compiled program, except that it be 
compiled and linked with debugging on. It's free software and can be 
obtained at  http://valgrind.org/

I recently used valgrind to find a similar problem, and can offer this 
advice if you try it:

1. Execution time can be ten times normal execution since valgrind does 
a instruction-by-instruction intepretation.  If there's any way to cut 
down the size of your problem, you should do so.

2. valgrind keeps exhaustive information about memory leaks/errors, so 
it consumes memory greedily. If your program currently runs until it 
uses up available memory and then dies, valgrind will run out of memory 
as well, and quit without generating a report.  Consequently, you will 
have to modify your program to exit after some memory has been leaked, 
but before all memory is exhausted.

3. Valgrind often reports the same execution error or memory leak many, 
many times, depending on the execution path of your program. I wrote a 
quick-and-dirty program (attached) that cleans up the valgrind output 
and removes most duplicate reports.  Valgrind also has ways to suppress 
error messages for files/libraries you don't care to debug, but building 
a good exclusion file is pretty tedious, since you have to run your 
program under valgrind with a special flag to generate the exclusion 
clauses.

4. As good as valgrind is, it can be fooled, and regularly reports leaks 
where I suspect none is occuring. Something as basic as an assignement 
to a std::string can generate a leak report.

All that being said, valgrind takes a lot of the sweat out of debugging 
memory problems, and can be a tremendous time saver. You might need to 
run it overnight to get useful results, but it's free software, and gets 
good results.

Leila baghdadi wrote:

>hi everyone,
>
>I have that uses a number of itk classes to perform some segmentation, I
>know that at least one of the classes has a leak, I can see how its
>memory usage grows as the program proceeds until at some point it dies,
>
>Unfortunately, I do not have any good program to solve this problem, I
>tried disconnecting the pipeline and deleting the previous filters but
>no luck,
>
>I am basically looking for some suggestions to fix this problem,
>
>Thanks for your time
>
>Leila
>
>_______________________________________________
>Insight-developers mailing list
>Insight-developers at itk.org
>http://www.itk.org/mailman/listinfo/insight-developers
>
>  
>
-------------- next part --------------
// valgrindmassage.cxx
// a program to reduce valgrind output to manageable proportions.
// usage: valgrindmassage <valgrind-output-file>
// writes massaged report on standard output.
//
// norman-k-williams at uiowa.edu
#include <iostream>
#include <string>
#include <fstream>
#include <list>
#include <ctype.h>
void
fix_error(std::string &s)
{
  std::string::size_type loc;
  bool possible;
  if((possible = s.find("are possibly lost") != std::string::npos) ||
     s.find("are definitely lost") != std::string::npos)
    {
    std::string::size_type first_newline =
      s.find('\n');
    if(first_newline != std::string::npos)
      {
      std::string s2 = (possible ? "Possible " : "Definite ");
      s2 += "Memory Leak\n";
      s2 += s.substr(first_newline+1);
      s = s2;
      }
    }
  std::string::size_type cur;
  loc = 0;
  while(loc != std::string::npos &&
        (loc = s.find("0x",loc)) != std::string::npos)
    {
    cur = loc + 2;
    while(cur != std::string::npos &&
          isxdigit(s[cur]))
      {
      cur++;
      }
    s.erase(loc,cur-loc);
    }
}

bool exclude(const std::string &s)
{
  static const char *exclusions[] = 
    {
    "LEAK SUMMARY",
    "ERROR SUMMARY",
    "GNU GPL",
    "getpwuid",
    "tclInstallCommands",
    "TclCreateExecEnv",
    "itk::MultiThreader",
    0
    };
  unsigned i;
  for(i = 0; exclusions[i] != 0 ; i++)
    {
    if(s.find(exclusions[i]) != std::string::npos)
      {
      return true;
      }
    }
  return false;
}
bool exclude_useless_leak_reports(const std::string &s)
{
  std::string::size_type stackentry = 0;
  if(s.find("by : ") != std::string::npos)
    {
    while(s.find("by : ",stackentry) != std::string::npos)
      {
      stackentry += 5;
      std::string::size_type address = s.find("???",stackentry,3);
      if(address == std::string::npos)
        {
        return false;
        }
      }
    return true;
    }
  return false;
}
int
main(int argc,char **argv)
{
  if(argc != 2)
    {
    std::cerr << "Oops" << std::endl;
    exit(-1);
    }
  std::ifstream in(argv[1]);
  std::list<std::string> message_blocks;
  std::string s;
  std::string accumulator;
  int total_count, net_count;
  while(getline(in,s))
    {
    if(s.find("==") != 0)
      {
      continue;
      }
    if(s[s.size()-1] == ' ') // a line with nothing on it terminates an entry
      {
      if(accumulator != "")
        {
        if(exclude(accumulator))
          {
          accumulator = "";
          }
        else
          {
          fix_error(accumulator);
          if(!exclude_useless_leak_reports(accumulator))
            {
            message_blocks.push_back(accumulator);
            }
          accumulator = "";
          }
        }
      }
    else
      {
      accumulator += s.substr(9);
      accumulator += '\n';
      }
    }

  total_count = message_blocks.size();
  message_blocks.sort();
  message_blocks.unique();
  net_count = message_blocks.size();
  std::list<std::string>::iterator it;
  for(it = message_blocks.begin();
      it != message_blocks.end();
      it++)
    {
    std::cout << (*it);
    std::cout << "---------------------------" << std::endl;
    }
  std::cout << "Total Count " << total_count << " Net Count " <<
    net_count << std::endl;
}