Anyway I have some sparse hints you can try to speed up your code. First you are doing something like for 5 regex, for 50k lines that is very heavy approach: you are processing every line 5 times. Normally when you iterate over a file (with the slowness of filesystem) is better to do the opposite: for 50k lines, for 5 regex (even if the result of 5 * 50k and 50k * 5 is identic) and you do not really need the big array at all!

You are populating the array with a big amount of lines. This consume memory and slow your program. See reading large file where is explained that foreach my $line (<$readHandle>) {.. is list context and while (defined( my $line= <$readHandle>)) { is scalar context.

So you need a change in the loop, like

while (defined( my $ln= <$readHandle>)) {

    ...
}
[download]

After this i see you are using if .. if .. if .. are you sure this is your intention? or better if .. elsif.. elsif .. else.. you really want to match more than one case?

Finally to speed up the loop you can insert some exit (from the loop) condition earlier in the loop. If this is possible is always worth to do.

Also if you can anchor somehow your regexes this will speed up a lot the match in long lines.

You can find these thread also interesting:

Optimising large files processing
Recommendations for efficient data reduction/substitution application
Using indexing for faster lookup in large file

HtH

L*

Hi Discipulus,

Thanks for your suggestions.

I have now done three changes to reduce the time taken.

1. Precompiled the regex and used them. This reduced the time taken from ~30 minutes to ~15 minutes. 2. Changed foreach loops to while loops 3. I managed to find the lines in input file which were responsible for longer runtime. I skipped parsing those lines, after confirming that they are not required. These lines were common in most of the input files.

After all this, time to run has come down from ~30 minutes to ~35 seconds.

A huge, huge, huge improvement.

Solving this issue has gotten me more interested in perl. Cant thank you enough for your help!

Hi,

Thanks a lot for the suggestions. I will try them and update here the results :)

Another trick to reduce processing time is to compose all the  @strings_to_be_matched strings into a single regex.

c:\@Work\Perl\monks>perl -wMstrict -le
"my @strings_to_be_matched = qw(foo bar wibble wobble fee_fie foe fum)
+;
 ;;
 my ($ur) =
   map  qr{ $_ }xms,
   join q{ | },
   map  quotemeta,
   reverse sort
   @strings_to_be_matched
   ;
 print qq{\$ur: $ur};
 ;;
 my $reg3 = qr/extern.+\b$ur\b\s*/i;
 print qq{\$reg3: $reg3};
"
$ur: (?^msx: wobble | wibble | fum | foo | foe | fee_fie | bar )
$reg3: (?^i:extern.+\b(?^msx: wobble | wibble | fum | foo | foe | fee_
+fie | bar )\b\s*)
[download]

• the  @strings_to_be_matched strings are all C/C++ or similar keywords or identifiers and so consist entirely in  \w characters;
• the  $ur pattern is always bounded by  \b assertions whenever it is interpolated.

So your final code might look something like this (untested):

my @strings_to_be_matched = ...;

my ($ur) =
    map  qr{ $_ }xms,
    join q{ | },
    map  quotemeta,
    reverse sort
    @strings_to_be_matched
    ;
    
my $reg1 = qr/=/i;
my $reg2 = qr/\S+=\S+/i;            
my $reg3 = qr/extern.+\b$ur\b\s*/i;
my $reg4 = qr/;$/i;                       
my $reg5 = qr/.+\b$ur\b\s*/i;

foreach my $ln (@contents_of_file) {

    if ($ln =~ $reg3 and $ln =~ $reg4) { ... }

    if ($ln =~ $reg5 and $ln=~ $reg4 and ($ln !~ $reg1 or $ln =~ $reg2
+)) { ... }

    if ($ln =~ $reg3 and $ln !~ $reg4) { ... }

    if ($ln =~ $reg5 and $ln !~ $reg4 and $ln !~ $reg1) { ... }

    }
[download]

Another thing that may affect speed is that you have all your regexes  $reg1 $reg2 $reg3 $reg4 $reg5 modified as  /i (case insensitive). Case insensitivity slows down regex execution. Some of your regexes have only assertions, characters or character classes  \S $ ; = to which case insensitivity does not apply. As noted above, the  @strings_to_be_matched strings seem to be C/C++ or suchlike keywords or identifiers; is case insensitivity ever appropriate here? I would seriously reconsider the use of case-insensitivity.

Last but not least: As a beginner, it's important always to usewarnings; and usestrict; and avoid global variables.