Basically, it uses the "Pass #" as a record delimiter.

use strict;
use warnings;

   my $file = "data1.txt";
   local $/ = "\nPass #";
   open my $fh, '<', $file or die "Can't open $file: $!";
   while ( <$fh>){
        print join(",",
              m/(\d+).*?
                    ^Elapsed\ Time\s+:\s+([\d\.]+).*?
                    ^CPU\ Time\s+:\s+([\d\.]+).*?
                    ^Virtual\ memory\ size\s+:\s+([\d\.]+).*?
                    ^Resident\ set\ size\s+:\s+([\d\.]+).*?
                    ^Major\ page\ faults\s+:\s+([\d\.]+)
                   /msgcx)
           , "\n";
   }
   close $fh;
[download]

That said, I would modify your slurp function to look like:

sub slurp {
   my $file = shift;
   local $/;
   open my $fh, '<', $file or die "Can't open $file: $!";
   return <$fh>;
}
[download]

The big changes here are swapping to indirect filehandles and 3 argument open. Indirect filehandles are guaranteed not to collide with a previously existing file handle and will automatically close out once the variable goes out of scope. See Indirect Filehandles in perlopentut for more virtues. 3-argument open doesn't really matter in this case, but it protects you from some malicious vectors so it's usually considered a good habit to get into. I removed the = undef from your $/ localization, since that is redundant. I explicitly named the input parameter and explicitly returned to make intent more obvious to the casual reader.

Since you are outputting CSV, I would also likely use an explicit CSV module, such as Text::CSV. Again, it doesn't matter in this case, but it handles escaping which may matter to you in the future.

Finally, rather than using a while with a long multiline regex, I'd probably either do a streaming parser or a split. The longer the regex, the easier it is to break and the harder it is to fix. But, as far as they go, yours is pretty clean.

Here's another way. It may be a better way. I've used Tie::File so that, even with very large input files, you won't run into any memory issues.

use strict;
use warnings;

use Tie::File;

my $infile = q{noa.txt};

my $wanted_re = qr{
    \A
    (?>
        (
            Pass \s \# |
            Elapsed \s Time \s+ : \s+ |
            CPU \s Time \s+ : \s+ |
            Virtual \s memory \s size \s+ : \s+ |
            Resident \s set \s size \s+ : \s+ |
            Major \s page \s faults \s+ : \s+
        )
        (
            [\d.]+
        )
    )
}msx;

my $last_stat_re = qr{ \A Major \s page \s faults \s+ : \s+ \z }msx;

tie my @indata, q{Tie::File}, $infile or die $!;

for my $line (@indata) {
    next if $line !~ $wanted_re;
    print $2;
    print $1 =~ $last_stat_re ? qq{\n} : q{, };
}

untie @indata;
[download]

I dummied up some additional input to what you provided:

$ cat noa.txt
...
Pass #123 ...
...
Elapsed Time : 1753.2 sec
CPU Time   :  753.2 sec
...
Virtual memory size  :  4472.6 MB
Resident set size    :  4362 MB
...
Major page faults  :  7153
...
Pass #the salt
...
Pass #124 ...
...
Elapsed Time : 9753.2 sec
CPU Time   :  953.2 sec
...
Virtual memory size  :  9472.6 MB
Resident Evil
Resident set size    :  9362 MB
...
Major page faults  :  9153
...
[download]

Here's the output:

$ noa.pl
123, 1753.2, 753.2, 4472.6, 4362, 7153
124, 9753.2, 953.2, 9472.6, 9362, 9153
[download]

While it might be overkill in this case, as an aside I would mention Parse::RecDescent which is an excellent tool to use for “complicated” inputs that exhibit a predictable structure.   It has a bit of a learning curve associated with it, but it really “moves the freight” in the right situations.   I’ve asked it to do things that were deserving of overtime and maybe a disability claim, and it just did ’em.