in reply to Re^7: bit by overhead
in thread bit by overhead

Perhaps I'm missing something here: 
sub from_cache2 {
    my $ticker = shift;
    return [ map unpack("A10FFFFL", $_), $cache2{$ticker} ];
}

[download]
Shouldn't that be: 

sub from_cache {
    my $ticker = shift;
    my $ref = $data_cache{$ticker};
    return [ map [unpack("A10FFFFL", $_)], @$ref ];
}

[download]
The other way doesn't seem to work, since map wants an array, not an array reference, and since the data is stored in a multidimensional array, shouldn't each row be pushed as a reference?

Replies are listed 'Best First'.
Re^9: bit by overhead
by BrowserUk (Patriarch) on Jan 07, 2011 at 16:40 UTC

    You are correct, that is a bug in the benchmark. I'd code it this way: 

    sub from_cache2 {
    my $ticker = shift;
    return [ map unpack("A10FFFFL", $_), @{ $cache2{$ticker} } ];
}

    [download]

    Unfortunately, it takes the edge off the speedup :( 

    C:\test>880868-2
       Rate orig mod1
orig 8.01/s   -- -36%
mod1 12.4/s  55%   --

    [download]

    Still worth having but less so. If you are the OP of this thread, then you should seriously consider the ideas in the last paragraph of my previous post.

    Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
    "Science is about questioning the status quo. Questioning authority".
    In the absence of evidence, opinion is indistinguishable from prejudice.
[reply]
[d/l]
[select]
      I have indeed tried your suggestion: 
      
sub to_cache {
    my( $ticker, $data ) = @_;

    $data_cache{$ticker} = pack "(A10FFFFL)*", map @$_, @$data;
}

sub from_cache {
    my $ticker = shift;
    return [
        map[
            unpack("A10FFFFL", $_)
        ], unpack '(A[A10FFFFL])*', $data_cache{$ticker}
        ];
}

      [download]
      But it doesn't seem to be working. Is this code assuming that the packed rows are stored together as a single scalar?
[reply]
[d/l]

        That code comes from Re^9: bit by overhead and is identified as being slower than this:

        my %cache2;
sub to_cache2 {
    my( $ticker, $data ) = @_;

    $cache2{$ticker} = [ map pack("A10FFFFL", @$_), @$data ];
}

sub from_cache2 {
    my $ticker = shift;
    return [ map unpack("A10FFFFL", $_), @{ $cache2{$ticker} } ];
}

        [download]

        which you should use instead.

        The suggestions I was referring to are:

        Do you use all 251 sets of 6 values every time you retrieve the data from the cache?

        The gist of where I'm going with this, is that if you don't use them all each time, you might be better to use a two level cache so that you unpack less data each time.

        Or, if you do use all the value for each ticker each time, then could you not cache the results of whatever you do with them, rather than the raw data itself?

        Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
        "Science is about questioning the status quo. Questioning authority".
        In the absence of evidence, opinion is indistinguishable from prejudice.
[reply]
[d/l]

In Section Seekers of Perl Wisdom