Geth rakudo/coke/ci: a11936b660 | (Will Coleda)++ | azure-pipelines.yml
Update CI to windows-2025

Match raku/nqp
01:51
07:13 rnddim joined 07:14 rnddim left, ShimmerFairy left, rnddim joined 07:15 rnddim left 07:16 rnddim joined 07:29 rnddim left, rnddim joined 08:22 spa1983 joined, spa1983 left, sp1983 joined 08:32 sp1983 left
Geth nqp/main: 1bb593f758 | (Nick Logan)++ (committed using GitHub Web editor) | 5 files
Fix lookbehind for patterns that cannot be flipped

The <?after ...> assertion compiles by reversing the pattern syntax tree and matching it against a reversed copy of the target string. flip_ast only knows how to reverse some nodes. Subrule calls (named rules, interpolated patterns, backreferences), embedded code, and zero-width checks other than anchors were left matching left-to-right ... (24 more lines)
11:26
rakudo/main: 15f695d7c2 | (Elizabeth Mattijsen)++ | tools/templates/NQP_REVISION
Bump NQP for fix of lookbehind for patterns that cannot be flipped

  ugexe++
11:34
nqp/main: 50eccc4964 | (Nick Logan)++ (committed using GitHub Web editor) | src/vm/moar/QAST/QASTOperationsMAST.nqp
Release dispatch op arg registers under their coerced kind

Previously add-dispatcher-op recorded each argument's register kind before coercing small-int, uint, and num32 arguments to full-width registers, then released the coerced register under that stale kind. That put an int64 register on the uint64 free-list (and similar for the other coerced kinds), so a later fresh_register of that kind in the same ... (7 more lines)
11:35
rakudo/main: 3485246b83 | (Elizabeth Mattijsen)++ | tools/templates/NQP_REVISION
Bump NQP to get dispatch register fix for uints

  ugexe++
11:50
nqp/main: 386acc2a81 | (Dan Kogai)++ (committed using GitHub Web editor) | 2 files
Add %a/%A (C99 hex float) directives to HLL sprintf

C99 Floating-point notation support has been long overdue. Perl 5 has done so in 5.22 in 2015, more than 11 years ago.
Format num values in C99 hexadecimal floating-point notation, e.g. 0x1.999999999999ap-4 for 0.1. Supports the usual flags (+, space, ... (19 more lines)
[Coke] definitely want to a spectest blin run with a change to sprintf. 11:58
someone is going to be relying on that old behavior.
lizmat that the %a/A formats do not work ? 11:59
[Coke] spectest+blin, I mean. (there's no special blin run that also spectests)
Oh, I misread. I thought it was changing *how* they worked to meet a new spec, not adding them outright. 12:00
ok. well, still, I can do a "free" blin run this weekend. :)
Geth rakudo/main: 999492263f | (Elizabeth Mattijsen)++ | tools/templates/NQP_REVISION
Bump NQP for %a/%A (C99 hex float) directives to sprintf

dankogai++
lizmat [Coke]: fwiw, I made sure that each of the NQP changes had its own bump, for bisectability 12:01
[Coke] I appreciate that. I probably wouldn't have thought of it, and then would have regretted it. :) 12:06
lizmat [Coke]: also thinking of doing github.com/MoarVM/MoarVM/pull/2031 12:07
[Coke] Yah, that seems good to test out. I do wish he had included the specific numbers he was seeing in the commit message.
m: say 16777216/4194304 12:08
camelia 4
Geth rakudo: dankogai++ created pull request #6524:
Add C99 hexadecimal float literals and %a/%A Formatter directives
[Coke] lizmat++ for also updating the Changelog. :) 12:10
Geth nqp/main: 5776e30dcf | (Elizabeth Mattijsen)++ | tools/templates/MOAR_REVISION
Bump MoarVM to get increased nursery size, MasterDuke++
12:16
rakudo/main: 8eee823949 | (Elizabeth Mattijsen)++ | tools/templates/NQP_REVISION
Bump NQP to get increased nursery size, MasterDuke++
12:30
lizmat FWIW, I did see some improvement in NQP tests (4 -> 3 seconds on my hw), but not really in Rakudo 12:32
I wonder whether the nursery size should be something settable with an env var
[Coke] hey, someone is getting us some tests on dragonflyBSD in addition to our vanilla ubuntu tests. 12:33
lizmat whee!
[Coke] (env var) or maybe compilation flag.
(dragonfly) if this works, could also use this as a framework for other OSes. 12:34
lizmat env var would be nicer, as you wouldn't have to re-compile MoarVM each time
anyways, that was my batch for merges for now, afk for a few hours&
[Coke] lizmat++
timo I would definitely like to see measurements from different processors 12:58
ab5tract am I crazy or did we used to have `@` and `%` anonymous state variables? 14:04
(me being crazy is absolutely on the table :)
I mean, the compiler clearly thinks I'm crazy 14:05
14:05 vrurg_ joined
ab5tract m: dd %.push: "this", "that" 14:05
camelia ===SORRY!=== Error while compiling <tmp>
Variable %.push used where no 'self' is available
at <tmp>:1
------> dd %.push: "this", "that"<HERE><EOL>
Geth rakudo: coke self-assigned RakuAST CI test and spectest runs should also be run with --optimize=off github.com/rakudo/rakudo/issues/6459
dankogai++ created pull request #6525: Add %a/%A (C99 hex float) directives to the 6.e Formatter
14:06
14:09 vrurg left
ab5tract Ah! The answer, as it so often is, is parentheses 14:20
ugexe for a literal like 0 or 1 what do you think the ideal type should be? int or Int? 16:34
ab5tract ugexe: depends on whether it's going to be able to stay an int or not, I guess? 16:35
ugexe i ask having been working with multi dispatch and natives 16:36
so maybe a better question: would f(0) ideally dispatch to f(int $) or f(Int $) 16:37
ab5tract hmm... I would cpnsider throwing an ambiguous dispatch 16:38
You've thought about it more than I have, but I would consider not dispatching to a native signature unless the value is specifically typed to a native type
So I would either make a rule that only native shapes are ever dispatched to signatures expecting native shapes (a simple universal rule to remember) 16:42
Or I would explode compilation when someone puts the two together in the same multi
probably there are more and better options. but what I would hate to do is add another implicit anything to the dispatcher 16:43
lizmat fwiw, I think f() should dispatch to sub f(int $x) 16:53
because you evidently wanted to create a sub with native int parameters 16:54
and you'd only do that for performance
[Coke] I can't ask the question because that changes the answer, but is 0; a literal int or Int? 17:06
My suggestion is dispatch to int because you can force it to go to Int if you want, but you can't force it to go to int 17:07
ugexe int $ = 1 17:16
lizmat 0 qasts as QAST::IVal(0) 17:18
17:34 lizmat left 17:45 lizmat joined
[Coke] ah. ok. so you *can* force it, but the syntax is slightly more awkard? I take back my slight preference. :) 17:55
17:57 lizmat left 17:58 sergot left 17:59 lizmat joined 18:01 sergot joined 19:12 rakkable joined
timo we have QAST::Want for values that could be Int or int (or Str or str, or Num or num) 19:24
lizmat indeed: teh full qast of my example is: 19:30
│ │ - QAST::Want <wanted> 0
│ │ - QAST::WVal(Int)
│ │ - Ii
│ │ - QAST::IVal(0) 0
Geth rakudo/main: 0860b287cb | (Dan Kogai)++ (committed using GitHub Web editor) | 5 files
Add C99 hexadecimal float literals to both frontends

C99 Floating-point notation support has been long overdue. Perl 5 has done so in 5.22 in 2015, more than 11 years ago.
Accept 0x1.8p+1 style hexadecimal floating point literals as Num literals, in both the legacy (Perl6) and the RakuAST (Raku) ... (24 more lines)
19:41
rakudo/main: bf86a3249e | (Elizabeth Mattijsen)++ (committed using GitHub Web editor) | 8 files
Remove undocumented and deprecated "gethostname"

The canonical way nowadays is Kernel.hostname. The deprecation message is about 6 years old :-)
19:42
[Coke] oh, wow, new box run spectest fast 20:14
japhb I commented on MasterDuke's nursery size commit, but just to mention here: It's not clear to me that the max size and starting size for the nursery should both be multiplied by the same amount, so I'm curious if there was any testing on that. 20:21
[Coke]: \o/ 20:22
[Coke] 6.c/6.d are clean as of today
kicking off a blin 20:25
upping %age of cores used 20:28
timo the starting size of the nursery is for newly created threads, if you have something that creates a bunch of threads, for example by filling up a ThreadPoolScheduler's max workers 21:02
when you have many threads that don't have to do a lot, they would not fill up its own nursery for a while 21:03
21:56 finanalyst left 21:57 [Coke] left 22:03 finanalyst joined
timo the profiler data contains which thread was responsible for starting the GC run by filling up its nursery, but it's probably easier to get the info out of moar with like a simple gdb breakpoint + commands or whatever 22:09
it's also visible in rrdb 22:10
22:13 [Coke] joined
[Coke] ok, blin doesn't respond too well when the internet connection goes dark for a few minutes. restarted 22:26
timo how tight is disk space on your blin vm? 22:59
because we could be recording all test runs with rr so if anything goes wrong in a way we can't easily reproduce, we'd have a recording for perfect reproducibility 23:05
not sure if that's actually a problem we have 23:07
Geth rakudo/main: b058762fa4 | (Nick Logan)++ | src/Perl6/Optimizer.nqp
Carry native return types on the legacy optimizer's settled calls

When the optimizer settles a call on a single candidate at compile time the candidate's declared native return type was being lost or carried in a shape that broke at runtime. The settled multi case dropped the type entirely, so assigning the result to a native typed container used the wrong unbox and died. The settled sub case marked the call as returning ... (21 more lines)
23:59
rakudo/main: f8bacc312e | (Nick Logan)++ | 7 files
RakuAST: carry native return types onto resolved calls and operators

When the check time analysis settles a call or an operator on a single candidate that declares a native return type, the type is recorded and attached to the emitted QAST through the same Want shape the legacy optimizer uses, with the bare call as the boxed default and typed native alternatives. The analysis runs at check time, so this applies ... (15 more lines)
rakudo/main: 9cf4f2d241 | (Nick Logan)++ (committed using GitHub Web editor) | 8 files
Merge pull request #6259 from ugexe/ugexe/native-return-type-coercion

Carry native return types on compile-time resolved calls