Do you want to add the numbers with the same keys?

#!/usr/bin/perl
use warnings;
use strict;

use Data::Dumper;

my %parent = (
    'file3232.ext' => {
        e => 0,
        k => '0.0031',
        i => '26.9',
        j => '33.0',
    }
);

my %returned = (
    'file3232.ext'  => {
        e => 0,
        k => '0.1040',
        i => '26.7',
        j => '14.6',
    }
);

for my $file (keys %returned) {
    for my $dataset (keys %{ $returned{$file} }) {
        $parent{$file}{$dataset} += $returned{$file}{$dataset};
    }
}

print Dumper \%parent;
[download]

Using Hash::Merge is the following: retrieve the most similar predefined behaviour, modify it to your needs (e.g. define the addition of scalar values) and use it to merge the hashes:

use Hash::Merge qw{ merge };

my $behavior = Hash::Merge::get_behavior_spec('STORAGE_PRECEDENT');
$behavior->{SCALAR}{SCALAR} = sub { $_[0] + $_[1] };
Hash::Merge::add_behavior_spec($behavior);

%parent = %{ merge(\%parent, \%returned) };

print Dumper \%parent;
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

I believe I understood what you were trying to do, but as I had not looked at Hash::Merge, I guess I went about things the long way. The sample code below ran a maximum of 65 children at a rate of a maximum of 5 simultaneous children. To simulate a workload, each generates a "filename" and picks 4 keys from a set of 8 possible, and generates a value for each key. When returned to the parent, the data is merged into a single HoH (level 1: filename; level 2: key), with a "total" of the keys is also generated. The data is then dumped at the end of the script. (Sample data run follows in <readmore></readmore>.)

#!/usr/bin/env perl

use strict;
use warnings;

use Data::Dumper;
use Getopt::Long;
use Parallel::ForkManager;

$Data::Dumper::Deepcopy = 1;
$Data::Dumper::Sortkeys = 1;

$| = 1;

my $max_child = 5;

my %parent_hash = ();

my $pm = Parallel::ForkManager->new($max_child);
$pm->run_on_finish(
    sub {
        my ( $pid, $exit_code, $process_ident, $exit_signal,
            $core_dump, $ds_ref, )
          = @_;
        if ( defined $ds_ref ) {
            foreach my $k1 ( sort { $a cmp $b } keys %{$ds_ref} )
            {
                foreach my $k2 ( keys %{ $ds_ref->{$k1} } ) {
                    $parent_hash{$k1}{$k2} +=
                      $ds_ref->{$k1}{$k2};
                    $parent_hash{total}{$k2} +=
                      $ds_ref->{$k1}{$k2};
                }
            }
        }
    },
);

foreach ( my $i = 0 ; $i < 128 ; $i += 8 ) {
    $pm->start and next;

    sleep $i;

    srand();    # So children have different random seeds

    my $child_hash;
    foreach my $j ( 0 .. int( rand() * 5 + 1 ) ) {
        my $fn = sprintf qq{file%05d.dat}, $i + $j;
        my @letters = ( 'a' .. 'h', );
        foreach my $k ( 0 .. 3 ) {
            my $l;
            while ( $l = int( rand() * scalar @letters ) ) {
                last
                  unless (
                    exists $child_hash->{$fn}{ $letters[$l] } );
            }
            my $m = int( rand() * 20 );
            $child_hash->{$fn}{ $letters[$l] } = $m;
        }
    }
    print Data::Dumper->Dump(
        [ \$i, \$child_hash, ],
        [qw( *i *child_hash )]
      ),
      qq{\n};
    $pm->finish( 0, $child_hash, );
}
$pm->wait_all_children;

print Data::Dumper->Dump( [ \%parent_hash, ],
    [qw( *parent_hash )] ),
  qq{\n};
[download]

Test run output:

Hope that helps.

%parent = ( %parent, %returned );
[download]