Instead of slurping the first file into an array, you should consider a hash instead. This will improve your search time and also will get rid of your terribly inefficient way of removing the record from the array (see splice as an alternative to your method) by using delete. Additionally, using a hash will give meaningful names to columns. If you are forced to use an array, consider the constant pragma to make the indices more meaningful.

Update: Here is a proof of concept

use constant COMP => 0;
use constant USER => 1;
use constant UNKN => 2;

my %inventory;
open(my $fh_inv, '<', 'Inventory.csv') or die "Unable to open 'Invento
+ry.csv' for reading: $!";
while ( <$fh_inv> ) {
    chomp;
    my ($key, $company, $user, $unkn) = (split /,/)[0, 3, 1, 4];
    $inventory{$key} = [$company, $user, $unkn];
}

my @Data;
open(my $fh_clients, '<', 'clients.txt') or die "Unable to open 'clien
+ts.txt' for reading: $!";
while ( <$fh_clients> ) {
    chomp;
    my @field = split /,/;
    my $iref = $inventory{$field[3]};
    if ( @$iref ) {
        push @Data, (join ',', $field[3], $iref->[COMP], @field[6,7,4,
+11], @{$iref}[USER, UNKN]);
    }
}
#processing @Data after this
[download]

It seems to me that this problem cries out for an associative array (hash). Try splitting your inventory file and storing the array of elements you need in a lookup hash (keyed by the first token). Then when you split your client file, you can check to see if a hash entry matching the 4th token exists, and if so, grab the necessary element array from that hash entry. You can use delete() to get rid of unwanted hash entries once you're done with them.

Update: Added (untested) code sample:

my %inventory_hash = ();
open DataFile, "Inventory.csv" or die ("Inventory.csv $!");
while (my $inventory_line = <DataFile>) {
  my @inventory_fields = split /,/,$inventory_line;
  my $inventory_key = shift @inventory_fields;
  if (exists($inventory_hash{$inventory_key})) {
    print "Warning! Duplicate inventory key detected: $inventory_key\n
+";
    next;
  }
  $inventory_hash{$inventory_key} = \@inventory_fields;
}
close DataFile;
open DataFile, "clients.txt" or die ("clients.txt $!");
while (my $line = <DataFile>) {
  my @fields = split(/,/, $line);
  if (exists($inventory_hash{$fields[3]})) {
    my @sys = @{$inventory_hash{$fields[3]}};
    # do stuff with the contents of @sys, print, whatever
    delete $inventory_hash{$fields[3]};
  }
}
[download]

Hope this rather abbreviated example helps.

Hi putm and L~R,
Thanks a ton for the help. Hash saved me. I'm learning the power of hash day by day.
Joseph

Well, you should preprocess the data as much as you can before getting into the while loop. As the others monks have said, you should use a hash for faster lookup. If creating the hash with the entire file is consuming too much memory, try to break the input file in pieces, if possible. You should try it for the second file, too, if possible. Putting the entire file into memory is faster than reading line per line (if memory is cheap for you).

There are some other improvements you can try. I recommend this IBM article if you want to improve the performance of your program: http://www-128.ibm.com/developerworks/library-combined/l-optperl.html.

You should try to profile your program (with less input data, of course) using Dprof, even before trying to optimize the code. Doing that will help you to find out the area in your code that is wasting more time to execute. Here is a good link for that: http://www.perl.com/pub/a/2004/06/25/profiling.html

If creating the hash with the entire file is consuming too much memory, try to break the input file in pieces, if possible

or better use DB_File or similar to create an on disk hash/tree.

Consider also loading the data into an RDMBS (even just something like SQLite) and letting it do the heavy lifting.