pperl 0.6.17#

2026-09-06 to 2026-09-09, 96 commits.

Language and runtime#

  • __END__ in bundled modules no longer opens a DATA handle. A module shipped inside pperl that ends in __END__ followed by POD, strict and warnings among them, had a DATA handle reading that POD; as in perl5, only __DATA__ gives a module a DATA handle.

JIT and parallelization#

  • nbody: the Benchmarks Game’s nbody at 200,000 steps runs 293M instructions, from 2,778M. At its official 50,000,000 steps it runs 47.65G instructions in 6.36 s of CPU time, where Node.js takes 49.66G and 6.0 s. Besides the call and array work below, compiled loops keep floating-point values in registers instead of reloading them from memory, check a loop’s constant bound once instead of on every iteration, and skip checks that cannot fail, such as overflow on $j + 1 of a loop counter and the domain test on sqrt of a sum of squares. Placing the arrays’ buffers so that loads and stores to different arrays no longer stall the processor cut nbody’s CPU cycles by 18%.

  • Calls to subroutines that loop: a compiled loop that calls a subroutine with loops of its own, such as nbody’s advance(), now compiles together with the called body, where before each call left compiled code and entered it again twice. The subroutine’s my variables are held in registers, and its call frame is pushed and popped inside compiled code. $_[0] in a subroutine called from one place with a numeric literal argument reads the literal directly.

  • Arrays of numbers whose elements are all floating-point numbers, or all integers, when a compiled loop starts are read and written as flat memory, without a type check per element. For the loop’s duration such an array’s values are kept in a buffer and written back when the loop is left, and an index that is a loop counter is checked against the array’s size once, at the loop’s start. On nbody the buffer alone saves 15.3% of the instructions.

  • Calls to small numeric subroutines no longer leave compiled code: a loop calling a function such as eval_A in the Benchmarks Game’s spectral-norm, a use integer body that reads $_[0] and $_[1] directly, passes the arguments in registers, and the function’s own my variables are registers too. spectral-norm at N=500 runs 440.0M instructions, from 776.5M, and at its official N=5,500 takes 3.25 s of CPU time, from 5.33 s.

  • Nested while and C-style for loops inside a compiled loop compile as part of it, and an unlabelled last or next out of them is a jump. The Benchmarks Game’s fannkuch-redux at n=9 runs 30.7% fewer instructions (6,650M to 4,609M).

  • Number types after compiled loops match perl5’s. $v = $i * 0.5 and sqrt(4) stay floating-point numbers even when the result is integral, an integer literal or a use integer result stays an integer, and an integer variable such as $t = ($i <=> 250) no longer carries a floating-point copy perl5 would not have. The values were right before; the flags, visible through Devel::Peek, were not.

  • Loops left half-compiled by 0.6.16 compile fully again: a loop whose variables are all assigned before they are read ($t = ($i <=> 250)), one that updates a package variable ($G = $G + 1), and one whose counter was used as a float during its first iterations (sin($i)). They had fallen back to a slower, checked mode; for the package-variable loop that was 2.2 times the instructions.

  • JIT compile time: a subroutine the JIT would compile and then reject as a numeric function is rejected before machine code is generated. nbody’s fixed compile cost falls from 157M to 107M instructions, and the Benchmarks Game’s mandelbrot at size 120, a run that is mostly compilation, executes 9.5% fewer instructions.

Modules#

  • Peta::WebGPU is new: GPU compute on the wgpu library, in builds with the webgpu feature. Peta::WebGPU::Device->new opens a device with the adapter’s own limits, compiles WGSL shaders, creates storage and uniform buffers and pipelines, and runs compute passes; have_gpu() and adapters() report what the machine has. A shader or validation error is a Perl exception with wgpu’s message, and a method with no natural result returns its object, so or die works and calls chain. A PDL ndarray uploads to a buffer directly ($gpu->storage_buffer(float(1 .. 8))); a double-typed one is refused with the conversion to use, since WGSL has only 32-bit numbers.

  • SDL2: 25 object methods that die on failure, among them clear, copy, draw_line, fill_rect, present, the save_* methods and every set_*, returned nothing on success, so $ren->clear or die died when it worked. They now return a true value, the object where there is no natural result, and calls chain: $ren->set_draw_color(30, 30, 40, 255)->clear. The direct SDL_* functions still return what the C functions do.

  • Loading modules under -w prints no warnings perl5 does not print. use POSIX (), and with it use Imager, printed 27: constant subroutines shared with Fcntl reported as redefined, and two “Ambiguous call resolved as CORE::open()”. use PDL; use PDL::MatrixOps printed 48 redefinitions, use PDL::Lite; use PDL 532 and use PDL::LiteF; use PDL 631, because PDL’s sub-modules were loaded twice.

  • PDL printing follows upstream PDL’s rules. Elements print as perl prints numbers, so pdl(1.0) - pdl(0.88096) shows 0.11904, not 0.11904000000000003; $PDL::doubleformat and $PDL::floatformat exist and take effect, and $PDL::toolongtoprint is honoured. A 3-D ndarray prints as nested blocks instead of one flat list, PDL->null as Null, an empty ndarray as Empty[0], and a 2-D ndarray ends with its newline.

  • PDL: append on a slice no longer aborts pperl and glue no longer fails with “Not physical but doesn’t have parent”; neither needs ->sever first. -=, +=, *=, /=, **= and %= on an ndarray no longer warn “Use of uninitialized value in subroutine entry”. pdl('BAD') is a 0-dimensional ndarray, pdl('[[5]]') stays 2-dimensional, and norm normalises a vector as upstream’s does instead of dividing the whole ndarray by its Frobenius norm. use PDL () no longer defines main::pdl.

Documentation#

  • Module reference: the Imager and GD pages include documentation that was written but never published: Imager’s colour classes, its kinds of image and the channel mask, and GD::Image and GD::Font.

  • Graphics guides: the 2D graphics guide is fully translated again in all 41 languages after its move to SDL2. The 3D guide’s chapter on opening a window with an OpenGL context is withdrawn, since pperl’s GPU binding is Peta::WebGPU, and the guides’ examples save their images with $ren->save_png.