The XML C library for Gnome

Table of Content:

1. General overview
2. Setting libxml set of memory routines
3. Cleaning up after parsing
4. Debugging routines
5. General memory requirements

General overview

The module xmlmemory.h provides the interfaces to the libxml memory system:

• libxml does not use the libc memory allocator directly but xmlFree(), xmlMalloc() and xmlRealloc()
• those routines can be reallocated to a specific set of routine, by default the libc ones i.e. free(), malloc() and realloc()
• the xmlmemory.c module includes a set of debugging routine

Setting libxml set of memory routines

It is sometimes useful to not use the default memory allocator, either for debugging, analysis or to implement a specific behaviour on memory management (like on embedded systems). Two function calls are available to do so:

• xmlMemGet () which return the current set of functions in use by the parser
• xmlMemSetup() which allow to set up a new set of memory allocation functions

Of course a call to xmlMemSetup() should probably be done before calling any other libxml routines (unless you are sure your allocations routines are compatibles).

Cleaning up after parsing

Libxml is not stateless, there is a few set of memory structures needing allocation before the parser is fully functional (some encoding structures for example). This also mean that once parsing is finished there is a tiny amount of memory (a few hundred bytes) which can be recollected if you don't reuse the parser immediately:

• xmlCleanupParser () is a centralized routine to free the parsing states. Note that it won't deallocate any produced tree if any (use the xmlFreeDoc() and related routines for this).
• xmlInitParser () is the dual routine allowing to preallocate the parsing state which can be useful for example to avoid initialization reentrancy problems when using libxml in multithreaded applications

Generally xmlCleanupParser() is safe, if needed the state will be rebuild at the next invocation of parser routines, but be careful of the consequences in multithreaded applications.

Debugging routines

When configured using --with-mem-debug flag (off by default), libxml uses a set of memory allocation debugging routines keeping track of all allocated blocks and the location in the code where the routine was called. A couple of other debugging routines allow to dump the memory allocated infos to a file or call a specific routine when a given block number is allocated:

• xmlMallocLoc() xmlReallocLoc() and xmlMemStrdupLoc() are the memory debugging replacement allocation routines
• xmlMemoryDump () dumps all the informations about the allocated memory block lefts in the .memdump file

When developing libxml memory debug is enabled, the tests programs call xmlMemoryDump () and the "make test" regression tests will check for any memory leak during the full regression test sequence, this helps a lot ensuring that libxml does not leak memory and bullet proof memory allocations use (some libc implementations are known to be far too permissive resulting in major portability problems!).

If the .memdump reports a leak, it displays the allocation function and also tries to give some informations about the content and structure of the allocated blocks left. This is sufficient in most cases to find the culprit, but not always. Assuming the allocation problem is reproducible, it is possible to find more easily:

1. write down the block number xxxx not allocated
2. export the environment variable XML_MEM_BREAKPOINT=xxxx , the easiest when using GDB is to simply give the command

   set environment XML_MEM_BREAKPOINT xxxx

   before running the program.

3. run the program under a debugger and set a breakpoint on xmlMallocBreakpoint() a specific function called when this precise block is allocated
4. when the breakpoint is reached you can then do a fine analysis of the allocation an step to see the condition resulting in the missing deallocation.

I used to use a commercial tool to debug libxml memory problems but after noticing that it was not detecting memory leaks that simple mechanism was used and proved extremely efficient until now. Lately I have also used valgrind with quite some success, it is tied to the i386 architecture since it works by emulating the processor and instruction set, it is slow but extremely efficient, i.e. it spot memory usage errors in a very precise way.

General memory requirements

How much libxml memory require ? It's hard to tell in average it depends of a number of things:

• the parser itself should work in a fixed amount of memory, except for information maintained about the stacks of names and entities locations. The I/O and encoding handlers will probably account for a few KBytes. This is true for both the XML and HTML parser (though the HTML parser need more state).
• If you are generating the DOM tree then memory requirements will grow nearly linear with the size of the data. In general for a balanced textual document the internal memory requirement is about 4 times the size of the UTF8 serialization of this document (example the XML-1.0 recommendation is a bit more of 150KBytes and takes 650KBytes of main memory when parsed). Validation will add a amount of memory required for maintaining the external Dtd state which should be linear with the complexity of the content model defined by the Dtd
• If you don't care about the advanced features of libxml like validation, DOM, XPath or XPointer, but really need to work fixed memory requirements, then the SAX interface should be used.

Daniel Veillard