Doubly

 view release on metacpan or  search on metacpan

lib/Doubly.pm  view on Meta::CPAN

			$linked->is_start;
			$linked->add(789);
			$linked->destroy;
		},
	});

	cmpthese $r;

Docker perl:5.38-threaded - Threaded environment (where only Doubly is truly safe):

	Benchmark: timing 10000 iterations of Doubly, Doubly::Linked, Doubly::Linked::PP, Doubly::Pointer...
	    Doubly: 0.704658 wallclock secs ( 0.70 usr +  0.00 sys =  0.70 CPU) @ 14285.71/s (n=10000)
	Doubly::Linked: 4.71918 wallclock secs ( 3.10 usr +  1.61 sys =  4.71 CPU) @ 2123.14/s (n=10000)
	Doubly::Linked::PP: 12.1816 wallclock secs (10.76 usr +  1.39 sys = 12.15 CPU) @ 823.05/s (n=10000)
	Doubly::Pointer: 0.778561 wallclock secs ( 0.77 usr +  0.00 sys =  0.77 CPU) @ 12987.01/s (n=10000)
			      Rate Doubly::Linked::PP Doubly::Linked Doubly::Pointer Doubly
	Doubly::Linked::PP   823/s                 --           -61%            -94%   -94%
	Doubly::Linked      2123/s               158%             --            -84%   -85%
	Doubly::Pointer    12987/s              1478%           512%              --    -9%
	Doubly             14286/s              1636%           573%             10%     --

Docker perl:5.38 - None threaded environment:

	Benchmark: timing 10000 iterations of Doubly, Doubly::Linked, Doubly::Linked::PP, Doubly::Pointer...
	    Doubly: 0.712633 wallclock secs ( 0.70 usr +  0.01 sys =  0.71 CPU) @ 14084.51/s (n=10000)
	Doubly::Linked: 16.0794 wallclock secs ( 4.05 usr +  5.75 sys =  9.80 CPU) @ 1020.41/s (n=10000)
	Doubly::Linked::PP: 13.0293 wallclock secs (11.73 usr +  1.27 sys = 13.00 CPU) @ 769.23/s (n=10000)
	Doubly::Pointer: 0.775681 wallclock secs ( 0.77 usr +  0.00 sys =  0.77 CPU) @ 12987.01/s (n=10000)
			      Rate Doubly::Linked::PP Doubly::Linked Doubly::Pointer Doubly
	Doubly::Linked::PP   769/s                 --           -25%            -94%   -95%
	Doubly::Linked      1020/s                33%             --            -92%   -93%
	Doubly::Pointer    12987/s              1588%          1173%              --    -8%
	Doubly             14085/s              1731%          1280%              8%     --

lib/Doubly/Pointer.pm  view on Meta::CPAN

			$linked = $linked->start;
			$linked->is_start;
			$linked->add(789);
		}

	});

	cmpthese $r;


	Benchmark: timing 100000 iterations of Doubly, Doubly::Linked, Doubly::Linked::PP...
	    Doubly: 2.70105 wallclock secs ( 2.43 usr +  0.23 sys =  2.66 CPU) @ 37593.98/s (n=100000)
	Doubly::Linked: 25.6334 wallclock secs (23.54 usr +  1.88 sys = 25.42 CPU) @ 3933.91/s (n=100000)
	Doubly::Linked::PP: 190.169 wallclock secs (189.59 usr +  0.19 sys = 189.78 CPU) @ 526.93/s (n=100000)
			      Rate Doubly::Linked::PP   Doubly::Linked            Doubly
	Doubly::Linked::PP   527/s                 --             -87%              -99%
	Doubly::Linked      3934/s               647%               --              -90%
	Doubly             37594/s              7035%             856%                --


=head1 AUTHOR

t/22-memory-leaks.t  view on Meta::CPAN

    plan tests => 1;
    no_leaks_ok(sub {
        for (1..100) {
            my $list = Doubly->new();
            $list->bulk_add(1, 2, 3, 4, 5);
            $list->destroy();
        }
    }, 'bulk_add does not leak');
};

# Test 16: Verify no accumulating leaks over many iterations
subtest 'no accumulating leaks' => sub {
    plan tests => 1;
    my $baseline = leaked_count(sub {
        for (1..10) {
            my $list = Doubly->new($_);
            $list->add($_*2) for 1..5;
            $list->destroy();
        }
    });
    
    my $larger = leaked_count(sub {
        for (1..100) {
            my $list = Doubly->new($_);
            $list->add($_*2) for 1..5;
            $list->destroy();
        }
    });
    
    my $ratio = $larger / ($baseline || 1);
    ok($ratio < 2, "leak count does not scale with iterations (ratio: $ratio)")
        or diag("baseline=$baseline, larger=$larger - indicates per-iteration leak");
};

done_testing();

t/72-pointer-memory-leaks.t  view on Meta::CPAN

    plan tests => 1;
    no_leaks_ok(sub {
        for (1..100) {
            my $list = Doubly::Pointer->new();
            $list->bulk_add(1, 2, 3, 4, 5);
            $list->destroy();
        }
    }, 'bulk_add does not leak');
};

# Test 16: Verify no accumulating leaks over many iterations
subtest 'no accumulating leaks' => sub {
    plan tests => 1;
    my $baseline = leaked_count(sub {
        for (1..10) {
            my $list = Doubly::Pointer->new($_);
            $list->add($_*2) for 1..5;
            $list->destroy();
        }
    });
    
    my $larger = leaked_count(sub {
        for (1..100) {
            my $list = Doubly::Pointer->new($_);
            $list->add($_*2) for 1..5;
            $list->destroy();
        }
    });
    
    my $ratio = $larger / ($baseline || 1);
    ok($ratio < 2, "leak count does not scale with iterations (ratio: $ratio)")
        or diag("baseline=$baseline, larger=$larger - indicates per-iteration leak");
};

done_testing();