Loading login details...

How to Compare Large Files

Table of Contents

  1. Introduction
  2. White space
  3. XML file structure
  4. Number of differences
  5. PCDATA
  6. Changes only or Full delta
  7. Java Heap Size
  8. SAX input sources
  9. Metrics
  10. Conclusion

1. Introduction

It is possible to compare very large datasets using DeltaXML; example test data has demonstrated that files over 1GB in size can be loaded from disk and compared in around 7 minutes.

NOTE: The Professional Named User licence for DeltaXML has a node limit and therefore will NOT process very large files. Please contact us if you need an evaluation to check processing of large files.

There are many different factors that affect performance with large files apart from the CPU type and speed, and the amount of physical memory, both of which must be adequate for the job. Some of the more important are discussed in the following sections. We also provide some typical metrics for DeltaXML on basic machines.

2. White space

White space nodes are generally significant in XML files. Each white space, e.g. newline or space, can be treated as a node in the XML file. This can increase the memory image size and slow the comparison process. It can also result in differences being identified that are not significant.

In many situations white space nodes are not important and can be ignored. If a file has a DTD, an XML parser can use this as the file is read in to identify whether white space is ignorable or not. If a white space node is ignorable, for example because it appears between two markup tags, DeltaXML will ignore it in the comparison process.

If there is no DTD white space nodes should be removed either using an editor or by processing using an XSL filter such as normalize-space.xsl, though using XSL can be time consuming for large files. The delta files generated by DeltaXML have no white space added to them: if you look at them in an editor you will see that new lines are added only inside tags. This may look strange at first but it is an effective way to have shorter lines without adding white space nodes to an XML file. White space inside tags will be ignored by any XML parser.

Remember also that indentation of PCDATA within a file has an effect: often white space in PCDATA and attributes should be normalized before comparison. Otherwise, again, there will be a lot of differences reported that are not important.

3. XML file structure

There is a performance difference in comparing 'flat' XML files, i.e. large number of records at one level, and more nested files, which tends to require less processing because there are fewer nodes at each level. Comparison of orderless data is generally slower.

4. Number of differences

The performance is affacted by the number of differences: it is quickest when there are no differences! The more differences there are the slower the comparison process because the software is trying to find a best match between the files. The LCS algorithm used in DeltaXML for pattern matching ordered sequences has optimal performance for small numbers of differences and slows significantly for large numbers of differences.

5. PCDATA

DeltaXML shares text strings, so many different text strings will result in a larger memory image and may cause the program to hit memory size limitations sooner. On the other hand, files with many identical strings will be stored very efficiently.

6. Changes only or Full delta

The DeltaXML API has the ability to generate a delta file with 'changes-only' or a 'full delta' that includes unchanged data as well.

The time for comparison and the memory required is independent of the type of delta being produced. However the full-context delta output is typically larger and will require more disk IO and CPU time to write to disk.

7. Java Heap Size

The size of the JVM heap is one of the main factors which determines the size of datasets which DeltaXML can process. The size of the heap, amount of available RAM and other JVM configuration options affects both capacity and performance (too small a heap will result in execess garbage collection, similarly not enough RAM will causes performance degredation). The following guidelines are suggested:

8. SAX input sources

Reading from disk based files, for example, using the command.jar command-line interpreter, is typically slower than processing SAX events produced from an existing in memory data representation. As well as the reduced disk IO a more significant speedup arises from the lack of lexical analysis/tokenization that is otherwise performed by a SAX parser. We also recommend testing different SAX parsers and comparing their performance using your data if you need to read XML files from disk.

9. Metrics

It is difficult to give accurate performance metrics for the reasons outlined above. But some examples may help as an indication.

There are very few large XML datasets which are publically available so we have used the XMark benchmark generator from: http://www.xml-benchmark.org/. This is typically used for testing XML content repositories/databases and XQuery implementations.  Suggestions for alternative benchmark data and particularly documents are welcome.

9.1 Test file generation

Example files of test data were generated using the following command-lines with the xmlgen application, the intention was to generate files around 1GByte in size:

$ ./xmlgen -v
This is xmlgen, version 0.92
by Florian Waas (flw@mx4.org)

$ ./xmlgen -f 10.0 -d -o f10.xml
$ ./xmlgen -e -o auction.dtd

$ ls -l f10.xml
-rw-rw-r--   1 nigelw   staff  1172322571 Nov  7 16:36 f10.xml

9.2 Test file characteristics

Some characteristics of the generated file are described using the following XPaths and their result values:

XPath Expression

value

count(/site/closed_auctions/closed_auction)

97,500

count(/site/open_auctions/open_auction)

120,000

count(/site/people/person)

255,000

count(/site/catgarph/edge)

10,000

count(/site/categories/category)

10,000

count(/site/regions/*)

6

9.3 Creating changes

While the shortest runtime is from performing an identity comparison (ie comparing the same file or data with itself) we wanted a more realistic test with perhaps a small number of changes.  To achieve this we deleted 7 random grand-children elements in the data, from the elements with large numbers of children. 

The following XPaths describe the elements which were deleted:

This 'trimmed' file was called f10t.xml and was slightly smaller than the original input.

9.4 Test Hardware and Software 

Test hardware was a Sun x4100, with:

Test software was DeltaXML Core 5.2

9.5 Test Command

The command-line driver was used to run and time the tests.  The following command was used:

$ time java -server -d64 -Xmx6g -jar /usr/local/deltaxml/DeltaXMLCore-5_2/command.jar compare delta f10.xml f10t.xml f10x.xml
DeltaXML Command Processor, version: 1.5
Copyright (c) 2000-2008 DeltaXML Ltd. All rights reserved.
Using: DeltaXMLCore, version: 5.2

real    7m28.145s
user    10m7.796s
sys     1m13.039s

9.6 Result comments

The above command represents the basic, default command-line usage.   The UNIX time results show a comparison time of around 7.5 minutes for these 1GByte data files. Faster times were obtained with the following techniques:

Some further issues relating to performance include:

We welcome feedback on these results and are prepared to look at tuning and performance issues for customers through our normal support channels.  Any suggestions for large XML datasets which can be used for benchmarking and performance testing would also be welcomed.

10. Conclusion

Be sure to remove white space from large input files. Performance depends on file structure and text content so needs to be evaluated on your own data.

However, it is clear form the above that DeltaXML can be used successfully with very large XML datasets.