Your code contains a problem if you have "overlap".in your source or target variable names. You should create one large regular expression that willsearch and replace the names in one go to avoid circles/sequences of replacing names instead of looping over your replacements per line:

my $re = join '\bŠ\b', reverse keys %mapper;
while (<IN>){
    s/\b($re)\b/$mapper{$1}/gei;
};
[download]

There are modules for conveniently building such regular expressions in a more optimal way, like Regex::PreSuf

I thought \b \b pairs will do the trick since they will match word boundaries. FYI, my mapping file has no redundant entries. Please correct me if I am wrong

You're correct with the \b word boundaries. The problem case I am thinking of is the following renaming setup:

%mapper = (
    foo => 'zap',
    zap => 'foo',
)
[download]

Here, foo will be replaced by "zap" in your loop and then again by "foo". But if that can't happen, all you'll gain with the large regex is speed ;)

Or grinder's Regexp::Assemble. :-)

HTH,

planetscape

open(MAP, "<$new_name_map_file");
while (<MAP>) {
     chomp;
     tr/A-Z/a-z/;
     @map_line = split (/\t/);
     $mapper{$map_line[0]} = $map_line[1];
}
close(MAP);

my $sub = "sub { ";
for my $name (sort keys %mapper) {
  my $qname = quotemeta $name;
  my $qrepl =  quotemeta $mapper{$name};
  $sub .= "s{\b$qname\b}{$qrepl}g; ";
}
$sub .= "}";
$sub = eval $sub;
die if $@;

open(IN, "<input_file");
open(OUT, ">input_file.new");
while (<IN>) {
print "%";
     tr/A-Z/a-z/;
     $sub->();
     print OUT "$_";
}
close(IN);
clse(OUT);
[download]

Isn't the cost of calling a sub significantly higher than running the same code in the loop? It's always been my policy to eliminate subs were possible when absolute speed is required. (But I could be wrong).

well, calling subs in Perl is not as expensive as people usually thing...

use Benchmark 'cmpthese';

my $a = 'foo bar doz' x 100;
$a .= ' hello '.$a;

my $sub = sub {
  /\bhello\b/; /\bhello\b/; /\bhello\b/; /\bhello\b/;
  /\bhello\b/; /\bhello\b/; /\bhello\b/; /\bhello\b/;
};

cmpthese(-3, { loop => sub {
                 for (($a) x 10) {
                   for my $i (1..8) {
                     /\bhello\b/;
                   }
                 }
               },
               sub => sub {
                 for (($a) x 10) {
                   $sub->()
                 }
               },
               inline => sub {
                 for (($a) x 10) {
                   /\bhello\b/; /\bhello\b/; /\bhello\b/; /\bhello\b/;
                   /\bhello\b/; /\bhello\b/; /\bhello\b/; /\bhello\b/;
                 }
               }
[download]

outputs...

         Rate   loop    sub inline
loop   4157/s     --    -5%   -16%
sub    4363/s     5%     --   -12%
inline 4943/s    19%    13%     --
[download]

and anyway, it's easy to modify my code to remove the subroutine call from the loop just moving the loop inside the sub:

open(MAP, "<$new_name_map_file");
while (<MAP>) {
     chomp;
     tr/A-Z/a-z/;
     @map_line = split (/\t/);
     $mapper{$map_line[0]} = $map_line[1];
}
close(MAP);

my $sub = <<'EOS';
sub {
  while (<IN>) {
  print "%";
  tr/A-Z/a-z/;
EOS

for my $name (sort keys %mapper) {
  my $qname = quotemeta $name;
  my $qrepl =  quotemeta $mapper{$name};
  $sub .= "s{\b$qname\b}{$qrepl}g;\n";
}

$sub .= <<'EOS'
    print OUT $_;
  }
}
EOS

$sub = eval $sub;
die if $@;

open(IN, "<input_file");
open(OUT, ">input_file.new");
$sub->();
close(IN);
clse(OUT);
[download]

Hi, If I understood your question correctly, try this & see the Benchmark,

#!/usr/bin/perl

use strict;
use warnings;

use Benchmark 'cmpthese';

cmpthese(-1, {
    method1  =>  '&yours',
    method2  =>  '&new_one',
});


sub yours{

my %mapper;
open(MAP, "<map.ini");
while (<MAP>) {
     chomp;
     tr/A-Z/a-z/;
     my @map_line = split (/\t/);
     $mapper{$map_line[0]} = $map_line[1];
}
close(MAP);
 
open(IN, "<input1.txt");
open(OUT, ">input_new.txt");
while (<IN>) {
#print "%";
     tr/A-Z/a-z/;
     foreach my $key (sort keys %mapper) {
        s/\b$key\b/$mapper{$key}/g;
     }
     print OUT "$_";
}
close(IN);
close(OUT);

}

sub new_one{

open(MAP, "map.ini");
my $map = do{local $/;<MAP>};
close(MAP);
my %mapper;
$map = lc($map);
%mapper = map{split/\t/,$_} split(/\n/, $map);

 
open(IN, "input1.txt");
my $input = do{local $/;<IN>};
close(IN);

open(OUT, ">input_new.txt");

$input = lc($input);

foreach my $key (sort keys %mapper) {
  $input =~ s/\b$key\b/$mapper{$key}/g;
}

print OUT $input;
close(OUT);
}

__END__
          Rate method1 method2
method1  908/s      --    -13%
method2 1050/s     16%      --
[download]

I have check with less number of lines file only. You can check with your input.

Come to think of it, why are you sorting the keys?

Hey, you're right!

I was about to example a case for partial keys getting substituted, but then I realized the keys are wrapped in word boundries, so there's no chance of partial key substitution, and no reason to sort.

Drop the sort and save some time.

You are right on unnecessary sorting. I copied over that part from somewhere and wasn't aware of what I was doing...