pperl 0.6.13#

2026-08-15 to 2026-08-18, 35 commits.

JIT and parallelization#

  • Element increments compile: $h{$key}++ and $a[$i]-- in a loop no longer keep it from compiling, also when the hash key is a computed string, as in $h{substr($seq, $i, $k)}++. The first increment of a new element creates it as an integer, as perl5 does. The Benchmarks Game’s k-nucleotide at its official input runs in 74.1 s instead of 99.2 s, 1.30 times as fast as perl5.

  • @_ element reads compile: $_[$j] and $_[0] inside a sub no longer keep its loops from compiling. The Benchmarks Game’s spectral-norm, whose inner loops read $_[$j], compiles them and at N=5,500 runs in 17.8 s instead of 61.8 s; perl5 takes 64.6 s.

  • Inlined subroutines: a loop that calls a short sub by name, one without branches or recursion that takes its arguments through my (...) = @_, my $x = shift or $_[k], compiles with the sub’s body in place of the call. A sub that only reads a lexical of its file, such as sub f { $g }, is inlined too, and redefining an inlined sub takes effect as on perl5. A loop calling a three-argument sub runs 18.1 times as fast as on perl5, and one using the return value of a two-argument sub 17.7 times.

  • Loops that call subroutines compile when the calls are the only part of the loop the JIT cannot compile: the calls run in the interpreter between stretches of compiled code, and hot loops inside the called sub still run compiled. A die, a last that leaves the sub, and recursion behave as on perl5.

  • use integer: integer addition, subtraction, multiplication, division and modulus, the six numeric comparisons and the shift operators compile under the pragma, with perl5’s wrapping integer results; before, they were left to the interpreter. Benchmark loops under use integer run 3.7 to 4.4 times as fast as on perl5.

  • Foreach over arrays: for my $x (@a) and for my $x (@$ref) compile, where only loops over a range did before; reversed and indexed forms stay in the interpreter. A benchmark loop over an array runs 4.94 times as fast as on perl5, against 0.74 times before.

  • Lexical array reads with a variable or constant index, $a[$j] and $a[3], compile in a loop, also inside an inlined sub reading an array of its file.

Modules#

  • Storable freezes faster: a benchmark freezing an array, which ran at 0.895 times perl5’s speed, runs about 1.2 times as fast as perl5.

  • Digest::MD5 computes digests in 2.2% more cycles than perl5’s Digest::MD5, down from 13.4% more.

  • Math::GMP reads a tied or otherwise magical argument before converting it, as perl5 does, and _gmp_lib_version returns a v-string.

Documentation#

  • Peta::FFI::Cairo reference: its pages are translated into 41 languages, where their prose was untranslated before. They were corrected against the module, among them the description of reference counting, and Context::get_matrix and get_font_matrix are documented for the first time.

  • Command-line options page: the page built from pperl --help lost every wrapped line of an option’s description, 11 lines across --cpan, --cpan --system, --via-daemon, --via-daemon=trunk and --interactive, and did not list --native-manifest=DIR at all. It now shows the complete text.