You could look at using XML::Twig, which bills itself as being able to process huge XML files. Alternativly you could profile your code with Devel::NYTProf to see if there are any points for improvement, see also Debugging and Optimization from the tutorials section of this site. This of course would require you to change some of your code, however since you don't show us your code we can't point out any issues it may have, or suggest areas for improvement.

Here is the pretty simple code.

I've dumped XML file into Perl's data structure using XMLin() which itself is taking so much of time.

Rest of the other processing to extract the data is not taking much time for me..

use strict;
use warnings;
use XML::Simple;
use XML::LibXML;
my $XML_FILE = 'sample.xml';

# Dump of the XML file in Perl's Data Structures
my $mldata = XMLin($XML_FILE);
[download]

Do you need to read the entire XML file into memory before you begin to process it? See Processing an XML document chunk by chunk from the XML::Twig docs.

BTW, use XML::LibXML is superfluous here, as you're not actually using it anywhere in the code...

In case you want to stick with XML::Simple (to avoid having to change existing code), you might want to check which parser XML::Simple is using under the hood  (in case of doubt, print out which modules have been loaded at the end of your script, using print join "\n", sort values %INC;)

As you're already using XML::LibXML anyway, you might want to try telling XML::Simple to use it by setting:

$XML::Simple::PREFERRED_PARSER = "XML::LibXML::SAX";
[download]

(See XML::Simple Environment for the details.)

As XML::LibXML is known to be one of the fastest XML parsers, this might speed up things (even though XML::Simple would of course still be creating its gazillion of hashes and arrays...)

XML::Twig may be a good candidate, if you use its simplify() method, then the changes against the XML::Simple based code may be fairly small. You'll just replace the outmost loop by a subroutine definition and instead of parsing the whole file and then looping, you'll tell XML::Twig to call that subroutine for each of those tags. Something like (PSEUDOCODE!):

my $xml = XMLin($file);
for my $foo (@{$xml->{foo}) {
  #and now we process the $foo
}

=>

$xmltwig->parse( xml_roots => {
  'foo' => \&process_foo
});
sub process_foo {
  my ($xmltwig, $foo_obj) = @_;
  $foo = $foo_obj->simplify();
  #and now we process the $foo
}
[download]

Another option is to use XML::Rules. It can tweak and simplify the generated structure as the file is parsed and like the XML::Twig, it allows you to execute code once a "twig" (a tag with all subtags and content) is fully parsed. See some of the examples on perlmonks or included with the module.

No. Depending on what you actually wrote, it shouldn't take too long ( 30min) to convert to XML::Twig