This is my first post to the monastery, so please take it easy on me :) I use Perl mostly as a hobby, and I have been slowly learning by reading various books and lurking around here. So, I think I finally have a question worth asking (most of the time a Super Search reveals that my question has already been answered). I have started to use Moose for anything object oriented and have found it to be very nice.

I recently wrote an application that creates a few thousand Moose objects. It seemed to run a bit slow so, I used Devel::DProf to help locate the bottleneck in my code. I was convinced that one of my methods would be involved. To my surprise, it seemed to be the combination of using Moose::Util::TypeConstraints with Regexp::Common

I have tried to reduce this down to a simple case based on the example given in Moose::Cookbook::Basics::Recipe4.

If I create the subtype using the technique in the recipe:

subtype USZipCodeA
      => as Value
      => where {
          /^$RE{zip}{US}{-extended => 'allow'}$/          
      };
[download]

my $zip_re = qr/^$RE{zip}{US}{-extended => 'allow'}$/;

  subtype USZipCodeB
      => as Value
      => where {
            $_ =~ $zip_re;         
      };
[download]

package AddressA;
 
use Moose;
use Moose::Util::TypeConstraints;

use Regexp::Common 'zip';
      
  subtype USZipCodeA
      => as Value
      => where {
          /^$RE{zip}{US}{-extended => 'allow'}$/          
      };

has 'zip_code' => (is => 'rw', isa => 'USZipCodeA');

1;
[download]

package AddressB;
 
use Moose;
use Moose::Util::TypeConstraints;

use Regexp::Common 'zip';

my $zip_re = qr/^$RE{zip}{US}{-extended => 'allow'}$/;

  subtype USZipCodeB
      => as Value
      => where {
            $_ =~ $zip_re;         
      };

has 'zip_code' => (is => 'rw', isa => 'USZipCodeB');

1;
[download]

#!/usr/bin/perl

use strict;
use warnings;
use Benchmark qw(cmpthese);
use AddressA;
use AddressB;

my $zip = 12345;

cmpthese (-5,
                {
                 A => sub { AddressA->new(zip_code => $zip);},
                 B => sub { AddressB->new(zip_code => $zip);}
                }
         );

exit;
[download]

I'm using the following:

• Windows XP
• perl -v output: This is perl, v5.10.0 built for MSWin32-x86-multi-thread (Strawberry Perl)
• Moose v0.55
• Regexp::Common v2.122

    Rate    A    B
A 2976/s   -- -43%
B 5187/s  74%   --
[download]

I made a couple simple programs to create 10,000 objects using either technique. Then I used Devel::DProf to profile the code. The two highest values of 'ExclSec' for the creation of 10,000 AddressA objects were from these methods:

Regexp::Common::_decache
Regexp::Common::new
[download]

Class::MOP::Instance::new
Class::MOP::Instance::set_slot_value
[download]

I just tried this out on Mac OS X with perl 5.8.8 (macports) and the results of the comparison are (same Moose and Regexp::Common versions)

    Rate    A    B
A 2955/s   --  -7%
B 3174/s   7%   --
[download]

My question has a few parts:

• Is this slowdown expected behavior?
• Am I doing something wrong?
• Should I suggest that the Cookbook Recipe be updated?