So instead of using your current keys for storage, use the value that is called $pdbchain in your program as a hash key. Then you can replace whole while (($key, $value) = each %hash) { if ($a eq $b) { ... } } with a single hash lookup, which should improve the performance.

Bug: The following do anything (useful):

$res =~/\S/g;
$domchain =~/\S/g;
$pdbchain =~/\S/g;
[download]

You want:

$res =~ s/\s//g;
$domchain =~ s/\s//g;
$pdbchain =~ s/\s//g;
[download]

Also, all over you have "$var" which needlessly makes a copy of $var. Drop the quotes. You want just $var. For example,

if("$domchain" eq "$pdbchain")
should be
if($domchain eq $pdbchain)

• use English makes your regular expressions dramatically slower (see English).
• Since you don't use English names for punctuation variables—it is unnecessary anyway. So are use UNIVERSAL qw(isa) (which should not be used as a function anyway) and use FileHandle. However, use warnings would be nice.

In the olden days English was known to slow down all your regular expressions. (I think they fixed that in 5.10?) That could be part of the problem.

Which part of your program is slow?

I think its ok until I get to the bit where I'm going though the %dom_hash hash.

In addition to what everyone else has said: Whenever you hear/think/say 'why is my code slow', profile!

Given the simplicity of the program (two nested loops), profiling won't tell you much ("the nested content is slow") until you've done some high-level analysis.

If the nested loops can be eliminated or sped up, improvements will ensue. For example, if it's possible for $domain to have the same value for two rows of DOMFILE, a file is being read more often than it needs to be.

And then there's the three-deep loop at the bottom. Efforts should be placed into flattening those.

Once that's done, profiling could be used to do some micro-optimisations.

Update: That one part of the program is IO-bound and the other is CPU-bound is noteworthy. Maybe parallelisation is an option.

I'm of the opinion that the added understanding gained by profiling is worth it even in simple cases. At the point where you are trying to speed it up, even educated guessing is often wrong. And Devel::NYTProf (which I linked to above) does both line-level and block-level profiling, so it would directly say that the problem is that you are running these loops too often. (Leading the optimizer to start looking for ways to run them less, hopefully.)

When looking at profile output, there is a temptation to focus on individual lines I'll admit; but it can and does help just as much on a broader scale, as long as the programmer resists that temptation.

foreach my $key (sort keys %csa_hash)
{
    #print "$key\n";
    
    # ok we now need to split up the key in the hash
    
    my $pdb = substr($key, 0, 4);
    
    my $chain = substr($key, 5, 1);
    
    my $res = substr($key, 7, 6);
        
    #print "$pdb $chain $res\n"; # works great. using substring as I d
+ont really want to create an array
    
    my $pdbchain = "$pdb" . "$chain"; # concatenate together so to com
+pare with domain data
    
    # print "$pdbchain\n"; # works fine
    
    # lets be on the safe side and remove white space
    # for domchain and pdbchain
    
    $res =~ s/\s//g;
    #$domchain =~ s/\s//g;
    $pdbchain =~ s/\s//g;
    
    #chomp($domchain);
    chomp($pdbchain);
    
    if($dom_hash{$pdbchain}{$res})
    {
    print "$pdbchain $res\n";
    }   
}
[download]

I think the problem starts with how the CSA_hash is built. You have 3 values: $pdb,$chain,$res that are concatenated together to form one key and the value of that key is always 1. That is all well and good if the main thing is that this combination of things is only counted once. Maybe you need to do that, I don't know. BUT later on in the most performance critical part of the code, what you really want to know is what $res's correspond to the $pdb,$chain combination. So another idea for CSA_hash, would be like this:

die "some usage error msg" if (@ARGV !=2);
my ($domFile,$csafile)= @ARGV; 

open(CSAFILE, "$csafile") or die "unable to open $csafile: $!";

my %csa_hash;
my %dom_hash;
my $domain_dir = "<my directory>";

while(<CSAFILE>)
{
    chomp;
    s/\s+//g;  #keep things simple, delete spaces
    my ($pdb,$chain,$res) = (split(/,/, $_))[0,3,4];
    push (@{$csa_hash{"$pdb;$chain"}},$res}); 
}
[download]

Where all of this is headed is to the 3rd loop level:

while ((my $key, my $value) = each(%csa_hash))
{....}
[download]

if("$domchain" eq "$pdbchain"){....}
[download]

One thing that I think is noteworthy is that if a string can work in a print statement, it will work as a hash key, eg. $somehash{"$pdb;$chain"}= $res; If the ";" is not a valid value inside of the $parm vars, then this works great. If you have a multi-value key, you can do a split on ";".

hope this helps.

        $domchain =~/\S/g;
        $pdbchain =~/\S/g; 

        chomp($domchain);
        chomp($pdbchain);
[download]

I tried to fix some things in the code below, but, naturally, I could't try to run it (as I don't have the files).

use strict;
use warnings FATAL => 'all';
use autodie;

my $dir = "<my directory>";
my ( $dom_file_name, $csa_file_name ) = @ARGV;
my %csa_hash;
my %dom_hash;

open my $csa_file, '<', $csa_file_name;
while ( my $csa = <$csa_file> ) {
    my @csa_data = split( /\,/, $csa );
    $csa_hash{ $csa_data[0] . $csa_data[3] } = $csa_data[4];
}
close($csa_file);

open my $dom_file, '<', $dom_file_name;
while ( my $dom = <$dom_file> ) {
    my @dom_data = split /\s+/, $dom;
    my $domain = $dom_data[0];
    next if exists $dom_hash{$domain};
    open my $ind_dom_file, '<', $dir . $domain;
    while ( my $line = <$ind_dom_file> ) {
        chomp $line;
        my @ff     = split /\s+/, $line;
        my $number = $ff[5];
        my $CA     = $ff[2];
        push @{ $dom_hash{$domain} }, $number if $CA eq 'CA';
    }
    close $ind_dom_file;
}
close $dom_file;

while ( my ( $protein_dom, $residues_ref ) = each %dom_hash ) {
    for my $residue ( @{$residues_ref} ) {
        my $dom_chain = substr( $protein_dom, 0, 5 );
        if ( $residue eq $csa_hash{$dom_chain} ) {
            print "$dom_chain $residue\n";
        }
    }
}
[download]

The idea was that it does the same thing as your code, but faster.