This weekend I read about a claim made by Altova that their XSLT 2.0 processor was 3 times faster than SaxonJ 8.7.

In particular, what they claim here is the following:

AltovaXML is 3X faster than the competition.

The AltovaXML processor is more than three times faster than Saxon. In a test of a selection of 1,127 test files from the official W3C test suite for XSLT 2.0, the same files AltovaXML processed in 6 minutes 42 seconds took Saxon a full 22 minutes to process. (Further details about test methods and metrics can be found below.) This makes an unbelievable difference in developer productivity as well as application optimization.

Michael Kay responds to these statements in his blog entry "Altova Mudslinging":

At least they had the decency to describe how they measured it - by running a thousand or so conformance tests from the W3C test suite using a batch script in which each transformation was run individually from the command line. Any reasonably competent user knows that that's a hopelessly inefficient way of running Java programs, because the initialisation costs for loading the Java VM a thousand times far exceed the time spent actually doing useful work. But of course, Altova know that a lot of people will only read the headlines.

On the Questions and Answers page of Saxon Michael Kay provides his results comparing the performance of AltovaXML to Saxon:

With a properly written Java test driver, Saxon takes 2 min 50 sec to run the full suite of 4864 tests, compared with the 6 min 42 sec that Altova took to run a subset of 1127 tests using their own processor. That's 28.6 tests per second for Saxon, 2.8 tests per second for Altova. The Saxon timing includes the expensive operation of comparing the results with reference results, I don't know if that's included in Altova's figures. Either way, if they're choosing to compete on performance, then they've got a long way to go.

Anyway, if they were running the W3C conformance test suite, then where are their results? And why were they only running a subset of the tests? Saxon's results are here

So, it turns out that Saxon is about 10 times faster than Altova on the full W3C conformance tests.

Here comes the fun part.

Given the times reported the 4000 or so W3C conformance tests must be all small to medium-sized.

As the beginning of wisdom is to call things by their right names, I ran some of my favourite transformations (from my FXSL library and  Sudoku solver) on my 3-year old home (DELL Pentium IV 3GHz, 2MB RAM Windows XP SP2) PC.

The results are below:

The "25min +" and "35min +" timings above actually mean that this was the time I was waiting for the AltovaXML2007-run - transformation to finish, before I decided to kill the process.

While everyone is encouraged to perform their own tests and the results of the tests may vary, it seems that the above results are quite significant.

To summarize the results:

For my favourite tasks AltovaXML2007 performs about 10 to hundreds of times slower  than SaxonJ 8.7.3

UPDATE: Another person has run his performance tests. The results:

"Saxon finishes this stylesheet in less then 3 minutes and consumes ~130 MB of RAM. For the most of the time Saxon utilizes only 70% of CPU -- disc is probably slower then Saxon ;-)
I tried the same stylesheet and data with Altova2007. After 30 minutes only 400 files from 5000 vere generated and 950 MB of RAM was vasted, CPU utilization for Altova process was over 90%. I decided to interrupt test here. For this stylesheet Altova was at least 100 times slower than Saxon. Moreover Altova eat more and more memory with each outputed file, so there is probably some memory leak in this product."

As some proverbs go, 

Cows might fly, but they are most unlikely birds.

Haste makes waste.

and

There is plenty of sound in an empty barrel.

If you ever had a look at the 

    func-standardXpathFunctions.xsl

stylesheet of FXSL 2 or let's say at the new module

    func-standardStringXpathFunctions.xsl

you have seen a lot of repetitive code like this:

<xsl:template match="f:string-join"
                      mode="f:FXSL">
  <xsl:param name="arg1" as="xs:string*"/>
  <xsl:param name="arg2" as="xs:string*"/>

  <xsl:sequence select=
   "f:string-join($arg1, 
                         if(empty($arg2)) then ''
                                                     else $arg2)"/>
</xsl:template>

<xsl:function name="f:string-join"
                    as="element()">
<f:string-join/>

</xsl:function>

<xsl:function name="f:string-join" as="node()">
  <xsl:param name="arg1" as="xs:string*"/>

  <xsl:sequence select=
     "f:curry(f:string-join(), 2, $arg1)"/>
</xsl:function>

<xsl:function name="f:string-join"
                     as="xs:string">
  <xsl:param name="arg1" as="xs:string*"/>
  <xsl:param name="arg2" as="xs:string"/>

<xsl:sequence select=
          "string-join($arg1,$arg2)"/>
</xsl:function>

You may have probably wondered how this code was generated for hundreds of standard XPath 2.0 functions.

Until recently, the answer was: manually.

A few days ago I had to provide the HOF wrappers for the only remaining group of XPath functions that didn't have one -- the various DateTime functions from the F & O spec.

This time I decided to automate the generation process as much as possible.

Here is the result:

if one specifies a function in a xml file containing nodes like this:

<f name="adjust-dateTime-to-timezone"
    type="xs:dateTime?">

  <pdateTime type="xs:dateTime?"/>
  <ptimeZone type="xs:dayTimeDuration?"/>

  <fCode>
    <xsl:sequence select=
     "adjust-dateTime-to-timezone
                        ($pdateTime,$ptimeZone)"/>
  </fCode>
</f>

then the full stylesheet module to create the HOF wrappers of the functions so specified is the following:

<xsl:stylesheet version="2.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
 xmlns:f="http://fxsl.sf.net/"
 xmlns:fint="http://fxsl.sf.net/internal"
 xmlns:xxx="xxx"
>

  <xsl:output omit-xml-declaration="yes"
                     indent="yes"/>

  <xsl:namespace-alias stylesheet-prefix="xxx"
                                    result-prefix="xsl"/>

  <xsl:template match="/">
    <xxx:stylesheet version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:f="http://fxsl.sf.net/"
  exclude-result-prefixes="f xs"
>
    <xxx:import href="func-curry.xsl"/>

    <xsl:apply-templates/>

    </xxx:stylesheet>

  </xsl:template>

  <xsl:template match="f">
    <xsl:comment>
----------------------------------------------------
Function: <xsl:value-of select="@name"/>()
</xsl:comment><xsl:text>&#xA;</xsl:text>

    <xxx:template match="f:{@name}"
                          mode="f:FXSL">

    <xsl:sequence select=
                          "fint:makeType(@type)"/>

    <xsl:for-each select="*[not(self::fCode)]">
      <xxx:param name="arg{position()}">
        <xsl:sequence select=
                                 "fint:makeType(@type)"/>
      </xxx:param>
    </xsl:for-each>

    <xsl:variable name="vFuncCall"
                        as="xs:string">

      <xsl:value-of separator=""
         select=

            "('f:',@name, '(',
               for $cnt in count(*[not(self::fCode)]),
                      $i in 1 to $cnt
                          return (concat('$arg', $i),
                                               if($i lt $cnt)
                                                 then ',' 
                                                 else ()
                                     ),
               ')'
             )

           " />
    </xsl:variable>

    <xxx:sequence select="{$vFuncCall}"/>
  </xxx:template>

  <xxx:function name="f:{@name}" 
                       as="element()">
    <xsl:element name="f:{@name}"/>  
  </xxx:function>

  <xsl:variable name="vFNode"
                       select="." as="element()"/>

  <xsl:for-each select=
             "1 to count(*[not(self::fCode)]) - 1">
    <xsl:sequence select=
                        "fint:makePartApp($vFNode,.)"/>
  </xsl:for-each>

  <xsl:sequence select=
                     "fint:makeFuncCode($vFNode)"/>
</xsl:template>

<xsl:function name="fint:makeType"
                     as="attribute()">
  <xsl:param name="pType" as="attribute()"/>

  <xsl:attribute name="as" select=
      "if(string($pType))
          then string($pType)
          else 'xs:untyped'
    "/> 
</xsl:function>

<xsl:function name="fint:makePartApp"
                     as="element()">
  <xsl:param name="pFNode" as="element()"/>
  <xsl:param name="pNumArgs"
                    as="xs:integer"/>

  <xxx:function name="f:{$pFNode/@name}"
                       as="element()">

  <xsl:for-each select=
                        "$pFNode/*[not(self::fCode)]">
    <xsl:if test="position() le $pNumArgs">
      <xxx:param name="{name(.)}">   
        <xsl:sequence select=
                            "fint:makeType(@type)"/>
      </xxx:param>
    </xsl:if>
  </xsl:for-each>

  <xsl:variable name="vCurriedCall"
                       as="xs:string">

    <xsl:value-of separator="" select=
        "('f:curry(','f:', $pFNode/@name, '(),',
                   count($pFNode/*[not(self::fCode)]),',', 
                   for $cnt in count($pFNode/*
                                                 [not(self::fCode)]),
                        $i in 1 to $pNumArgs
                            return ('$',name($pFNode/*
                                                   [not(self::fCode)]
                                                   [$i]),
                                        if($i lt $pNumArgs)
                                           then ','
                                           else ()
                                     ),
                       ')'
          )"
    />
  </xsl:variable>

  <xxx:sequence select="{$vCurriedCall}"/>

  </xxx:function>

</xsl:function>

<xsl:function name="fint:makeFuncCode"
                     as="element()">
  <xsl:param name="pFNode" as="element()"/>

  <xxx:function name="f:{$pFNode/@name}">
    <xsl:sequence select=
              "fint:makeType($pFNode/@type)"/>

    <xsl:for-each select="$pFNode/*
                                         [not(self::fCode)]">

      <xxx:param name="{name(.)}">
        <xsl:sequence select=
                                "fint:makeType(@type)"/>  
      </xxx:param>
   </xsl:for-each>

   <xsl:sequence select=
                             "$pFNode/fCode/node()"/>
  </xxx:function>
</xsl:function>

</xsl:stylesheet>