Slash Boxes
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

use Perl Log In

Log In

[ Create a new account ]

Alias (5735)

  (email not shown publicly)

Journal of Alias (5735)

Monday September 07, 2009
11:41 AM

Improvement Needed - Perl needs better benchmarking

[ #39595 ]

My previous post on Moose contained a fairly typical benchmark, used in a fairly typical way.

# Object::Tiny vs Object::Tiny::XS vs Moose::Tiny
# Note that I had to do __PACKAGE__->meta->make_immutable to
# the Moose::Tiny class, because it doesn't to so itself.
# Based on the following Object::Tiny class.
use Object::Tiny qw{
                Rate moose_all    xs_all tiny_all moose_none tiny_none   xs_none
moose_all    82795/s        --      -54%     -54%       -72%      -90%      -92%
xs_all      178763/s      116%        --      -1%       -39%      -79%      -83%
tiny_all    179759/s      117%        1%       --       -39%      -79%      -83%
moose_none  294985/s      256%       65%      64%         --      -65%      -72%
tiny_none   842460/s      918%      371%     369%       186%        --      -21%
xs_none    1066098/s     1188%      496%     493%       261%       27%        --
            (warning: too few iterations for a reliable count)
               Rate moose_get  tiny_get    xs_get
moose_get 1730104/s        --      -11%      -32%
tiny_get  1937984/s       12%        --      -24%
xs_get    2557545/s       48%       32%        --

Now, I'm not showing this again to rub in that Moose is slower than Class::XSAccessor, because even as recently as today there XS acceleration code about to land and start making up the difference.

The problem here is that this benchmark isn't tangible.

You can't reuse it. You can't identify it. You can't package it or upload it to the CPAN. The closest you can get is to just randomly drop the raw script somewhere and hope for the best.

And god forbid you want a benchmark that will try to establish theta or O(), a benchmark that run itself across a set or a range of n, and produce a chart, or auto-discover O(). Or vary over multiple variables.

A benchmark with encoded results, in the same way that TAP is encoding of test results. A benchmark I can save in a /bm/ directory, the same way that I can save my tests in a /t/ directory.

So where is it? Where is my Class::Benchmark? My Benchmark::Archive that uploads to my Benchmark::Smolder?

Dear LazyWeb.

Can you make us a benchmark stack that is as good as our testing stack?


The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
More | Login | Reply
Loading... please wait.
  • I wonder if your post today was inspired by what I wrote in reply [] to your last post or we're just on the same wavelength with this. :)

    At YAPC::NA this year I did a lightning talk on a web-testing framework I built for a client*. The main topic was just that the tests were all data-driven, and because of that I gained a pile of great functionality, not least of which was the ability to turn my test suite into a benchmarking suite seamlessly.

    By running via prove or directly, each script was a set of unit
    • It's mostly because of some issues at work.

      We've got ourselves a shiny new load testing environment, which is useful for catching major performance regressions.

      But it doesn't easily catch slowdowns in strange and unusual places. Stuff beyond just the "scrape the website" tests, things that only run in the backend and do a lot of heavy lifting.

      What we'd like is a way to have a benchmark suite that sits in the project, runs nightly with the smoke tests, and logs to a database so that we can do performance tre

    • I think Alias addressed most of my would-be response, so I'll limit my comments to:

      All of the efforts I've personally seen to turn unit tests into benchmarks ended up being more of a benchmark of perl's compiler than anything else.  Unit tests tend to focus on tiny portions of the overall code, and test just them; they tend to not do unnecessary looping.  As such, the naive 'turn them into benchmarks' puts the loop around them, and unfortunately either re-evals them, or re-forks and evals them.


      • Indeed, in this case the test harness *is* testing on a more functional/integration level. As we refactor the code that runs the client's site, we want to ensure that we neither break any part of the site nor slow it down.

        Still, using this type of technique has made me wonder if there is a good way of encouraging benchmarks of perl modules by piggy-backing on the tests.

        An example of this can be found in the test suite for Sort::Maker. [] (It was actually Uri's advice to

      • One of the other problems we have is that because our system is enormous, with many links to external systems and pre-compiled caches, it takes two to three orders of magnitude more time to set up for a functional test than it does to run the actual tests.

        I think any sufficiently robust solution is going to need a way to factor that out, and this is a problem for the test script overloading approach.

        The test scripts would need a way to isolate the code you are interested in from the code you are running to

  • a few members of (including me) are working on a benchmarking framework with the intent of being able to build nice charts and graphs to show rakudo getting faster and to compare it to perl5. We're using the euler problem set just as an example for now but if you have specific specs that you would like us to hit I would love to hear them. []

    • Apart from a 120 line .pm file with very little in it, I'm not seeing much there in the way of frameworky'ness.

      Do you have a more accurate URL?