I've just had a quick look at the source and its not a million miles away from what we've done; but it does rely on a particular structure of hashref/arrayrefs that we don't have so we couldn't use it as it stands but its reassuring to know at least one other person took the same approach.

Have we made a fundamental error somewhere...

I think yes. Your libxml_output() re-structures the passed $xml, then stringifies, the xmlsimple_output() just stringifies the passed $xml, generated by XMLin() beforehand. The subroutines are not comparable.

Just measuring the performance of stringification ...

#!/usr/bin/perl -w
use strict;
use XML::Simple;
use XML::LibXML;
use Benchmark qw(cmpthese);

my $file = shift or die "usage: $0 xmlfile\n";

my $xml = XMLin( $file);
my $dom = XML::LibXML->load_xml(location => $file);

cmpthese ( -1, {
        simple => sub { XMLout($xml) },
        libxml => sub { $dom->toString() },
    }
);
__END__
         Rate simple libxml
simple 29.4/s     --   -96%
libxml  658/s  2141%     --
[download]

... gives a different picture. Are you working internally with $xml or $dom ?

Ah, sorry I didn't make it clear - in the production code there is no file to load from - here its just a handy way of getting a similar hashref to do timings on. So we can't just compare stringification; we have to convert hashref to $dom then stringify.

Internally in the 'real' system we have 30 odd Classes some of which with 5-10 polymorphic variants that all have a method called output which returns a nested hashref/arrayref structure that can be converted into JSON/XML/Storable etc. These are all assembled into one giant hashref before conversion.

For the example I simply used XMLin to create a hashref that would be similar to what we already - internally (in our real framework) we're working with something that resembles $xml (which is badly named and perhaps should be $nested_hashref_containing_arrayrefs_and_hashrefs). A tiny fragment of it would look like:

$VAR1 = {
          'RelationshipPermissions' => {
                                       'PermissionHolderType' => {
                                                                 'cont
+ent' => 'authenticated'
                                                               },
                                       'ZName' => {
                                                    'content' => 'svz_
+admin_rp'
                                                  },
                                       'DisplayName' => {
                                                          'content' =>
+ 'Admin Permissions'
                                                        },
                                       'IPList' => {
                                                   'content' => 'any'
                                                 },
                                       'changeable' => {
                                                       'content' => 't
+rue'
                                                     },
                                       'readable' => {
                                                     'content' => 'tru
+e'
                                                   },
                                       'deleteable' => {
                                                       'content' => 't
+rue'
                                                     },
                                       'appendable' => {
                                                       'content' => 't
+rue'
                                                     },
                                       'secureable' => {
                                                       'content' => 't
+rue'
                                                     }
                                     }
        };
[download]

So whilst the stringification is quicker if we already have a complete DOM object structure - we don't already have that and modifying our code to produce that would a) be a massive task and b) make it more difficult (impossible / slower) to also produce JSON / Storable output.

Full code

#!/usr/bin/perl -w

use strict;
use XML::Simple;
use XML::LibXML;
use diagnostics;
use Time::HiRes qw(gettimeofday);

package MyXMLSimple;
use base 'XML::Simple';

sub sorted_keys { my ( $self, $name, $hashref ) = @_; return sort { ma
+in::element_order($a) <=> main::element_order($b) } keys(%{$hashref})
+; };

package main;

#load xmlfile using XMLin (creating hashref)
my $file =  $ARGV[0];
my $reps = $ARGV[1] || 1;

my $xml = XMLin( $file);

our $dom;

our %ELEMENTORDER  = ( Process => 1, Filter => 2, Field => 3, ZName =>
+ 4);

my $before = gettimeofday();
my $xso;
foreach my $i (0..$reps) {
$xso = xmlsimple_output($xml);
}
my $xso_time = sprintf("%0.3f", (gettimeofday() - $before) * 1000);

print "=========================XML Simple outptut ===================
+===========\n";
print $xso;

$before = gettimeofday();
my $lxo;
foreach my $i (0..$reps) {
$lxo = libxml_output($xml);
}
my $lxo_time = sprintf("%0.3f", (gettimeofday() - $before) * 1000);
print "=========================Lib XML outptut ======================
+=======\n=";
print $lxo;

print "====================TIMINGS=======================\n";
print "LibXML time for $reps rep(s): $lxo_time ms\n";
print "XML Simple time for $reps rep(s): $xso_time ms\n";
#print keys %{$xml->{Process}->[0]->{LongDescription}->{content}};

#loads (above) into an XML::LibXML object using a recursive method
sub element_order
{
    my $element_name = shift;
    return $ELEMENTORDER{$element_name} || 9999999;
}

sub add_nodes_hash
{
    #first time $xml will be the file, after that it will be the hash 
+or array ref
    # $is_child is a flag to see if it wants to be added as like a roo
+t node, or part of a nest
    my $xml = shift;
    my $parent_element = shift;
    
    foreach my $node (sort {element_order($a) <=> element_order($b)} k
+eys %{$xml})
#    foreach my $node (keys %{$xml})
    {
        #next if ($node =~/\//);        
        if (ref($xml->{$node}) eq 'HASH')
        {
            my $element = $dom->createElement( $node );
            $parent_element->insertAfter($element,undef);
            add_nodes_hash($xml->{$node},$element);
        }
        if (ref( $xml->{$node} ) eq 'ARRAY')
        {
            
            foreach my $array_element (@{$xml->{$node}})
            {
                if (ref($array_element) eq 'HASH')
                {
                    my $element = $dom->createElement( $node );
                    my @attributes = $element->attributes();
                    $parent_element->insertAfter($element,undef);
                    add_nodes_hash($array_element,$element);
                }
                elsif (!ref( $xml->{$node} ) && ($xml->{$node}))
                {
                    my $element = $dom->createElement( $node );
                    $element->appendText($xml->{$node});
                    $parent_element->insertAfter($element,undef);
                }
            }
        }
        elsif (!ref( $xml->{$node} ) && ($xml->{$node}))
        {
            my $element = $dom->createElement( $node );
            $element->appendText($xml->{$node});
            $parent_element->insertAfter($element,undef);
        }    
    }
    return $dom;
}



#use toString() to print it out

#print add_nodes_hash($xml,0)->toString;


sub libxml_output {
my $xml = shift;
#create the dom object
$dom = XML::LibXML::Document->new();


my $root = $dom->createElement('Zymonic');
$dom->setDocumentElement($root);
add_nodes_hash($xml, $root);
return $dom->toString(1);

}

sub xmlsimple_output {
my $xml = shift;
my $parser = MyXMLSimple->new( KeyAttr => [], RootName => 'Zymonic' );
return $parser->XMLout($xml,
        KeyAttr       => [],
        RootName      => 'Zymonic',
        NoEscape      => 1,
        SuppressEmpty => 1
);
}
[download]

Interesting – but what does that have to do with the OPs concern? No downvotes here, obviously, but I do not see your point!

Apologies - I am the OP... I thought it may make the question too long if I gave full source code for our script, but thought it may be useful to anyone trying to recreate the scenario - so I added it as a reply.