the purpose is to take a string, split it and store it in memory in such a way that you can pass it around and not need to split it again when receiving it in some other part of the program.

Then nothing will be as fast as constructing an array of arrays and passing a reference to it around. It could not be so.

Reading between the lines, your main problem seems to be that yoo are inisting on copying the subarrays to local named scalars each time before using them, rather than just using them in-situ.

Ie. You are doing something like:

sub process {
    my( $AoA,  $thingToProcess ) = @_;
    my( $v1, $v2, $v3, $v4, $v5, $v6, $v7 ) = @{ $AoA->[ $thingToProce
+ss ] };
    
    my( $r1, $r2, $r3, $r4, $r5, $r6, $r7 ) = ( ... some calculation(s
+) involving $v1, $v2, $v3, $v4, $v5, $v6, $v7 ... );

    @{ $AoA->[ $thingToProcess ] } = ( $r1, $r2, $r3, $r4, $r5, $r6, $
+r7 );
    return;
}
[download]

When you could be doing:

sub process {
    my( $AoA,  $thingToProcess ) = @_;

    $AoA->[ $thingToProcess ][ 3 ] =  $AoA->[ $thingToProcess ][ 1 ] *
+ $AoA->[ $thingToProcess ][ 2 ];
    ...
    return;
}
[download]

this is correct. however, writing each time $AoA->[ $thingToProcess ][ something ] could lead to hard to understand code.

also, if in the benchmarks, I use every time the "copying the subarrays to local named scalars" , these cancel themselves out, so basically the benchmark is still valid from this point of view, do you agree ?

But if you are going to be operating entirely within a program and not, e.g., storing to disk or transmitting to another computer over a network, why not just pass array or hash references (or object references) around? Again, I don't understand the application.

there's a big amount of strings that need to be processed(the split and store in some data structure thing), so storing it in a hash is not very optimal, turns out from the benchmarks an array would be faster. but I was expecting pack/unpack to be faster since it just packs it into a very simple datastructure and then unpacks it the same way, not needing so complex data structures such as hashes/arrays, instead.. it would just store everything as binary data. so that's why I was expecting that to be faster.