10,000 times is not that much, in itself. Could it be that your subroutine has many parameters / return values? If so, simply rewriting it to pass by reference may speed things up considerably.

Currently, there's no good way to inline subroutines. In the future it may be possible.

If you can post part of the code, perhaps someone can suggest a way to do the same thing more efficiently.

(By the way, it's Perl, never PERL.)

WARNING - THIS SUGGESTION IS FRAUGHT WITH PERIL
Use this at your own risk. I am not responsible if you get fired.

You could unroll the function call stack (using goto and dynamic labels) and manipulate it yourself. This is ... very poor form, requires a book of comments, and is about as fragile as bone china. But, it is possible.

Let's say you have:

my $value = foo( 3, 4, 5 );

for ( 1 .. 10_000 ) {
    # Blahblah
    my $inside_value = foo( $_, 1, 2 );
    # Yadda, yadda, yadda
}

my $other_value = foo( 7, 8, 9 );

sub foo {
    my ($first, @args) = @_;
    do_something( $first );
    return do_something_else( @args );
}
[download]

Note: I am not advocating this type of code nor am I suggesting that you won't be hunted down like the fool you are if you implement this code and quit the next day. I'm saying that you can inline functions in Perl that are called from outside the loop and here is how.

Is there any way in PERL to resolve the above issue

You could always transfer the problem from runtime to compile time by using a source filter to provide an inline/macro facility. In use it would look something like this:

#! perl -slw
use strict;
use Macro;

MACRO sub fred {
    my( $a, $b, $c ) = @_;
    return ( $a + $b ) * $c;
}
ENDMACRO

my( $x, $y, $z ) = ( 1, 4, 7 );
print fred( $x, $y, $z );

for my $x ( 1 .. 10 ) {
    print fred( $x, $y, $z );
}
__END__
P:\test>435608
35
35
42
49
56
63
70
77
84
91
98
[download]

And the actual code (whitespace reduced) that would be executed is:

my( $x, $y, $z ) = ( 1, 4, 7 );
print do{
    our $MACRO_RETURN;
    local $MACRO_RETURN;
    $MACRO_RETURN = ( $x + $y ) * $z; goto MACRO_RETURN;;
    MACRO_RETURN: $MACRO_RETURN
};

for my $x ( 1 .. 10 ) {
        print do{
            our $MACRO_RETURN;
            local $MACRO_RETURN;
            $MACRO_RETURN = ( $x + $y ) * $z; goto MACRO_RETURN;;
            MACRO_RETURN: $MACRO_RETURN
       };
}
[download]

This is only a demonstration (with flaws) of the possibilities, and far from fully thought through, but it has some merits relative to the alternatives offered:

The package Macro:

package Macro;
use strict;
use warnings;
use Filter::Simple;

my %macros;

FILTER_ONLY 
executable => sub { 
    while( 
        s[
            MACRO\s+
            sub\s+
            (\w+)\s+
            \{\s+
            my\s*\( \s* ( [^\)]+? ) \s* \)\s* =\s* \@_;\s+
            ( .*? )
            \} \s* 
            ENDMACRO
        ][]xsmg 
    ) {
        my( $name, $args, $body ) = ( $1, $2, $3 );
        $body =~ s[[\r\n]+][]g;
        $macros{ $name } = [ 
            [ split ',\s*', $args ], 
            "do{
                our \$MACRO_RETURN;
                local \$MACRO_RETURN;
                $body; 
                MACRO_RETURN: \$MACRO_RETURN 
            }" 
        ];
    }
    
    for my $macro ( keys %macros ) {
        s[
            $macro\( \s* ( [^\)]+ ) \s* \)
        ]{
            my @actual = split '\s*,\s*', $1;
            my @formal = @{ $macros{ $macro }[ 0 ] };
            my $do = $macros{ $macro }[ 1 ];
            my %substs; @substs{ @formal } = @actual;
            $do =~ s[([\$][\w]+)]{ 
                       exists $substs{ $1 } ? $substs{ $1 } : $1 
                  }eg;
            $do =~ s[return\s*(.*?)\s*;]
                       [\$MACRO_RETURN = $1; goto MACRO_RETURN;]g;
            $do;
        }xeg;
    }
    $_;
};


1;
[download]

Source filters are either condemned as evil, hailed as saviours, or sometimes both as people transition from one state of Perlish grace to another.