xml.etree.ElementTree.iterparse() not scalable for large XML docs?

Question

I'm trying to do incremental parsing via iterparse() of an XML doc that is (designed to be) too large to fit in memory. I find doing even a no-op pass over the doc exhausts process memory and causes my system to start swapping.

Is it wrong to expect xml.etree.ElementTree.iterparse() to run in constant memory independent of size of XML doc? If so, what is the recommended package for doing incremental parsing of arbitrarily long XML docs? And if not, WTF is wrong with my code?

Here is the code: Note that I request 'start' events only (so parser doesn't try to buffer up all the body elements before returning the end tag of the document root element ( in my case). and I explicitly del() the loop variables to force them to be freed.

Thinking that the garbage collector might not be getting a chance to run since the loop doesn't yield, I added explicit call to gc.collect() and time.sleep() every million iterations. But it doesn't help.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import xml.etree.ElementTree as ET
import pprint

import gc
import time
import os
import psutil

def gcStats(myProc):
    # return human readable gc.stats for 3 generations

    extmem = myProc.memory_info_ex()

    a =  "extmem: rss {:12n}, vms {:12n}, shared{:12n}, text{:12n}, lib {:12n}, data{:12n}, dirty{:12n}".format(
                    extmem.rss, extmem.vms, extmem.shared, extmem.text, extmem.lib, extmem.data, extmem.dirty)

    return a + "	gc enabled {}, sumCount {:n}, lenGarbage {:n}".format( gc.isenabled(), sum(gc.get_count()), len(gc.garbage)) 

# the misbehaving code:    
def count_tags(filename):
    retVal = {}
    iterCount = 0
    sleepTime = 2.0
    myProc = psutil.Process()

    print("Starting: gc.isenabled() == {}
{}".format(gc.isenabled(), gcStats( myProc)))

    for event, element in ET.iterparse(filename, ('start',)):
        assert event == 'start'
        if iterCount % 1000000 == 0:
            print('{} iterations, sleeping {} sec...'.format(iterCount, sleepTime))
            time.sleep( sleepTime)
            print('{}
Now starting gc pass...'.format( gcStats( myProc)))
            gcr = gc.collect()
            print('gc returned {}'.format( gcr))
        iterCount += 1
        del element
        del event
    return retVal


if __name__ == "__main__":
    tags = count_tags('/home/bobhy/MOOC_Data/' + 'chicago.osm')

Here is a sample of the doc. It is well-formed OSM data.

. . . and so on for 1.8 GB . . .

And here is the output:

Starting: gc.isenabled() == True
extmem: rss      9097216, vms     37199872, shared     3145728, text     3301376, lib            0, data     5820416, dirty           0 gc enabled True, sumCount 410, lenGarbage 0
0 iterations, sleeping 2.0 sec...
extmem: rss      9097216, vms     37335040, shared     3145728, text     3301376, lib            0, data     5955584, dirty           0 gc enabled True, sumCount 87, lenGarbage 0
Now starting gc pass...
gc returned 0
1000000 iterations, sleeping 2.0 sec...
extmem: rss   1234309120, vms   1262891008, shared     3280896, text     3301376, lib            0, data  1231511552, dirty           0 gc enabled True, sumCount 372, lenGarbage 0
Now starting gc pass...
gc returned 0
2000000 iterations, sleeping 2.0 sec...
extmem: rss   2495262720, vms   2524073984, shared     3280896, text     3301376, lib            0, data  2492694528, dirty           0 gc enabled True, sumCount 37, lenGarbage 0
Now starting gc pass...
gc returned 0
3000000 iterations, sleeping 2.0 sec...
extmem: rss   3781947392, vms   3812208640, shared     3280896, text     3301376, lib            0, data  3780829184, dirty           0 gc enabled True, sumCount 262, lenGarbage 0
Now starting gc pass...
gc returned 0
4000000 iterations, sleeping 2.0 sec...
extmem: rss   5067837440, vms   5096787968, shared     3280896, text     3301376, lib            0, data  5065408512, dirty           0 gc enabled True, sumCount 241, lenGarbage 0
Now starting gc pass...
gc returned 0
5000000 iterations, sleeping 2.0 sec...
extmem: rss   6345998336, vms   6375632896, shared     3063808, text     3301376, lib            0, data  6344253440, dirty           0 gc enabled True, sumCount 333, lenGarbage 0
Now starting gc pass...
gc returned 0
6000000 iterations, sleeping 2.0 sec...
extmem: rss   7266795520, vms   7665147904, shared     1060864, text     3301376, lib            0, data  7633768448, dirty           0 gc enabled True, sumCount 877, lenGarbage 0
Now starting gc pass...

I interpret the output to show process virtual memory is growing by about 1 000 B / iteration (that is, per XML tag parsed). I think the garbage collection stats do not show a monotonic increase in allocated objects, so I don't know where the memory growth is coming from. Garbage collection is indeed enabled.

BobHy · Accepted Answer

Close reading of the doc for iterparse() convinces me that the above is intended behavior. The doc says that it returns a full-fledged Element with no restrictions on child access, so it must be retaining the (incrementally growing) document tree in memory.

Since my problem did not need parent or child element access, just an event for each tag encountered, I was able to solve my problem nicely with xml.etree.ElementTree.XMLParser().

xml.etree.ElementTree.iterparse() not scalable for large XML docs?

Answers (2)

Related Questions