Skip to main content

Perl Floating Point-Multiplication Benchmark

I was worried whether I was making basic errors in testing the Perl version, so I decided to use the Benchmark module to get the numbers. I copied the matmult.pl file and added use Benchmark ':all' to the header of the file. The main() routine got changed to :

    my $time = $ARGV[0] || 5;
    my %vars = (   2 => [],
                   5 => [],
                  10 => [],
                  32 => [],
                 100 => [],
    );
    for my $size ( keys %vars ) {
       my $filestub = q{F_} . $size . q{x} . $size . q{.};
       $vars{$size}[0] = readMatrix( $filestub . '1' );
       $vars{$size}[1] = readMatrix( $filestub . '2' );
    }
    
    say "Processing for $time seconds each size ",
        "will take @{[5 * $time]} seconds."; 
    say scalar localtime;
    cmpthese( -$time, {
       'F_2x2'     => sub { matmult( $vars{2}[0],
                                        $vars{2}[1]); },
       'F_5x5'     => sub { matmult( $vars{5}[0],
                                        $vars{5}[1]); },
       'F_10x10'   => sub { matmult( $vars{10}[0],  
                                        $vars{10}[1]); },
       'F_32x32'   => sub { matmult( $vars{32}[0],  
                                        $vars{32}[1]); },
       'F_100x100' => sub { matmult( $vars{100}[0], 
                                        $vars{100}[1]); },
       });
    say scalar localtime;

The user can specify how long each variant should be run, with a default of 5 seconds for each size if no arg is provided.

-➤   perl ./benchmark.pl 2
Processing for 2 seconds each size will take 10 seconds.
Mon Jun 15 17:11:08 2015
              Rate F_100x100   F_32x32   F_10x10     F_5x5     F_2x2
F_100x100   5.39/s        --      -97%     -100%     -100%     -100%
F_32x32      163/s     2931%        --      -97%     -100%     -100%
F_10x10     4909/s    90934%     2904%        --      -85%      -98%
F_5x5      32731/s   606904%    19929%      567%        --      -88%
F_2x2     264660/s  4908131%   161856%     5292%      709%        --
Mon Jun 15 17:11:22 2015

Adjusting for the number of multiplications involved in each size of matrix --- 8 for the 2x2 up to 1,000,000 for the 100x100 --- produces results very similar to what we've already seen ( millions of multiplications per second):

perl -E'say  "100 => 5.36";
        say  "32  => ", 32000 * 154 / 10**6;
        say  "20  => ", 1000 * 4904 / 10**6;
        say  "5   => ", 125 * 32767 / 10**6;
        say  "2   => ", 8 * 263472  / 10**6; 
       '

100 => 5.39
32  => 5.216
20  => 4.909
5   => 4.091375
2   => 2.11728
Rerunning the benchmarks with integer matrices and use integer enabled generated insignificantly, fractionally better numbers; though I wonder if the pragma affected Benchmark's calculations.
Labels:

Comments

Joaquin Ferrero said…
Please, test PDL (Perl Data Language), after.
June 15, 2015 at 7:46 PM
Tom Legrady said…
Hi Joaquin - Yes, I'm aware of PDL, but I've never used it. I'll see how hard it is.
June 17, 2015 at 2:54 PM
Post a Comment

Popular posts from this blog

Perl5, Moxie and Enumurated Data Types

Moxie - a new object system for Perl5 Stevan Little created the Moose multiverse to upgrade the Perl 5 programming language's object-oriented system more in line with the wonderfull world of Perl 6. Unfortunately, it's grown into a bloated giant, which has inspired light-weight alternatives Moos, Moo, Mo, and others. Now he's trying to create a modern, efficient OO system that can become built into the language. I've seen a few of his presentations at YAPC (Yet Another Perl Conference, now known as TPC, The Perl Conference), among them ‎p5 mop final final v5 this is the last one i promise tar gz <. So I was delighted to recently see an announcement of the module Moxie, and decided to try implementing a card game. While the package provides some POD documentation about the main module, Moxie, it doesn't actually explain the enum package, Moxie::Enum. But delving into the tests directory reveals its secrets. Creating an Enum package Ranks { use
5 comments
Read more

BASH Matrix Multiplication

tl;dr Bash is not the language for math-intensive operations. REPS=$1; FILE_1=$2; FILE_2=$3 OUTFILENAME=$4; readonly COLS=`head -1 $FILE_1 | wc -w`; readonly ROWS=`cat $FILE_1 | wc -l`; # echo "rows is $ROWS; cols is $COLS" if [[ $ROWS != $COLS ]]; then echo "Expecting square matrices, " \ "but rows = $ROWS, cols = $COLS\n"; exit 1; fi # -------------------------------------------------- # SUBROUTINES # function outputMatrix() { local matrixname=$1; local matrix; local elem; echo "matrix is '$matrixname'."; eval matrix=\( \${${matrixname}[@]} \); local i=0; for elem in "${matrix[@]}"; do echo -n "$elem "; if (( ++i == $COLS )); then echo ''; i=0; fi done } function multiply() { declare -a product; local M=$1 N=$2; local i j k idx1 idx2 idx3; for ((i=0; i < $ROWS; i++ )); do for ((j=0; j<$COLS; j++)); do
Post a Comment
Read more

Creating Perl5 Objects with Moxie

Having in the previous article prepared data types for car suits and card ranks, I can now combine them to provide a playing card class, using Stevan Little's Moxie module (version 0.04, so definitely early days.) The goal is to provide an object-oriented paradigm to the Perl 5 programming language which is more sophisticated, more powerful and less verbose than manually bless() -ing hashes. To achieve that goal it needs to be faster and light-weight compared to Moose. Currently, Moxie.pm and and MOP.pm are add-on modules, but eventually, when they are more complete, when the wrinkles have been ironed out, and when they have gained acceptance and a community of users, they might be merged into the Perl core. One significant feature of Moxie is that it reduces boilerplate code. You don't have to specify warnigns or strict . As well, the features or the perl you are using are enabled, among them say , state , signatures , and post_deref . A Simple Moxie Class packag
Post a Comment
Read more