view release on metacpan or  search on metacpan

t/benchmark.pl  view on Meta::CPAN

        is_async       => $is_async,
        query_count    => $query_count,
        elapsed        => $elapsed,
        throughput     => $throughput,
        responsiveness => $responsiveness,
        speedup        => $is_async ? ($baseline_time / $elapsed) : 1,
    };
}

sub print_summary {
    my @results = @_;

    print "\n" . "-" x 70 . "\n";
    print "SUMMARY\n";
    print "-" x 70 . "\n";

    my @async_results = grep {  $_->{is_async} } @results;
    my @sync_results  = grep { !$_->{is_async} } @results;

    if (@async_results == 0 || @sync_results == 0) {
        print "No results to summarize.\n";
        exit;
    }

    my $avg_speedup        = 0;
    my $max_speedup        = 0;
    my $avg_responsiveness = 0;

    foreach my $result (@async_results) {
        $avg_speedup        += $result->{speedup};
        $max_speedup         = $result->{speedup}
            if $result->{speedup} > $max_speedup;
        $avg_responsiveness += $result->{responsiveness};
    }

    $avg_speedup        /= scalar @async_results;
    $avg_responsiveness /= scalar @async_results;

    my $total_sync_time  = 0;
    my $total_async_time = 0;

    $total_sync_time  += $_->{elapsed} for @sync_results;
    $total_async_time += $_->{elapsed} for @async_results;

    my $total_time_saved  = $total_sync_time - $total_async_time;
    my $total_improvement = $total_sync_time > 0
                            ? ($total_time_saved / $total_sync_time * 100)
                            : 0;

    printf "Across all %d test runs:\n", scalar(@results) / 2;
    printf "\nPerformance Results:\n";
    printf "  - Average Speedup:     %.2fx faster\n", $avg_speedup;
    printf "  - Maximum Speedup:     %.2fx faster\n", $max_speedup;
    printf "  - Total Time (Sync):   %.4f seconds\n", $total_sync_time;
    printf "  - Total Time (Async):  %.4f seconds\n", $total_async_time;
    printf "  - Time Saved:          %.4f seconds (%.1f%% improvement)\n",
        $total_time_saved, $total_improvement;

    printf "\nEvent Loop Health:\n";
    printf "  - Average Responsiveness: %.1f%%\n", $avg_responsiveness;
    printf "  - Sequential Blocking:    0.0%% (completely blocked)\n";

    print "\n What This Means:\n";
    print "  - TRUE parallel query execution across network connections\n";

    if ($avg_speedup > 50) {
        printf "  - Exceptional performance: %.0fx faster with worker pool\n", $avg_speedup;
        print "  - Worker process caching and connection reuse is highly effective\n";
    }
    elsif ($avg_speedup > 2) {
        printf "  - Strong performance: %.1fx faster with parallelism\n", $avg_speedup;
    }
    else {
        printf "  - Similar speed (%.1fx), but with %.1f%% event loop responsiveness\n",
            $avg_speedup, $avg_responsiveness;
    }

    print "  - Non-blocking event loop maintains application responsiveness\n";
    print "  - Better scalability as query count increases\n";

    if ($max_speedup > 100) {
        print "\nKey Insight: Worker pool caching delivered exceptional results!\n";
        print "After warm-up, persistent workers with cached connections and\n";
        print "prepared statements achieved extraordinary parallel throughput.\n";
    } elsif (@sync_results && $sync_results[0]->{query_count}) {
        my $avg_query_time = ($sync_results[0]->{elapsed} / $sync_results[0]->{query_count} * 1000);
        print "\nKey Insight: Network latency makes parallelism highly effective!\n";
        printf "Each query has ~%.1fms of overhead. With 4 workers, parallel\n", $avg_query_time;
        print "execution dramatically reduces total execution time.\n";
    }

    print "\n";
}