Re: [xsl] Notes on Comparison of XSL FO Renderers

Subject: Re: [xsl] Notes on Comparison of XSL FO Renderers
From: Tokushige Kobayashi <koba@xxxxxxxxxxxxx>
Date: Sun, 19 Oct 2003 18:48:47 +0900
To grasp the overall situation, I have complied the comparison 
data and percentage of implimentation.

Please refer to the following:

Implementation comparison:

Percentage of implimentation:

Overall, implementation level is as follows:

 XSL Formatter V2.5: 79%
 XSL Formatter V3.0: 70%
 FOP 0.20.5: 46%
 XEP V3.6:  74%
 xmlroff: 39%

There should be many notes for each implementation, I suppose.
More important is incompatibility issue. XSL-FO specification
is sometimes implimented depending on different understanding.

As for the performance, the large volume formating is another 
issue. For example, we are now expelimenting to format 40,000 
pages of complicated bank statement in reply to a some 
potential customer. XSL Formatter V3.0 can complete it. I do 
not know any other FO implementaion that can complete 40,000 
pages, that is 1,285,551(UTF-16) fo file.

Best regards,

Tokushige Kobayashi 

> reply ro the mail 
> From:David Tolpin <dvd@xxxxxxxxxxxxxx>
> Dated: Sat, 18 Oct 2003 13:25:52 +0500 (AMST) 
> Subject: [xsl] Notes on Comparison of XSL FO Renderers

> We have compared the following four XSL-FO processors.
> Generally speaking,
> The fastest processor is Antenna House XSL Formatter Version 3
> Second is XEP version 3
> The third is Antenne House XSL Formatter Version 2.5
> The slowest among these four is FOP. The performance of FOP is
> not good.


I believe that it is 

1) not fair to compare these processors in one row
2) even though it is not fair, the results above are plain wrong.

First, general notes,

  The fastest processor among listed is indeed "Antenna House XSL Formatter Version 3". But it is
  so for the price of so many features missing, that it is hardly usable for any
  practical implementation. 

  It should be compared to xmlroff, not to the two java implementations; and it looses to xmlroff.
  The set of features they implement are comparable.

  The fastest of relatively complete processors is Apache FOP. This is partly also because it lacks many
  features, neglecting constraints helps make code running better.

  RenderX XEP is slower than FOP; I am one of the core authors o XEP and I do know that it is so
  and why it is so. It is so because the objective of making algorithms spend only as much time 
  as required for each particular case is seldomly achievable; support for general cases and sofisticated
  features adds processing tiime to simpler ones.

Next, on speed comparison technique (results listed in the next message by Mr Kobayashi).

  Both XEP and FOP are Java processors. And both are developed for server and embedded use,
  not just for standalone command-line invocation.

  Modern JVM have significant startup time. Comparing batch invocations between a C++ program
  and a Java program on a small document (hammer is one of early RenderX samples available
  at is incorrect to say the least. JVM startup
  time is more than time required for XEP to process this particular sample.

  Both XEP and FOP have Java APIs and Ant Tasks. Speed comparison should be performed either on
  multiple invocations (ten formatting cycles of Hammer in one run, not one), or after loading
  it into a server environment. I am aware of successful use of XEP in client-server environment,
  where a small command-line client connects to a server running XEP via TCP; the throughput is
  much better.

  Besides, XEP, at least, and I recall that FOP does it too although I am not sure, caches a lot
  of data during formatting, thus subsequent calls result in better execution times.

Last but not least, comparing the processors in relatively the same range of features (Antenna XSL Formatter V2.5,
  XEP and FOP) must take into consideration different results they bring. Antenna House XSL Formatter V2.5
  supports vertical writing modes, has very slow and memory hungry PDF generator, and takes a lot of memory during
  formatting. XEP does not support vertical writing modes or Thai, time expenses on PDF generation are neglectable.
  FOP does not (or does it already?) support shorthands in attribute values, does not regard keep-* constraints
  and has other deficiencies which may or may not matter for you depending on your requirements.

There are other implementations, and they are also worth including into the list. I would just like to 
see correct comparison in speed and feature, not just a batch run on a RenderX Sample (which cannot be run through
FOP, by the way -- the FASTEST of processors listed - just because it does not have support for shortands, which, in turn,
are not required for basic conformance).

David Tolpin

 XSL-List info and archive:

Tokushige Kobayashi
Antenna House, Inc.
E-mail koba@xxxxxxxxxxxxx
WWW (English)
TEL    +81-3-3234-1361(direct call)
FAX    +81-3-3221-9975

Antenna House XSL School

 XSL-List info and archive:

Current Thread