Vm-dev June 2022

vm-dev@lists.squeakfoundation.org

16 participants
87 discussions

VM/image backwards compatibility (& high dpi) [was Re: [squeak-dev] SIGTRAP when Proceeding from BlockCannotReturn]
by Eliot Miranda 06 Jul '22

06 Jul '22

Hi Jaromir, > On May 11, 2022, at 5:49 AM, Jaromir Matas <mail(a)jaromir.net> wrote: > > > > Hi Eliot, > > > > On Tue, May 10, 2022 at 1:36 PM Jaromir Matas <mail(a)jaromir.net> wrote: > > > Hi Eliot, > > > > > > Thanks a lot for your answers. > > > > > > One last question: what about Process >> #signalException:? You wrote a fix (enclosed) – is it ok to merge it when the #suspend method is updated (Nicolas’s way)? > > > > > > > Yes, I think so. We have to test it but it seems right. And we can go even simpler, just have the first clause as guarded by processSuspensionUnblocks ifFalse:, once we're ready to release on VMs with the new primitive. > > > > Thanks again; this brings me to another question: if you go simpler, i.e. with the ifFalse clause only, it would mean the method wouldn't work correctly with older VMs with the older prim 88 suspend semantics. I was under the impression to keep compatibility with older VMs but maybe it's a nonsensical assumption on my part (The reason I'm asking is the #terminate I wrote is compatible with both the new and old VMs - but could be simplified a bit if the old VMs were not supposed to be used with the new images). That’s the way backwards compatibility works, with images and VMs in the same way as binaries and processors. A VM is expected to be backwards compatible with all older images of the same basic version (eg the Spur format, the V3 format). So all Spur 4.6, 5.x & current 6.x images should run on the current tip VM. But a new image may expect a feature added to a contemporary VM that is absent in previous versions of the VM. This is analogous to, for example, binaries compiled against newer instructions added to the x86 such as mmx, sse 1, 2 & 3. We expect that the new processor can run older binaries; we do not expect new binaries to run on older processors unless we compile them specially. Now, at a major release we may decide to remove VM features, but at that point we would change the VM’s image format number so that older images do not load. Since this effectively introduces a new VM variant it is not something we do lightly and do only when compelling, as the performance and functionality improvements obtained from the Spur architecture are over V3. We’re currently thinking about this with high dpi support. Can we afford to provide backwards compatibility with older “high dpi unaware” (HDU) images or not? We can either freeze Spur VM support for older images at around March this year, and drop support for HDU images in the platform sources, or we can add a flag bit to the image flags in the latest VMs which if set identifies an image as “high dpi aware” (HDA), and set the bit, eg in a Monticello package load script. And then the VM can remain backwards compatible by testing the HDA bit, behaving like older VMs if unset. It is desirable to maintain backwards compatibility if we can afford the engineering effort. But note that considerable engineering effort must be extended either way. For example, the Virtend application would require considerable work to migrate to HDA, being HDU currently. This is a structural issue. Putting the effort into the HDA VM to provide backwards compatibility with HDU images supports all older HDU applications. Not putting the effort means that all older HDU applications must put effort in to move forwards. (This is because the VM is the platform supporting applications above it, just as the trunk image is a platform that supports applications built within it). Hence it’s my preference to put the effort into the VM (selfishly as I’m committed to keeping the Virtend application running). What kinds of effort are we talking about? It’s not just having a flag to test and having the VM answer/respond appropriately for HDU if unset and for HDA if set. The flag needs to be tested very early in start up, potentially in the current sources before the image has been loaded. Eg on Linux one can supply a command line argument specifying the display subsystem to use which comes before the image name. So command line parsing must be able to make a pass through the arguments to find the image, locate the flags in the header, determine the value of the HDA flag, and then go back and actually process the command line arguments. Tedious work ;-) > > Thanks, > > Jaromir > > -- > Jaromír Matas > mail(a)jaromir.net > > From: Eliot Miranda > Sent: Tuesday, May 10, 2022 23:21 > To: The general-purpose Squeak developers list > Subject: Re: [squeak-dev] SIGTRAP when Proceeding from BlockCannotReturn > > > > On Tue, May 10, 2022 at 1:36 PM Jaromir Matas <mail(a)jaromir.net> wrote: > Hi Eliot, > > Thanks a lot for your answers. > > One last question: what about Process >> #signalException:? You wrote a fix (enclosed) – is it ok to merge it when the #suspend method is updated (Nicolas’s way)? > > Yes, I think so. We have to test it but it seems right. And we can go even simpler, just have the first clause as guarded by processSuspensionUnblocks ifFalse:, once we're ready to release on VMs with the new primitive. > > > Thanks again, > Jaromir > > -- > > Jaromír Matas > > +420 777 492 777 > mail(a)jaromir.net > > > From: Eliot Miranda > Sent: Tuesday, May 10, 2022 21:17 > To: The general-purpose Squeak developers list > Subject: Re: [squeak-dev] SIGTRAP when Proceeding from BlockCannotReturn > > Hi Jaromir, > > On Tue, May 10, 2022 at 8:31 AM Jaromir Matas <mail(a)jaromir.net> wrote: > Hi Eliot, Nicolas, > > > > > (Eliot) Apologies for not responding sooner. It seems to me the semantics must remain as they are, and it be left up to the image to bind suspend to the primitive most convenient. Then backwards compatibility can be provided for cases such as DelayWaitTimeout by providing a renamed suspend which accesses the old primitive. > > > > > > (Nicolas) Yes, I propose the selector > > Process>>suspendAndUnblock <primitive: 78> snip... > > Process>>suspend would call the new primitive, and fallback to suspendAndUnblock in case of failure (for example if new primitive is absent). > > The question remaining is if we really need two new primitives 578 (V1) and 588 (V2). > > It seems like signalException: would require V1, while Jaromir terminate logic would require V2... > > > > (Eliot) +1. Works for me. Having both 578 & 588 available in the VM is fine. I agree that surfacing only one of them is best. > > Thank you, I wasn't sure how to proceed with this :) Do I understand correctly #suspend will have the new suspend semantics (either V1 or preferably V2) in new images (new release) and the previous semantics (via prim 88) will be available for backward compatibility (or special usage)? > > Yes, exactly. > In that case the tests I submitted in KernelTests-jar.421 should work without changes... > > Cool! > > The next question is what to do with: > Process >> suspendPrimitivelyOrFail > "Test support. Execute primitive 88, or fail." > > <primitive: 88> > ^self primitiveFailed > > Change it or remove it? Replace with Nicolas’s Process>>suspendAndUnblock ? > > Well it appears to be used only in testAtomicSuspend. So I would change it to use the same primitive number as suspend, which I guess is 578, primitiveSuspendBackingUpV2, which has the more consistent semantics. > > > Thanks! > > Best, > > Jaromir > > From: Eliot Miranda > Sent: Monday, May 9, 2022 23:23 > To: The general-purpose Squeak developers list > Subject: Re: [squeak-dev] SIGTRAP when Proceeding from BlockCannotReturn > > > > > On May 9, 2022, at 1:04 PM, Nicolas Cellier <nicolas.cellier.aka.nice(a)gmail.com> wrote: > > > > Hi Eliot, > Le lun. 9 mai 2022 à 20:36, Eliot Miranda <eliot.miranda(a)gmail.com> a écrit : > Hi Jaromir, Hi Nicolas, > > On Sun, May 8, 2022 at 8:17 AM Jaromir Matas <mail(a)jaromir.net> wrote: > Hi Nicolas, > > >> About the latest VM, (Smalltalk processSuspensionUnblocks) answers about the behavior of primitiveSuspend (#88). > > Err, wrong wording (Smalltalk processSuspensionUnblocks) does not describe the behavior of primitiveSuspend #(88). > > It answers whether the VM has primitives #578 and #588 (see #getCogVMFeatureFlags in VMMaker)... > > > Yes, thanks, well that was the original idea for Smalltalk processSuspensionUnblocks to answer about the behavior of the primitiveSuspend #88; which was before the primitives #568 and #578 were introduced. (And which was when I wrote the tests using this original logic). However that approach ran into problems with some existing implementations (e.g. Virtend) and as a result the two new primitives were introduced (#568 and #578) - and apparently the logic of what Smalltalk processSuspensionUnblocks answers about changed. Since then I haven't heard from Eliot about his plans how to proceed with the new suspend semantics or whether this is it :) > > Apologies for not responding sooner. It seems to me the semantics must remain as they are, and it be left up to the image to bind suspend to the primitive most convenient. Then backwards compatibility can be provided for cases such as DelayWaitTimeout by providing a renamed suspend which accesses the old primitive. > Yes, I propose the selector > Process>>suspendAndUnblock <primitive: 78> snip... > Process>>suspend would call the new primitive, and fallback to suspendAndUnblock in case of failure (for example if new primitive is absent). > The question remaining is if we really need two new primitives 578 (V1) and 588 (V2). > It seems like signalException: would require V1, while Jaromir terminate logic would require V2... > > +1. Works for me. Having both 578 & 588 available in the VM is fine. I agree that surfacing only one of them is best. > > > > Sorry about not renaming processSuspensionUnblocks. This should be something like Smalltalk hasExtendedProcessSuspensionSemantics or some such. > > It's not too late, there are not many usages, except inbox experimentations. > > > > > In case this is still WIP I'd quite like an approach similar to Smalltalk processPreemptionYields - you'd set Smalltalk processSuspensionUnblocks true or false depending on how you want the VM to behave and the VM would use the right semantics (unless this is too naive :) ). > > Regarding the tests failing with the newest VM: > testAtomicSuspend - we can remove this updated version and leave the existing one for the moment > testRevisedSuspendExpectations - we can leave this one out too > testTerminateBlockedInNestedEnsure1 - I'll take a look at these two and try to adjust the logic > testTerminateBlockedInNestedEnsure2 > > All remaining test in KernelTests-jar.421 work as intended. > > Thanks again, > Jaromir > > -- > > Jaromír Matas > > mail(a)jaromir.net > > > From: Nicolas Cellier > Sent: Sunday, May 8, 2022 16:22 > To: The general-purpose Squeak developers list > Subject: Re: [squeak-dev] SIGTRAP when Proceeding from BlockCannotReturn > > > > Le dim. 8 mai 2022 à 15:59, Nicolas Cellier <nicolas.cellier.aka.nice(a)gmail.com> a écrit : > > > Le dim. 8 mai 2022 à 14:16, Nicolas Cellier <nicolas.cellier.aka.nice(a)gmail.com> a écrit : > Hi Jaromir > > Le sam. 7 mai 2022 à 14:45, Jaromir Matas <mail(a)jaromir.net> a écrit : > Hi Marcel, Nicolas, Eliot, > > > > (Nicolas) I have merged Kernel-jar.1446 which is trivial (re-signal an Exception). > > Thanks! > > > (Marcel) Hmm... #testSimpleResignalVsOuter1 is still failing. > > In my latest trunk image it passes ok (5/7/22) > > >> (Marcel) I will also take a look at KernelTests-jar.421 to check whether any new semantics are okay. > >> > > (Nicolas) Yes, I did that and got two failing tests > > testTerminateTerminatingProcess > > testResumeTerminatingProcess > > > > both failures look the same, in second self assert: terminator isSuspended. > > Yes, they are supposed to fail at the moment so I suggest to make them expected failures/feature requests. However there's a stupid bug in both I’ve fixed now: they were indeed supposed to fail the following assertion: > ``` self should: [terminatee terminate] raise: Error. ``` > > Apologies for the confusion - an updated changeset is enclosed. > > > However, there's another issue regarding the revised #suspend semantics Eliot has been working on. I've updated the process tests in KernelTests-jar.421 to test both the old and the new #suspend semantics. The two semantics should be distinguishable via Smalltalk processSuspensionUnblocks flag answering true in case of the old semantics and false in case of the revised one; my updated tests use this logic. However, unfortunately the latest VM answers "false" but uses the OLD suspend semantics in #suspend prim 88. > > So I'm surprised you haven't observed more tests failing due to the new suspend semantics... What VM have you used – an older one? I'm on the latest trunk's VM 3183. And what is the answer of Smalltalk processSuspensionUnblocks? :) I'm utterly confused... > > Hi Eliot - I may be confused here but if the current VM uses the old #suspend prim 88 semantics, shouldn't ```Smalltalk processSuspensionUnblocks``` answer true? > > > Indeed, I can confirm that the latest VM does answer false to (Smalltalk processSuspensionUnblocks). > Though, process suspension still unblocks as shown by the example at > https://github.com/pharo-project/pharo/issues/10669 > > A bit more simply, this answers false - it shouldn't: > > s := Semaphore new. > p := [s wait] newProcess. > p resume. > 100 milliSeconds wait. > p suspend; resume. > 100 milliSeconds wait. > p isTerminated = Smalltalk processSuspensionUnblocks. > > technically, this answers false - it shouldn't: > > s := Semaphore new. > p := [s wait] newProcess. > p resume. > 100 milliSeconds wait. > p suspend == s = Smalltalk processSuspensionUnblocks > > > About the latest VM, (Smalltalk processSuspensionUnblocks) answers about the behavior of primitiveSuspend (#88). > Err, wrong wording (Smalltalk processSuspensionUnblocks) does not describe the behavior of primitiveSuspend #(88). > It answers whether the VM has primitives #578 and #588 (see #getCogVMFeatureFlags in VMMaker)... > > The new Behavior is implemented by primitiveSuspendBackingUpV1 (#578) and primitiveSuspendBackingUpV2 (#588). > V1 always answers the old list (even if a Semaphore/Mutex), V2 answers nil in case of Semaphore/Mutex. > > So, only ((Process>>#suspend) primitive) can give you a clue about the behavior, assuming that the primitive in question is implemented... > > So it depends if we want to make it a Preference, or make the image compatible with some less capable VM... > > we could implement > Process>>primitiveSuspendAndUnblock as <primitive: 88> > Process>>primitiveSuspend as <primitive: 588> > test the VM flag in suspend > Process>>suspend > ^(VMHasPrimitiveSuspendBackingUp ifNil: [VMHasPrimitiveSuspendBackingUp := Smalltalk processSuspensionUnblocks not]) > ifTrue: [self primitiveSuspend] > ifFalse: [self primitiveSuspendAndUnblock] > Then arrange to reset VMHasPrimitiveSuspendBackingUp to nil at snapshot... > > I will tell next week about the status of the VM which I used for testing, it's possibly a few months old. > > > (Nicolas) I would also consider 1445 1421 and most importantly 1447. > > Regarding 1421: alternatively, you might consider a newer version 1415 where the only difference is #return:from: passes a block instead of nil to #resume:through: to cause a fresh search for the first unwind context; otherwise they are equivalent. > > OK, I will check again. > > > (Marcel) Maybe we can just merge > > > > KernelTests-jar.393 > > KernelTests-jar.418 > > KernelTests-jar.421 > > > > And go from there? Or are there any objections? > > KernelTests-jar.393 is just a special case of a more general KernelTests-jar.418 test… > > In my image all tests are green provided Smalltalk processSuspensionUnblocks answers true and the two above tests Nicolas mentioned are marked expected failures :) > > Thanks very much for your feedback, > Jaromir > > -- > > Jaromír Matas > > mail(a)jaromir.net > > > > > > > -- > _,,,^..^,,,_ > best, Eliot > > > > > > > -- > _,,,^..^,,,_ > best, Eliot > > > > > -- > _,,,^..^,,,_ > best, Eliot > >

2 3

Re: [Vm-dev] Help: Float returns on RISCV
by ken.dickey＠whidbey.com 01 Jul '22

01 Jul '22

> Date: Wed, 29 Jun 2022 09:17:29 -0700 > From: Eliot Miranda <eliot.miranda(a)gmail.com> .. > The pattern is straight-forward. Look at the various implementations > of ffiCalloutTo:SpecOnStack:in:. There are two issues, passing > arguments and receiving results. Yes. I have followed that. Thanks. The generated RiscV64FFIPlugin.c is virtually identical to ARM64FFIPlugin.c as ThreadedARM64FFIPlugin subclass: #ThreadedRiscV64FFIPlugin with almost no overrides, aside from #nonRegisterStructReturnIsViaImplicitFirstArgument --> true. However, the post return assignment to floatRet.d which I see in the ARM64 code appears to be absent from the RiscV64 code. Being very rusty on C and GDB, I am moby confused by this.. -KenD vvvvvv======vvvvvv From SqueakFFIPlugin: [Aarch64/Arm64] 2470 (floatRet.d = dispatchFunctionPointerwithwithwithwithwithwithwithwith(((struct dprr (*)(sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t)) (((void *) address))), ((calloutState->integerRegisters))[0], ((calloutState->integerRegisters))[1], ((calloutState->integerRegisters))[2], ((calloutState->integerRegisters))[3], ((calloutState->integerRegisters))[4], ((calloutState->integerRegisters))[5], ((calloutState->integerRegisters))[6], ((calloutState->integerRegisters))[7])); 0x0000007ff6b3b6cc <+2004>: ldr x8, [x29, #928] 0x0000007ff6b3b6d0 <+2008>: ldr x0, [x29, #800] 0x0000007ff6b3b6d4 <+2012>: ldr x9, [x0, #232] 0x0000007ff6b3b6d8 <+2016>: ldr x0, [x29, #800] 0x0000007ff6b3b6dc <+2020>: ldr x1, [x0, #240] 0x0000007ff6b3b6e0 <+2024>: ldr x0, [x29, #800] 0x0000007ff6b3b6e4 <+2028>: ldr x2, [x0, #248] 0x0000007ff6b3b6e8 <+2032>: ldr x0, [x29, #800] 0x0000007ff6b3b6ec <+2036>: ldr x3, [x0, #256] 0x0000007ff6b3b6f0 <+2040>: ldr x0, [x29, #800] 0x0000007ff6b3b6f4 <+2044>: ldr x4, [x0, #264] 0x0000007ff6b3b6f8 <+2048>: ldr x0, [x29, #800] 0x0000007ff6b3b6fc <+2052>: ldr x5, [x0, #272] 0x0000007ff6b3b700 <+2056>: ldr x0, [x29, #800] 0x0000007ff6b3b704 <+2060>: ldr x6, [x0, #280] 0x0000007ff6b3b708 <+2064>: ldr x0, [x29, #800] 0x0000007ff6b3b70c <+2068>: ldr x7, [x0, #288] 0x0000007ff6b3b710 <+2072>: add x0, x29, #0x3b8 0x0000007ff6b3b714 <+2076>: sub x19, x0, #0x200 0x0000007ff6b3b718 <+2080>: mov x0, x9 0x0000007ff6b3b71c <+2084>: blr x8 ## after return, struct floatRet.d is assigned 0x0000007ff6b3b720 <+2088>: fmov d5, d0 0x0000007ff6b3b724 <+2092>: fmov d4, d1 0x0000007ff6b3b728 <+2096>: fmov d1, d2 0x0000007ff6b3b72c <+2100>: fmov d0, d3 0x0000007ff6b3b730 <+2104>: str d5, [x19] 0x0000007ff6b3b734 <+2108>: str d4, [x19, #8] 0x0000007ff6b3b738 <+2112>: str d1, [x19, #16] 0x0000007ff6b3b73c <+2116>: str d0, [x19, #24] 2471 if (isCalleePopsConvention((calloutState->callFlags))) { ^^^^^^======^^^^^^ vvvvvv======vvvvvv [RISCV64] 2476 (floatRet.d = dispatchFunctionPointerwithwithwithwithwithwithwithwith(((struct dprr (*)(sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t, sqIntptr_t)) (((void *) address))), ((calloutState->integerRegisters))[0], ((calloutState->integerRegisters))[1], ((calloutState->integerRegisters))[2], ((calloutState->integerRegisters))[3], ((calloutState->integerRegisters))[4], ((calloutState->integerRegisters))[5], ((calloutState->integerRegisters))[6], ((calloutState->integerRegisters))[7])); 0x0000003ff703f95a <+3456>: ld t3,-200(s0) 0x0000003ff703f95e <+3460>: ld a7,-208(s0) 0x0000003ff703f962 <+3464>: ld a6,-216(s0) 0x0000003ff703f966 <+3468>: ld a5,-224(s0) 0x0000003ff703f96a <+3472>: ld a4,-232(s0) 0x0000003ff703f96e <+3476>: ld a3,-240(s0) 0x0000003ff703f972 <+3480>: ld a2,-248(s0) 0x0000003ff703f976 <+3484>: ld a1,-256(s0) 0x0000003ff703f97a <+3488>: addi s4,s0,-520 0x0000003ff703f97e <+3492>: mv a0,s4 0x0000003ff703f980 <+3494>: sd t3,0(sp) 0x0000003ff703f982 <+3496>: jalr s5 ## NOTA BENE: After return: NO assignment to floatRet.d !?! 2477 if (isCalleePopsConvention((calloutState->callFlags))) { 2478 setsp((calloutState->argVector)); 2479 } 2480 ownVM(myThreadIndex); => 0x0000003ff703f984 <+3498>: ld a5,408(s10) 0x0000003ff703f988 <+3502>: mv a0,s1 0x0000003ff703f98a <+3504>: jalr a5 2481 if (atomicType == FFITypeDoubleFloat) { 0x0000003ff703f98c <+3506>: li a5,13 0x0000003ff703f98e <+3508>: beq s2,a5,0x3ff703fd4a <ffiCallArgArrayOrNilNumArgs+4464> 2482 result = floatObjectOf(((((floatRet.d)).doubles))[0]); ^^^^^^======^^^^^^

2 1

[OpenSmalltalk/opensmalltalk-vm] 6955a7: Manually hack around the incompatibilities with th...
by Eliot Miranda 30 Jun '22

30 Jun '22

Branch: refs/heads/virtend Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 6955a7645836b7ca3e1f65e39b19f570c2cb1553 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/6955a7645836b7ca3e… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2022-06-30 (Thu, 30 Jun 2022) Changed paths: M src/spur64.cog/cogitARMv8.c Log Message: ----------- Manually hack around the incompatibilities with the VMMaker.oscog-eem.3204 commit (get rid of the unused genPrimitiveUninitializedNewWithArg, and the traceFlagsMeanings).

1 0

[OpenSmalltalk/opensmalltalk-vm] 16465e: Manually merge commit 39de29f53035490eff1f1adb0f74...
by Eliot Miranda 30 Jun '22

30 Jun '22

Branch: refs/heads/virtend Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 16465e866972138f9e612250cc784269f20408a6 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/16465e866972138f9e… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2022-06-30 (Thu, 30 Jun 2022) Changed paths: M src/spur64.cog/cogitARMv8.c M src/spur64.sista/cogitARMv8.c Log Message: ----------- Manually merge commit 39de29f53035490eff1f1adb0f74aa153fa21606 CogVM source as per VMMaker.oscog-eem.3204 ARMv8 Cogit. The + 1 in CogARMv8Compiler>>#flushICacheFrom:to: is erroneous cuz the endAddress is always past the last address needing flushing. We're seeing occasional segfaults from sys_icache_invalidate on M1 macs; the plus one looks like the cause.

1 0

[OpenSmalltalk/opensmalltalk-vm] 39de29: CogVM source as per VMMaker.oscog-eem.3204
by Eliot Miranda 30 Jun '22

30 Jun '22

Branch: refs/heads/Cog Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 39de29f53035490eff1f1adb0f74aa153fa21606 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/39de29f53035490eff… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2022-06-30 (Thu, 30 Jun 2022) Changed paths: M src/spur64.cog/cogitARMv8.c M src/spur64.sista/cogitARMv8.c Log Message: ----------- CogVM source as per VMMaker.oscog-eem.3204 ARMv8 Cogit. The + 1 in CogARMv8Compiler>>#flushICacheFrom:to: is erroneous cuz the endAddress is always past the last address needing flushing. We're seeing occasional segfaults from sys_icache_invalidate on M1 macs; the plus one looks like the cause.

1 0

VM Maker: VMMaker.oscog-eem.3204.mcz
by commits＠source.squeak.org 30 Jun '22

30 Jun '22

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.3204.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.3204 Author: eem Time: 30 June 2022, 1:57:44.171763 pm UUID: 1462ee1d-3247-4917-b6b6-a7c90517dd20 Ancestors: VMMaker.oscog-eem.3203 ARMv8 Cogit. The + 1 in CogARMv8Compiler>>#flushICacheFrom:to: is erroneous cuz the endAddress is always past the last address needing flushing. We're seeing occasional segfaults from sys_icache_invalidate on M1 macs; the plus one looks like the cause. =============== Diff against VMMaker.oscog-eem.3203 =============== Item was changed: ----- Method: CogARMv8Compiler>>flushICacheFrom:to: (in category 'inline cacheing') ----- flushICacheFrom: startAddress "<Integer>" to: endAddress "<Integer>" "Flush the instruction cache from (startAddress to endAddress]. If there is a dual mapped code zone (the normal zone but marked with read/execute, and a read/write zone codeToDataDelta bytes away) then also flush the data cache for the corresp- onding range in the read/write zone and invalidate the data cache for the read/execute zone. If using the Apple MAP_JIT/pthread_jit_write_protect_np: also flush the data cache. Use Apple's implementations for both; they are simple and effective." <inline: #always> cogit ensureExecutableCodeZone. self cCode: [self cppIf: #__APPLE__ & #__MACH__ + ifTrue: [cogit sys_dcache_flush: (self cCoerce: startAddress to: #'void *') _: endAddress - startAddress; + sys_icache_invalidate: (self cCoerce: startAddress to: #'void *') _: endAddress - startAddress] - ifTrue: [cogit sys_dcache_flush: (self cCoerce: startAddress to: #'void *') _: endAddress - startAddress + 1; - sys_icache_invalidate: (self cCoerce: startAddress to: #'void *') _: endAddress - startAddress + 1] ifFalse: [cogit ceFlushICache: startAddress _: endAddress]] inSmalltalk: [cogit simulateCeFlushICacheFrom: startAddress to: endAddress]!

1 0

Re: [Vm-dev] Help: Float returns on RISCV
by Eliot Miranda 29 Jun '22

29 Jun '22

Hi Ken, > On Jun 29, 2022, at 7:32 AM, Ken.Dickey(a)whidbey.com wrote: > > Greetings, > > I could use some help in how register values are passed in the FFI. > > The basic situation is that on RISC-V, simple float/double values are returned in FA0 (float reg), not A0 (integer reg). The pattern is straight-forward. Look at the various implementations of ffiCalloutTo:SpecOnStack:in:. There are two issues, passing arguments and receiving results. To pass register arguments the code does a call of a dummy function, loadFloatRegs, defined in platforms/Cross/plugins/SqueakFFIPrims/sqFFIPlugin.c as an empty function. Just calling this with any floating point arguments causes the C compiler to generate the code that loads the floating point argument registers. Because the function does nothing the values persist until the subsequent call of the real function. Look for sends of loadFloatRegs:_:_:_: & loadFloatRegs:_:_:_:_:_:_:_: Then, following immediately, to collect a floating point result the point of call tests the return type and if it is floating point if casts the function pointer to one returning floating point and calls that, otherwise it casts it to one that returns an integer and calls that. > E.g. for unit test: > > ======================================= > testConstructedDoubleCall > "Test using generic FFI spec" > | result meth | > meth := ExternalLibraryFunction > name:'ffiTestDoubles' module: FFITestLibrary moduleName > callType: 0 returnType: ExternalType double > argumentTypes: ((1 to: 2) collect:[:i| ExternalType double]). > result := meth invokeWithArguments: (Array with: 41 with: true). > self assert: result = 42.0 > ======================================= > EXPORT(double) ffiTestDoubles(double d1, double d2) > { > printf("The two floats are %f and %f\n", (float)d1, (float)d2); > return d1+d2; > } > > Looking at: > ThreadedARM64FFIPlugin>>ffiCalloutTo:SpecOnStack:in: > ======================================= > > Stepping in GDB > --> ffiCallArgArrayOrNilNumArgs() > .. > (floatRet.d = dispatchFunctionPointerwithwithwithwithwithwithwithwith(...) > > At this point, I can single step to ffiTestDoubles(), > the proper values are printed (41,1), > 42 is placed in register FA0 > > But the first value in float.d is _1_ (value presumably from A0). > > So I need to set GDB into asm mode and crawl through the C assign to floatRet.d, > but some theory of operations could help me out here. > > Different setup passed to #setReturnRegister:andCall:withArgsArray: ?? > > Thanks much for help, > -KenD

1 0

VM Maker: VMMaker.oscog.seperateMarking-WoC.3207.mcz
by commits＠source.squeak.org 29 Jun '22

29 Jun '22

Tom Braun uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog.seperateMarking-WoC.3207.mcz ==================== Summary ==================== Name: VMMaker.oscog.seperateMarking-WoC.3207 Author: WoC Time: 29 June 2022, 4:54:19.037798 pm UUID: 38b41253-526f-4015-8815-21870b2d6b3a Ancestors: VMMaker.oscog-eem.3203, VMMaker.oscog.seperateMarking-eem.3206 Created abstract superclass for marking Added <cmacro: GIV(...)> where needed to keep the same semantic in generated code =============== Diff against VMMaker.oscog-eem.3203 =============== Item was changed: SystemOrganization addCategory: #'VMMaker-Building'! SystemOrganization addCategory: #'VMMaker-Interpreter'! SystemOrganization addCategory: #'VMMaker-InterpreterSimulation'! SystemOrganization addCategory: #'VMMaker-JIT'! SystemOrganization addCategory: #'VMMaker-JITSimulation'! SystemOrganization addCategory: #'VMMaker-Multithreading'! SystemOrganization addCategory: #'VMMaker-Plugins'! SystemOrganization addCategory: #'VMMaker-Plugins-FFI'! SystemOrganization addCategory: #'VMMaker-Plugins-IOS'! SystemOrganization addCategory: #'VMMaker-PostProcessing'! SystemOrganization addCategory: #'VMMaker-SmartSyntaxPlugins'! SystemOrganization addCategory: #'VMMaker-SpurMemoryManager'! SystemOrganization addCategory: #'VMMaker-SpurMemoryManagerSimulation'! SystemOrganization addCategory: #'VMMaker-Support'! SystemOrganization addCategory: #'VMMaker-Tests'! SystemOrganization addCategory: #'VMMaker-Translation to C'! SystemOrganization addCategory: #'VMMaker-Utilities'! + SystemOrganization addCategory: #'VMMaker-V3MemoryManager'! Item was changed: SmartSyntaxInterpreterPlugin subclass: #BitBltSimulation instanceVariableNames: 'destForm sourceForm halftoneForm combinationRule destX destY width height sourceX sourceY clipX clipY clipWidth clipHeight sourceWidth sourceHeight sourceDepth sourcePitch sourceBits sourcePPW sourceMSB destWidth destHeight destDepth destPitch destBits destPPW destMSB bitCount skew mask1 mask2 preload nWords destMask hDir vDir sourceIndex sourceDelta destIndex destDelta sx sy dx dy bbW bbH halftoneHeight noSource noHalftone halftoneBase sourceAlpha srcBitShift dstBitShift bitBltOop affectedL affectedR affectedT affectedB opTable maskTable ditherMatrix4x4 ditherThresholds16 ditherValues16 hasSurfaceLock warpSrcShift warpSrcMask warpAlignShift warpAlignMask warpBitShiftTable querySurfaceFn lockSurfaceFn unlockSurfaceFn isWarping cmFlags cmMask cmShiftTable cmMaskTable cmLookupTable cmBitsPerColor dither8Lookup componentAlphaModeColor componentAlphaModeAlpha ungammaLookupTable gammaLookupTable numGCsOnInvocation bitBltIsReceiver endOfDestination endOfSource' classVariableNames: 'AllOnes AlphaIndex BBClipHeightIndex BBClipWidthIndex BBClipXIndex BBClipYIndex BBColorMapIndex BBDestFormIndex BBDestXIndex BBDestYIndex BBHalftoneFormIndex BBHeightIndex BBLastIndex BBRuleIndex BBSourceFormIndex BBSourceXIndex BBSourceYIndex BBWarpBase BBWidthIndex BBXTableIndex BEBitBltIndex BinaryPoint BlueIndex ColorMapFixedPart ColorMapIndexedPart ColorMapNewStyle ColorMapPresent CrossedX EndOfRun FixedPt1 FormBitsIndex FormDepthIndex FormHeightIndex FormWidthIndex GreenIndex OpTable OpTableSize RedIndex' poolDictionaries: '' + category: 'VMMaker-Plugins'! - category: 'VMMaker-Interpreter'! !BitBltSimulation commentStamp: 'nice 10/31/2020 23:39' prior: 0! This class implements BitBlt, much as specified in the Blue Book spec. Performance has been enhanced through the use of pointer variables such as sourceIndex and destIndex, and by separating several special cases of the inner loop. Operation has been extended to color, with support for 1, 2, 4, 8, 16, and 32-bit pixel sizes. Conversion between different pixel sizes is facilitated by accepting an optional color map. In addition to the original 16 combination rules, this BitBlt supports 16 fail (for old paint mode) 17 fail (for old mask mode) 18 sourceWord + destinationWord 19 sourceWord - destinationWord 20 rgbAdd: sourceWord with: destinationWord 21 rgbSub: sourceWord with: destinationWord 22 OLDrgbDiff: sourceWord with: destinationWord 23 OLDtallyIntoMap: destinationWord -- old vers doesn't clip to bit boundary 24 alphaBlend: sourceWord with: destinationWord 25 pixPaint: sourceWord with: destinationWord 26 pixMask: sourceWord with: destinationWord 27 rgbMax: sourceWord with: destinationWord 28 rgbMin: sourceWord with: destinationWord 29 rgbMin: sourceWord bitInvert32 with: destinationWord 30 alphaBlendConst: sourceWord with: destinationWord -- alpha passed as an arg 31 alphaPaintConst: sourceWord with: destinationWord -- alpha passed as an arg 32 rgbDiff: sourceWord with: destinationWord 33 tallyIntoMap: destinationWord 34 alphaBlendScaled: sourceWord with: destinationWord 35 alphaBlendScaled: sourceWord with: "unused here - only used by FXBlt" 36 alphaBlendScaled: sourceWord with: "unused here - only used by FXBlt" 37 rgbMul: sourceWord with: destinationWord 38 pixSwap: sourceWord with: destinationWord 39 pixClear: sourceWord with: destinationWord 40 fixAlpha: sourceWord with: destinationWord 41 rgbComponentAlpha: sourceWord with: destinationWord 42 alphaScale: ignoredSourceWord with: destinationWord 43 alphaUnscale: ignoredSourceWord with: destinationWord 44 alphaBlendUnscaled: sourceWord with: destinationWord This implementation has also been fitted with an experimental "warp drive" that allows abritrary scaling and rotation (and even limited affine deformations) with all BitBlt storage modes supported. To add a new rule to BitBlt... 1. add the new rule method or methods in the category 'combination rules' of BBSim 2. describe it in the class comment of BBSim and in the class comment for BitBlt 3. add refs to initializeRuleTable in proper positions 4. add refs to initBBOpTable, following the pattern ! Item was changed: ----- Method: CCodeGenerator>>sortMethods: (in category 'utilities') ----- sortMethods: aTMethodCollection "We need to define this since different Squeak versions answer different results for asSortedCollection and if sort order changes, generated code changes too. When generating VM code, use class name as major sort index as this groups some methods by functionality (e.g. SpurGenerationScavenger) and that makes the VMProfiler more useful." ^aTMethodCollection asSortedCollection: (self isGeneratingPluginCode ifTrue: [[:a :b| a selector caseSensitiveLessOrEqual: b selector]] ifFalse: [[:a :b| + a definingClass sourceSortingKey = b definingClass sourceSortingKey - a definingClass = b definingClass ifTrue: [a selector caseSensitiveLessOrEqual: b selector] + ifFalse: [a definingClass sourceSortingKey caseSensitiveLessOrEqual: b definingClass sourceSortingKey]]])! - ifFalse: [a definingClass name caseSensitiveLessOrEqual: b definingClass name]]])! Item was added: + ----- Method: InterpreterPrimitives>>primitiveNewPinnedInOldSpace (in category 'object access primitives') ----- + primitiveNewPinnedInOldSpace + NewspeakVM ifTrue: "For the mirror prims check that the class obj is actually a valid class." + [(argumentCount < 1 + or: [self objCouldBeClassObj: self stackTop]) ifFalse: + [^self primitiveFailFor: PrimErrBadArgument]]. + objectMemory hasSpurMemoryManagerAPI + ifTrue: + ["Allocate a new fixed-size instance. Fail if the allocation would leave + less than lowSpaceThreshold bytes free. This *will not* cause a GC :-)" + (objectMemory instantiateClass: self stackTop) + ifNotNil: [:obj| self pop: argumentCount + 1 thenPush: obj] + ifNil: [self primitiveFailFor: ((objectMemory isFixedSizePointerFormat: (objectMemory instSpecOfClass: self stackTop)) + ifTrue: [PrimErrNoMemory] + ifFalse: [PrimErrBadReceiver])]] + ifFalse: + ["Allocate a new fixed-size instance. Fail if the allocation would leave + less than lowSpaceThreshold bytes free. May cause a GC." + | spaceOkay | + "The following may cause GC!! Use var for result to permit inlining." + spaceOkay := objectMemory + sufficientSpaceToInstantiate: self stackTop + indexableSize: 0. + spaceOkay + ifTrue: + [self + pop: argumentCount + 1 + thenPush: (objectMemory + instantiateClass: self stackTop + indexableSize: 0)] + ifFalse: [self primitiveFailFor: PrimErrNoMemory]]! Item was added: + ----- Method: InterpreterPrimitives>>primitiveNewWithArgUninitialized (in category 'object access primitives') ----- + primitiveNewWithArgUninitialized + "Allocate a new indexable instance. Fail if the allocation would leave less than lowSpaceThreshold bytes free. May cause a GC." + | size spaceOkay instSpec | + NewspeakVM ifTrue: "For the mirror prims check that the class obj is actually a valid class." + [(argumentCount < 2 + or: [self addressCouldBeClassObj: (self stackValue: 1)]) ifFalse: + [^self primitiveFailFor: PrimErrBadArgument]]. + size := self positiveMachineIntegerValueOf: self stackTop. + self successful ifFalse:"positiveMachineIntegerValueOf: succeeds only for non-negative integers." + [^self primitiveFailFor: PrimErrBadArgument]. + objectMemory hasSpurMemoryManagerAPI + ifTrue: + [(objectMemory instantiateUninitializedClass: (self stackValue: 1) indexableSize: size) + ifNotNil: [:obj| self pop: argumentCount + 1 thenPush: obj] + ifNil: [instSpec := objectMemory instSpecOfClass: (self stackValue: 1). + self primitiveFailFor: (((objectMemory isIndexableFormat: instSpec) + and: [(objectMemory isCompiledMethodFormat: instSpec) not]) + ifTrue: [PrimErrNoMemory] + ifFalse: [PrimErrBadReceiver])]] + ifFalse: + [spaceOkay := objectMemory sufficientSpaceToInstantiate: (self stackValue: 1) indexableSize: size. + spaceOkay + ifTrue: + [self + pop: argumentCount + 1 + thenPush: (objectMemory instantiateClass: (self stackValue: 1) indexableSize: size)] + ifFalse: + [self primitiveFailFor: PrimErrNoMemory]]! Item was changed: ObjectMemory subclass: #NewObjectMemory instanceVariableNames: 'coInterpreter freeStart reserveStart scavengeThreshold needGCFlag edenBytes checkForLeaks statGCEndUsecs heapMap' classVariableNames: '' poolDictionaries: '' + category: 'VMMaker-V3MemoryManager'! - category: 'VMMaker-Interpreter'! !NewObjectMemory commentStamp: '<historical>' prior: 0! I am a refinement of ObjectMemory that eliminates the need for pushRemappableOop:/popRemappableOop in the interpreter proper. Certain primitives that do major allocation may still want to provoke a garbage collection and hence may still need to remap private pointers. But the interpreter subclass of this class does not have to provided it reserves sufficient space for it to make progress to the next scavenge point (send or backward branch).! Item was changed: VMClass subclass: #ObjectMemory instanceVariableNames: 'memory youngStart endOfMemory memoryLimit nilObj falseObj trueObj specialObjectsOop rootTable rootTableCount rootTableOverflowed extraRoots extraRootCount weakRoots weakRootCount child field parentField freeBlock lastHash allocationCount lowSpaceThreshold signalLowSpace compStart compEnd fwdTableNext fwdTableLast remapBuffer remapBufferCount allocationsBetweenGCs tenuringThreshold gcBiasToGrow gcBiasToGrowGCLimit gcBiasToGrowThreshold statFullGCs statIncrGCs statFullGCUsecs statIncrGCUsecs statGCEndTime statIGCDeltaUsecs statTenures statRootTableOverflows freeContexts freeLargeContexts interruptCheckCounter totalObjectCount shrinkThreshold growHeadroom headerTypeBytes youngStartLocal statMarkCount statMarkCountLocal statSweepCount statMkFwdCount statCompMoveCount statGrowMemory statShrinkMemory statRootTableCount statAllocationCount statSurvivorCount statSpecialMarkCount forceTenureFlag gcStartUsecs oldSpaceStart' classVariableNames: 'AllButHashBits AllButImmutabilityBit AllButMarkBit AllButMarkBitAndTypeMask AllButRootBit Done ExtraRootSize GCTopMarker HashBits HeaderTypeClass HeaderTypeExtraBytes HeaderTypeFree HeaderTypeGC LongSizeNumBits NilContext RemapBufferSize RootTableRedZone RootTableSize StartField StartObj Upward WeakRootTableSize WordMask' poolDictionaries: 'VMBasicConstants VMBytecodeConstants VMObjectIndices VMSqueakClassIndices VMSqueakV3ObjectRepresentationConstants' + category: 'VMMaker-V3MemoryManager'! - category: 'VMMaker-Interpreter'! !ObjectMemory commentStamp: '<historical>' prior: 0! This class describes a 32-bit direct-pointer object memory for Smalltalk. The model is very simple in principle: a pointer is either a SmallInteger or a 32-bit direct object pointer. SmallIntegers are tagged with a low-order bit equal to 1, and an immediate 31-bit 2s-complement signed value in the rest of the word. All object pointers point to a header, which may be followed by a number of data fields. This object memory achieves considerable compactness by using a variable header size (the one complexity of the design). The format of the 0th header word is as follows: 3 bits reserved for gc (mark, root, unused) 12 bits object hash (for HashSets) 5 bits compact class index 4 bits object format 6 bits object size in 32-bit words 2 bits header type (0: 3-word, 1: 2-word, 2: forbidden, 3: 1-word) If a class is in the compact class table, then this is the only header information needed. If it is not, then it will have another header word at offset -4 bytes with its class in the high 30 bits, and the header type repeated in its low 2 bits. It the objects size is greater than 255 bytes, then it will have yet another header word at offset -8 bytes with its full word size in the high 30 bits and its header type repeated in the low two bits. The object format field provides the remaining information as given in the formatOf: method (including isPointers, isVariable, isBytes, and the low 2 size bits of byte-sized objects). This implementation includes incremental (2-generation) and full garbage collection, each with compaction and rectification of direct pointers. It also supports a bulk-become (exchange object identity) feature that allows many objects to be becomed at once, as when all instances of a class must be grown or shrunk. There is now a simple 64-bit version of the object memory. It is the simplest possible change that could work. It merely sign-extends all integer oops, and extends all object headers and oops by adding 32 zeroes in the high bits. The format of the base header word is changed in one minor, not especially elegant, way. Consider the old 32-bit header: ggghhhhhhhhhhhhcccccffffsssssstt The 64-bit header is almost identical, except that the size field (now being in units of 8 bytes, has a zero in its low-order bit. At the same time, the byte-size residue bits for byte objects, which are in the low order bits of formats 8-11 and 12-15, are now in need of another bit of residue. So, the change is as follows: ggghhhhhhhhhhhhcccccffffsssssrtt where bit r supplies the 4's bit of the byte size residue for byte objects. Oh, yes, this is also needed now for 'variableWord' objects, since their size in 32-bit words requires a low-order bit. See the comment in formatOf: for the change allowing for 64-bit wide bitmaps, now dubbed 'variableLong'.! Item was added: + SpurMarker subclass: #SpurAllAtOnceMarker + instanceVariableNames: 'marking' + classVariableNames: '' + poolDictionaries: 'SpurObjStackConstants VMBasicConstants' + category: 'VMMaker-SpurMemoryManager'! Item was added: + ----- Method: SpurAllAtOnceMarker class>>implicitReturnTypeFor: (in category 'translation') ----- + implicitReturnTypeFor: aSelector + "Answer the return type for methods that don't have an explicit return." + ^#void! Item was added: + ----- Method: SpurAllAtOnceMarker class>>simulatorClass (in category 'simulation') ----- + simulatorClass + ^ SpurAllAtOnceMarkerSimulator! Item was added: + ----- Method: SpurAllAtOnceMarker class>>sourceSortingKey (in category 'translation') ----- + sourceSortingKey + "To keep methods in the same order while refactoring..." + ^SpurMemoryManager name! Item was added: + ----- Method: SpurAllAtOnceMarker>>initialize (in category 'instance initialization') ----- + initialize + + marking := false! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAccessibleObjectsAndFireEphemerons (in category 'marking') ----- + markAccessibleObjectsAndFireEphemerons + self assert: marking. + self assert: manager validClassTableRootPages. + self assert: manager segmentManager allBridgesMarked. + self cCode: [] "for debugging markAndTrace: set (MarkStackRecord := OrderedCollection new)" + inSmalltalk: [MarkStackRecord ifNotNil: [MarkStackRecord resetTo: 1]]. + + "This must come first to enable stack page reclamation. It clears + the trace flags on stack pages and so must precede any marking. + Otherwise it will clear the trace flags of reached pages." + coInterpreter initStackPageGC. + self markAndTraceHiddenRoots. + self markAndTraceExtraRoots. + self assert: manager validClassTableRootPages. + coInterpreter markAndTraceInterpreterOops: true. + self assert: manager validObjStacks. + self markWeaklingsAndMarkAndFireEphemerons. + self assert: manager validObjStacks! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAllUnscannedEphemerons (in category 'weakness and ephemerality') ----- + markAllUnscannedEphemerons + "After firing the unscanned ephemerons we must scan-mark them. + The wrinkle is that doing so may add more ephemerons to the set. + So we remove the first element, by overwriting it with the last element, + and decrementing the top, and then markAndTrace its contents." + self assert: (manager noUnscannedEphemerons) not. + self assert: manager allUnscannedEphemeronsAreActive. + [manager unscannedEphemerons top > manager unscannedEphemerons start] whileTrue: + [| ephemeron key lastptr | + ephemeron := manager longAt: manager unscannedEphemerons start. + lastptr := manager unscannedEphemerons top - manager bytesPerOop. + lastptr > manager unscannedEphemerons start ifTrue: + [manager longAt: manager unscannedEphemerons start put: (manager longAt: lastptr)]. + manager unscannedEphemerons top: lastptr. + key := manager followedKeyOfMaybeFiredEphemeron: ephemeron. + manager setIsMarkedOf: ephemeron to: false. "to get it to be fully scanned in markAndTrace:" + self + markAndTrace: key; + markAndTrace: ephemeron]! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAndShouldScan: (in category 'marking') ----- + markAndShouldScan: objOop + "Helper for markAndTrace:. + Mark the argument, and answer if its fields should be scanned now. + Immediate objects don't need to be marked. + Already marked objects have already been processed. + Pure bits objects don't need scanning, although their class does. + Weak objects should be pushed on the weakling stack. + Anything else need scanning." + | format | + <inline: true> + (manager isImmediate: objOop) ifTrue: + [^false]. + "if markAndTrace: is to follow and eliminate forwarding pointers + in its scan it cannot be handed an r-value which is forwarded." + self assert: (manager isForwarded: objOop) not. + (manager isMarked: objOop) ifTrue: + [^false]. + manager setIsMarkedOf: objOop to: true. + format := manager formatOf: objOop. + (manager isPureBitsFormat: format) ifTrue: "avoid pushing non-pointer objects on the markStack." + ["Avoid tracing classes of non-objects on the heap, e.g. IRC caches, Sista counters." + (manager classIndexOf: objOop) > manager lastClassIndexPun ifTrue: + [self markAndTraceClassOf: objOop]. + ^false]. + (manager isWeakFormat: format) ifTrue: "push weaklings on the weakling stack to scan later" + [manager push: objOop onObjStack: manager weaklingStack. + ^false]. + ((manager isEphemeronFormat: format) + and: [manager activeAndDeferredScan: objOop]) ifTrue: + [^false]. + ^true! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAndTrace: (in category 'marking') ----- + markAndTrace: objOop + "Mark the argument, and all objects reachable from it, and any remaining objects + on the mark stack. Follow forwarding pointers in the scan." + <api> + <inline: #never> + "if markAndTrace: is to follow and eliminate forwarding pointers + in its scan it cannot be handed an r-value which is forwarded. + The assert for this is in markAndShouldScan:" + (self markAndShouldScan: objOop) ifFalse: + [^self]. + + "Now scan the object, and any remaining objects on the mark stack." + self markLoopFrom: objOop! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAndTraceClassOf: (in category 'marking') ----- + markAndTraceClassOf: objOop + "Ensure the class of the argument is marked, pushing it on the markStack if not already marked. + And for one-way become, which can create duplicate entries in the class table, make sure + objOop's classIndex refers to the classObj's actual classIndex. + Note that this is recursive, but the metaclass chain should terminate quickly." + <inline: false> + | classIndex classObj realClassIndex | + classIndex := manager classIndexOf: objOop. + classObj := manager classOrNilAtIndex: classIndex. + self assert: (coInterpreter objCouldBeClassObj: classObj). + realClassIndex := manager rawHashBitsOf: classObj. + (classIndex ~= realClassIndex + and: [classIndex > manager lastClassIndexPun]) ifTrue: + [manager setClassIndexOf: objOop to: realClassIndex]. + (manager isMarked: classObj) ifFalse: + [manager setIsMarkedOf: classObj to: true. + self markAndTraceClassOf: classObj. + manager push: classObj onObjStack: manager markStack]! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAndTraceExtraRoots (in category 'marking') ----- + markAndTraceExtraRoots + | oop | + self assert: manager remapBufferCount = 0. + + 1 to: manager extraRootCount do: + [:i| + oop := (manager extraRoots at: i) at: 0. + ((manager isImmediate: oop) or: [manager isFreeObject: oop]) ifFalse: + [self markAndTrace: oop]]! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAndTraceHiddenRoots (in category 'marking') ----- + markAndTraceHiddenRoots + "The hidden roots hold both the class table pages and the obj stacks, + and hence need special treatment. The obj stacks must be marked + specially; their pages must be marked, but only the contents of the + mournQueue should be marked. + + If a class table page is weak we can mark and trace the hiddenRoots, + which will not trace through class table pages because they are weak. + But if class table pages are strong, we must mark the pages and *not* + trace them so that only classes reachable from the true roots will be + marked, and unreachable classes will be left unmarked." + + self markAndTraceObjStack: manager markStack andContents: false. + self markAndTraceObjStack: manager weaklingStack andContents: false. + self markAndTraceObjStack: manager mournQueue andContents: true. + + manager setIsMarkedOf: manager rememberedSetObj to: true. + manager setIsMarkedOf: manager freeListsObj to: true. + + (manager isWeakNonImm: manager classTableFirstPage) ifTrue: + [^self markAndTrace: manager hiddenRootsObj]. + + manager setIsMarkedOf: manager hiddenRootsObj to: true. + self markAndTrace: manager classTableFirstPage. + 1 to: manager numClassTablePages - 1 do: + [:i| manager setIsMarkedOf: (manager fetchPointer: i ofObject: manager hiddenRootsObj) + to: true]! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAndTraceObjStack:andContents: (in category 'marking') ----- + markAndTraceObjStack: stackOrNil andContents: markAndTraceContents + "An obj stack is a stack of objects stored in a hidden root slot, such + as the markStack or the ephemeronQueue. It is a linked list of + segments, with the hot end at the head of the list. It is a word object. + The stack pointer is in ObjStackTopx and 0 means empty." + <inline: false> + | index field | + stackOrNil = manager nilObj ifTrue: + [^self]. + manager setIsMarkedOf: stackOrNil to: true. + self assert: (manager numSlotsOfAny: stackOrNil) = ObjStackPageSlots. + field := manager fetchPointer: ObjStackNextx ofObject: stackOrNil. + field ~= 0 ifTrue: + [self markAndTraceObjStack: field andContents: markAndTraceContents]. + field := stackOrNil. + [field := manager fetchPointer: ObjStackFreex ofObject: field. + field ~= 0] whileTrue: + [manager setIsMarkedOf: field to: true]. + markAndTraceContents ifFalse: + [^self]. + "There are four fixed slots in an obj stack, and a Topx of 0 indicates empty, so + if there were 6 slots in an oop stack, full would be 2, and the last 0-rel index is 5." + index := (manager fetchPointer: ObjStackTopx ofObject: stackOrNil) + ObjStackNextx. + [index >= ObjStackFixedSlots] whileTrue: + [field := manager followObjField: index ofObject: stackOrNil. + (manager isImmediate: field) ifFalse: + [self markAndTrace: field]. + index := index - 1]! Item was added: + ----- Method: SpurAllAtOnceMarker>>markAndTraceWeaklingsFrom: (in category 'weakness and ephemerality') ----- + markAndTraceWeaklingsFrom: startIndex + "Mark weaklings on the weaklingStack, ignoring startIndex + number of elements on the bottom of the stack. Answer + the size of the stack *before* the enumeration began." + ^manager objStack: manager weaklingStack from: startIndex do: + [:weakling| + self deny: (manager isForwarded: weakling). + self markAndTraceClassOf: weakling. + "N.B. generateToByDoLimitExpression:negative:on: guards against (unsigned)0 - 1 going +ve" + 0 to: (manager numStrongSlotsOfWeakling: weakling) - 1 do: + [:i| | field | + field := manager followOopField: i ofObject: weakling. + ((manager isImmediate: field) or: [manager isMarked: field]) ifFalse: + [self markAndTrace: field]]]! Item was added: + ----- Method: SpurAllAtOnceMarker>>markInactiveEphemerons (in category 'weakness and ephemerality') ----- + markInactiveEphemerons + "Go through the unscanned ephemerons, marking the inactive ones, and + removing them from the unscanned ephemerons. Answer if any inactive + ones were found. We cannot fire the ephemerons until all are found to + be active since scan-marking an inactive ephemeron later in the set may + render a previously-observed active ephemeron as inactive." + | foundInactive ptr | + foundInactive := false. + ptr := manager unscannedEphemerons start. + [ptr < manager unscannedEphemerons top] whileTrue: + [| ephemeron key | + key := manager followedKeyOfEphemeron: (ephemeron := manager longAt: ptr). + ((manager isImmediate: key) or: [manager isMarked: key]) + ifTrue: + [foundInactive := true. + "Now remove the inactive ephemeron from the set, and scan-mark it. + Scan-marking it may add more ephemerons to the set." + manager unscannedEphemerons top: manager unscannedEphemerons top - manager bytesPerOop. + manager unscannedEphemerons top > ptr ifTrue: + [manager longAt: ptr put: (manager longAt: manager unscannedEphemerons top)]. + self markAndTrace: ephemeron] + ifFalse: + [ptr := ptr + manager bytesPerOop]]. + ^foundInactive! Item was added: + ----- Method: SpurAllAtOnceMarker>>markLoopFrom: (in category 'marking') ----- + markLoopFrom: objOop + "Scan objOop and all objects on the mark stack, until the mark stack is empty. + N.B. When the incremental GC is written this will probably be refactored as + markLoopFrom: objOop while: aBlock" + <inline: true> + | objToScan field index numStrongSlots scanLargeObject | + + "Now scan the object, and any remaining objects on the mark stack." + objToScan := objOop. + "To avoid overflowing the mark stack when we encounter large objects, we + push the obj, then its numStrongSlots, and then index the object from the stack." + [(manager isImmediate: objToScan) + ifTrue: [scanLargeObject := true] + ifFalse: + [numStrongSlots := manager numStrongSlotsOfInephemeral: objToScan. + scanLargeObject := numStrongSlots > self traceImmediatelySlotLimit]. + scanLargeObject + ifTrue: "scanning a large object. scan until hitting an unmarked object, then switch to it, if any." + [(manager isImmediate: objToScan) + ifTrue: + [index := manager integerValueOf: objToScan. + objToScan := manager topOfObjStack: manager markStack] + ifFalse: + [index := numStrongSlots. + self markAndTraceClassOf: objToScan]. + [index > 0] whileTrue: + [index := index - 1. + field := manager fetchPointer: index ofObject: objToScan. + (manager isNonImmediate: field) ifTrue: + [(manager isForwarded: field) ifTrue: "fixFollowedField: is /not/ inlined" + [field := manager fixFollowedField: index ofObject: objToScan withInitialValue: field]. + (self markAndShouldScan: field) ifTrue: + [index > 0 ifTrue: + [(manager topOfObjStack: manager markStack) ~= objToScan ifTrue: + [manager push: objToScan onObjStack: manager markStack]. + manager push: (manager integerObjectOf: index) onObjStack: manager markStack]. + objToScan := field. + index := -1]]]. + index >= 0 ifTrue: "if loop terminated without finding an unmarked referent, switch to top of stack." + [objToScan := manager popObjStack: manager markStack. + objToScan = objOop ifTrue: + [objToScan := manager popObjStack: manager markStack]]] + ifFalse: "scanning a small object. scan, marking, pushing unmarked referents, then switch to the top of the stack." + [index := numStrongSlots. + self markAndTraceClassOf: objToScan. + [index > 0] whileTrue: + [index := index - 1. + field := manager fetchPointer: index ofObject: objToScan. + (manager isNonImmediate: field) ifTrue: + [(manager isForwarded: field) ifTrue: "fixFollowedField: is /not/ inlined" + [field := manager fixFollowedField: index ofObject: objToScan withInitialValue: field]. + (self markAndShouldScan: field) ifTrue: + [manager push: field onObjStack: manager markStack. + ((manager rawNumSlotsOf: field) > self traceImmediatelySlotLimit + and: [(numStrongSlots := manager numStrongSlotsOfInephemeral: field) > self traceImmediatelySlotLimit]) ifTrue: + [manager push: (manager integerObjectOf: numStrongSlots) onObjStack: manager markStack]]]]. + objToScan := manager popObjStack: manager markStack]. + objToScan notNil] whileTrue! Item was added: + ----- Method: SpurAllAtOnceMarker>>markObjects: (in category 'marking') ----- + markObjects: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged + <inline: #never> "for profiling" + "Mark all accessible objects. objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged + is true if all objects are unmarked and/or if unmarked classes shoud be removed from the class table." + "If the incremental collector is running mark bits may be set; stop it and clear them if necessary." + self cCode: '' inSmalltalk: [coInterpreter transcript nextPutAll: 'marking...'; flush]. + manager runLeakCheckerFor: GCModeFull. + + manager shutDownGlobalIncrementalGC: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged. + manager initializeUnscannedEphemerons. + manager initializeMarkStack. + manager initializeWeaklingStack. + marking := true. + self markAccessibleObjectsAndFireEphemerons. + manager expungeDuplicateAndUnmarkedClasses: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged. + manager nilUnmarkedWeaklingSlots. + marking := false! Item was added: + ----- Method: SpurAllAtOnceMarker>>markWeaklingsAndMarkAndFireEphemerons (in category 'weakness and ephemerality') ----- + markWeaklingsAndMarkAndFireEphemerons + "After the initial scan-mark is complete ephemerons can be processed. + Weaklings have accumulated on the weaklingStack, but more may be + uncovered during ephemeron processing. So trace the strong slots + of the weaklings, and as ephemerons are processed ensure any newly + reached weaklings are also traced." + | numTracedWeaklings | + <inline: false> + numTracedWeaklings := 0. + [coInterpreter markAndTraceUntracedReachableStackPages. + coInterpreter markAndTraceMachineCodeOfMarkedMethods. + "Make sure all reached weaklings have their strong slots traced before firing ephemerons..." + [numTracedWeaklings := self markAndTraceWeaklingsFrom: numTracedWeaklings. + (manager sizeOfObjStack: manager weaklingStack) > numTracedWeaklings] whileTrue. + manager noUnscannedEphemerons ifTrue: + [coInterpreter + markAndTraceUntracedReachableStackPages; + markAndTraceMachineCodeOfMarkedMethods; + freeUntracedStackPages; + freeUnmarkedMachineCode. + ^self]. + self markInactiveEphemerons ifFalse: + [manager fireAllUnscannedEphemerons]. + self markAllUnscannedEphemerons] + repeat! Item was added: + ----- Method: SpurAllAtOnceMarker>>marking (in category 'marking') ----- + marking + <cmacro: '() GIV(marking)'> + + ^ marking! Item was added: + ----- Method: SpurAllAtOnceMarker>>traceImmediatelySlotLimit (in category 'marking') ----- + traceImmediatelySlotLimit + "Arbitrary level at which to defer tracing large objects until later. + The average slot size of Smalltalk objects is typically near 8. + We do require traceImmediatelySlotLimit to be < numSlotsMask." + ^64! Item was added: + SpurAllAtOnceMarker subclass: #SpurAllAtOnceMarkerSimulator + instanceVariableNames: '' + classVariableNames: '' + poolDictionaries: '' + category: 'VMMaker-SpurMemoryManagerSimulation'! Item was added: + SpurMarker subclass: #SpurIncrementalMarker + instanceVariableNames: '' + classVariableNames: '' + poolDictionaries: '' + category: 'VMMaker-SpurMemoryManager'! Item was changed: CogClass subclass: #SpurMarker + instanceVariableNames: 'manager coInterpreter' - instanceVariableNames: 'manager marking coInterpreter' classVariableNames: '' + poolDictionaries: '' - poolDictionaries: 'SpurObjStackConstants VMBasicConstants' category: 'VMMaker-SpurMemoryManager'! Item was removed: - ----- Method: SpurMarker class>>simulatorClass (in category 'as yet unclassified') ----- - simulatorClass - ^SpurMarkerSimulator! Item was changed: ----- Method: SpurMarker>>coInterpreter: (in category 'accessing') ----- coInterpreter: aVMSimulator <doNotGenerate> + coInterpreter := aVMSimulator! Item was removed: - ----- Method: SpurMarker>>doMarkAndTrace: (in category 'as yet unclassified') ----- - doMarkAndTrace: objOop - "Mark the argument, and all objects reachable from it, and any remaining objects - on the mark stack. Follow forwarding pointers in the scan." - - <inline: true> - "if markAndTrace: is to follow and eliminate forwarding pointers - in its scan it cannot be handed an r-value which is forwarded. - The assert for this is in markAndShouldScan:" - (self markAndShouldScan: objOop) ifFalse: - [^self]. - - "Now scan the object, and any remaining objects on the mark stack." - self markLoopFrom: objOop! Item was removed: - ----- Method: SpurMarker>>initialize (in category 'as yet unclassified') ----- - initialize - - marking := false! Item was changed: ----- Method: SpurMarker>>manager: (in category 'accessing') ----- manager: aSpurNBitMMXEndianSimulator <doNotGenerate> manager := aSpurNBitMMXEndianSimulator. aSpurNBitMMXEndianSimulator coInterpreter ifNotNil: [:coint | coInterpreter := coint].! Item was removed: - ----- Method: SpurMarker>>markAccessibleObjectsAndFireEphemerons (in category 'as yet unclassified') ----- - markAccessibleObjectsAndFireEphemerons - self assert: marking. - self assert: manager validClassTableRootPages. - self assert: manager segmentManager allBridgesMarked. - self cCode: [] "for debugging markAndTrace: set (MarkStackRecord := OrderedCollection new)" - inSmalltalk: [MarkStackRecord ifNotNil: [MarkStackRecord resetTo: 1]]. - - "This must come first to enable stack page reclamation. It clears - the trace flags on stack pages and so must precede any marking. - Otherwise it will clear the trace flags of reached pages." - coInterpreter initStackPageGC. - self markAndTraceHiddenRoots. - self markAndTraceExtraRoots. - self assert: manager validClassTableRootPages. - coInterpreter markAndTraceInterpreterOops: true. - self assert: manager validObjStacks. - self markWeaklingsAndMarkAndFireEphemerons. - self assert: manager validObjStacks! Item was removed: - ----- Method: SpurMarker>>markAllUnscannedEphemerons (in category 'weakness and ephemerality') ----- - markAllUnscannedEphemerons - "After firing the unscanned ephemerons we must scan-mark them. - The wrinkle is that doing so may add more ephemerons to the set. - So we remove the first element, by overwriting it with the last element, - and decrementing the top, and then markAndTrace its contents." - self assert: (manager noUnscannedEphemerons) not. - self assert: manager allUnscannedEphemeronsAreActive. - [manager unscannedEphemerons top > manager unscannedEphemerons start] whileTrue: - [| ephemeron key lastptr | - ephemeron := manager longAt: manager unscannedEphemerons start. - lastptr := manager unscannedEphemerons top - manager bytesPerOop. - lastptr > manager unscannedEphemerons start ifTrue: - [manager longAt: manager unscannedEphemerons start put: (manager longAt: lastptr)]. - manager unscannedEphemerons top: lastptr. - key := manager followedKeyOfMaybeFiredEphemeron: ephemeron. - manager setIsMarkedOf: ephemeron to: false. "to get it to be fully scanned in markAndTrace:" - self - doMarkAndTrace: key; - doMarkAndTrace: ephemeron]! Item was removed: - ----- Method: SpurMarker>>markAndShouldScan: (in category 'as yet unclassified') ----- - markAndShouldScan: objOop - "Helper for markAndTrace:. - Mark the argument, and answer if its fields should be scanned now. - Immediate objects don't need to be marked. - Already marked objects have already been processed. - Pure bits objects don't need scanning, although their class does. - Weak objects should be pushed on the weakling stack. - Anything else need scanning." - | format | - <inline: true> - (manager isImmediate: objOop) ifTrue: - [^false]. - "if markAndTrace: is to follow and eliminate forwarding pointers - in its scan it cannot be handed an r-value which is forwarded." - self assert: (manager isForwarded: objOop) not. - (manager isMarked: objOop) ifTrue: - [^false]. - manager setIsMarkedOf: objOop to: true. - format := manager formatOf: objOop. - (manager isPureBitsFormat: format) ifTrue: "avoid pushing non-pointer objects on the markStack." - ["Avoid tracing classes of non-objects on the heap, e.g. IRC caches, Sista counters." - (manager classIndexOf: objOop) > manager lastClassIndexPun ifTrue: - [self markAndTraceClassOf: objOop]. - ^false]. - format = manager weakArrayFormat ifTrue: "push weaklings on the weakling stack to scan later" - [manager push: objOop onObjStack: manager weaklingStack. - ^false]. - (format = manager ephemeronFormat - and: [manager activeAndDeferredScan: objOop]) ifTrue: - [^false]. - ^true! Item was added: + ----- Method: SpurMarker>>markAndTrace: (in category 'marking') ----- + markAndTrace: objOop + + ^ self subclassResponsibility! Item was removed: - ----- Method: SpurMarker>>markAndTraceClassOf: (in category 'as yet unclassified') ----- - markAndTraceClassOf: objOop - "Ensure the class of the argument is marked, pushing it on the markStack if not already marked. - And for one-way become, which can create duplicate entries in the class table, make sure - objOop's classIndex refers to the classObj's actual classIndex. - Note that this is recursive, but the metaclass chain should terminate quickly." - <inline: false> - | classIndex classObj realClassIndex | - classIndex := manager classIndexOf: objOop. - classObj := manager classOrNilAtIndex: classIndex. - self assert: (coInterpreter objCouldBeClassObj: classObj). - realClassIndex := manager rawHashBitsOf: classObj. - (classIndex ~= realClassIndex - and: [classIndex > manager lastClassIndexPun]) ifTrue: - [manager setClassIndexOf: objOop to: realClassIndex]. - (manager isMarked: classObj) ifFalse: - [manager setIsMarkedOf: classObj to: true. - self markAndTraceClassOf: classObj. - manager push: classObj onObjStack: manager markStack]! Item was removed: - ----- Method: SpurMarker>>markAndTraceExtraRoots (in category 'as yet unclassified') ----- - markAndTraceExtraRoots - | oop | - self assert: manager remapBufferCount = 0. - - 1 to: manager extraRootCount do: - [:i| - oop := (manager extraRoots at: i) at: 0. - ((manager isImmediate: oop) or: [manager isFreeObject: oop]) ifFalse: - [self doMarkAndTrace: oop]]! Item was removed: - ----- Method: SpurMarker>>markAndTraceHiddenRoots (in category 'as yet unclassified') ----- - markAndTraceHiddenRoots - "The hidden roots hold both the class table pages and the obj stacks, - and hence need special treatment. The obj stacks must be marked - specially; their pages must be marked, but only the contents of the - mournQueue should be marked. - - If a class table page is weak we can mark and trace the hiddenRoots, - which will not trace through class table pages because they are weak. - But if class table pages are strong, we must mark the pages and *not* - trace them so that only classes reachable from the true roots will be - marked, and unreachable classes will be left unmarked." - - self markAndTraceObjStack: manager markStack andContents: false. - self markAndTraceObjStack: manager weaklingStack andContents: false. - self markAndTraceObjStack: manager mournQueue andContents: true. - - manager setIsMarkedOf: manager rememberedSetObj to: true. - manager setIsMarkedOf: manager freeListsObj to: true. - - (manager isWeakNonImm: manager classTableFirstPage) ifTrue: - [^self doMarkAndTrace: manager hiddenRootsObj]. - - manager setIsMarkedOf: manager hiddenRootsObj to: true. - self doMarkAndTrace: manager classTableFirstPage. - 1 to: manager numClassTablePages - 1 do: - [:i| manager setIsMarkedOf: (manager fetchPointer: i ofObject: manager hiddenRootsObj) - to: true]! Item was removed: - ----- Method: SpurMarker>>markAndTraceObjStack:andContents: (in category 'as yet unclassified') ----- - markAndTraceObjStack: stackOrNil andContents: markAndTraceContents - "An obj stack is a stack of objects stored in a hidden root slot, such - as the markStack or the ephemeronQueue. It is a linked list of - segments, with the hot end at the head of the list. It is a word object. - The stack pointer is in ObjStackTopx and 0 means empty." - <inline: false> - | index field | - stackOrNil = manager nilObj ifTrue: - [^self]. - manager setIsMarkedOf: stackOrNil to: true. - self assert: (manager numSlotsOfAny: stackOrNil) = ObjStackPageSlots. - field := manager fetchPointer: ObjStackNextx ofObject: stackOrNil. - field ~= 0 ifTrue: - [self markAndTraceObjStack: field andContents: markAndTraceContents]. - field := stackOrNil. - [field := manager fetchPointer: ObjStackFreex ofObject: field. - field ~= 0] whileTrue: - [manager setIsMarkedOf: field to: true]. - markAndTraceContents ifFalse: - [^self]. - "There are four fixed slots in an obj stack, and a Topx of 0 indicates empty, so - if there were 6 slots in an oop stack, full would be 2, and the last 0-rel index is 5." - index := (manager fetchPointer: ObjStackTopx ofObject: stackOrNil) + ObjStackNextx. - [index >= ObjStackFixedSlots] whileTrue: - [field := manager followObjField: index ofObject: stackOrNil. - (manager isImmediate: field) ifFalse: - [self doMarkAndTrace: field]. - index := index - 1]! Item was removed: - ----- Method: SpurMarker>>markAndTraceWeaklingsFrom: (in category 'weakness and ephemerality') ----- - markAndTraceWeaklingsFrom: startIndex - "Mark weaklings on the weaklingStack, ignoring startIndex - number of elements on the bottom of the stack. Answer - the size of the stack *before* the enumeration began." - ^manager objStack: manager weaklingStack from: startIndex do: - [:weakling| - self deny: (manager isForwarded: weakling). - self markAndTraceClassOf: weakling. - "N.B. generateToByDoLimitExpression:negative:on: guards against (unsigned)0 - 1 going +ve" - 0 to: (manager numStrongSlotsOfWeakling: weakling) - 1 do: - [:i| | field | - field := manager followOopField: i ofObject: weakling. - ((manager isImmediate: field) or: [manager isMarked: field]) ifFalse: - [self doMarkAndTrace: field]]]! Item was removed: - ----- Method: SpurMarker>>markInactiveEphemerons (in category 'weakness and ephemerality') ----- - markInactiveEphemerons - "Go through the unscanned ephemerons, marking the inactive ones, and - removing them from the unscanned ephemerons. Answer if any inactive - ones were found. We cannot fire the ephemerons until all are found to - be active since scan-marking an inactive ephemeron later in the set may - render a previously-observed active ephemeron as inactive." - | foundInactive ptr | - foundInactive := false. - ptr := manager unscannedEphemerons start. - [ptr < manager unscannedEphemerons top] whileTrue: - [| ephemeron key | - key := manager followedKeyOfEphemeron: (ephemeron := manager longAt: ptr). - ((manager isImmediate: key) or: [manager isMarked: key]) - ifTrue: - [foundInactive := true. - "Now remove the inactive ephemeron from the set, and scan-mark it. - Scan-marking it may add more ephemerons to the set." - manager unscannedEphemerons top: manager unscannedEphemerons top - manager bytesPerOop. - manager unscannedEphemerons top > ptr ifTrue: - [manager longAt: ptr put: (manager longAt: manager unscannedEphemerons top)]. - self doMarkAndTrace: ephemeron] - ifFalse: - [ptr := ptr + manager bytesPerOop]]. - ^foundInactive! Item was removed: - ----- Method: SpurMarker>>markLoopFrom: (in category 'as yet unclassified') ----- - markLoopFrom: objOop - "Scan objOop and all objects on the mark stack, until the mark stack is empty. - N.B. When the incremental GC is written this will probably be refactored as - markLoopFrom: objOop while: aBlock" - <inline: true> - | objToScan field index numStrongSlots scanLargeObject | - - "Now scan the object, and any remaining objects on the mark stack." - objToScan := objOop. - "To avoid overflowing the mark stack when we encounter large objects, we - push the obj, then its numStrongSlots, and then index the object from the stack." - [(manager isImmediate: objToScan) - ifTrue: [scanLargeObject := true] - ifFalse: - [numStrongSlots := manager numStrongSlotsOfInephemeral: objToScan. - scanLargeObject := numStrongSlots > self traceImmediatelySlotLimit]. - scanLargeObject - ifTrue: "scanning a large object. scan until hitting an unmarked object, then switch to it, if any." - [(manager isImmediate: objToScan) - ifTrue: - [index := manager integerValueOf: objToScan. - objToScan := manager topOfObjStack: manager markStack] - ifFalse: - [index := numStrongSlots. - self markAndTraceClassOf: objToScan]. - [index > 0] whileTrue: - [index := index - 1. - field := manager fetchPointer: index ofObject: objToScan. - (manager isNonImmediate: field) ifTrue: - [(manager isForwarded: field) ifTrue: "fixFollowedField: is /not/ inlined" - [field := manager fixFollowedField: index ofObject: objToScan withInitialValue: field]. - (self markAndShouldScan: field) ifTrue: - [index > 0 ifTrue: - [(manager topOfObjStack: manager markStack) ~= objToScan ifTrue: - [manager push: objToScan onObjStack: manager markStack]. - manager push: (manager integerObjectOf: index) onObjStack: manager markStack]. - objToScan := field. - index := -1]]]. - index >= 0 ifTrue: "if loop terminated without finding an unmarked referent, switch to top of stack." - [objToScan := manager popObjStack: manager markStack. - objToScan = objOop ifTrue: - [objToScan := manager popObjStack: manager markStack]]] - ifFalse: "scanning a small object. scan, marking, pushing unmarked referents, then switch to the top of the stack." - [index := numStrongSlots. - self markAndTraceClassOf: objToScan. - [index > 0] whileTrue: - [index := index - 1. - field := manager fetchPointer: index ofObject: objToScan. - (manager isNonImmediate: field) ifTrue: - [(manager isForwarded: field) ifTrue: "fixFollowedField: is /not/ inlined" - [field := manager fixFollowedField: index ofObject: objToScan withInitialValue: field]. - (self markAndShouldScan: field) ifTrue: - [manager push: field onObjStack: manager markStack. - ((manager rawNumSlotsOf: field) > self traceImmediatelySlotLimit - and: [(numStrongSlots := manager numStrongSlotsOfInephemeral: field) > self traceImmediatelySlotLimit]) ifTrue: - [manager push: (manager integerObjectOf: numStrongSlots) onObjStack: manager markStack]]]]. - objToScan := manager popObjStack: manager markStack]. - objToScan notNil] whileTrue! Item was removed: - ----- Method: SpurMarker>>markObjects: (in category 'as yet unclassified') ----- - markObjects: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged - <inline: #never> "for profiling" - "Mark all accessible objects. objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged - is true if all objects are unmarked and/or if unmarked classes shoud be removed from the class table." - "If the incremental collector is running mark bits may be set; stop it and clear them if necessary." - self cCode: '' inSmalltalk: [coInterpreter transcript nextPutAll: 'marking...'; flush]. - manager runLeakCheckerFor: GCModeFull. - - manager shutDownGlobalIncrementalGC: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged. - manager initializeUnscannedEphemerons. - manager initializeMarkStack. - manager initializeWeaklingStack. - marking := true. - self markAccessibleObjectsAndFireEphemerons. - manager expungeDuplicateAndUnmarkedClasses: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged. - manager nilUnmarkedWeaklingSlots. - marking := false! Item was removed: - ----- Method: SpurMarker>>markWeaklingsAndMarkAndFireEphemerons (in category 'weakness and ephemerality') ----- - markWeaklingsAndMarkAndFireEphemerons - "After the initial scan-mark is complete ephemerons can be processed. - Weaklings have accumulated on the weaklingStack, but more may be - uncovered during ephemeron processing. So trace the strong slots - of the weaklings, and as ephemerons are processed ensure any newly - reached weaklings are also traced." - | numTracedWeaklings | - <inline: false> - numTracedWeaklings := 0. - [coInterpreter markAndTraceUntracedReachableStackPages. - coInterpreter markAndTraceMachineCodeOfMarkedMethods. - "Make sure all reached weaklings have their strong slots traced before firing ephemerons..." - [numTracedWeaklings := self markAndTraceWeaklingsFrom: numTracedWeaklings. - (manager sizeOfObjStack: manager weaklingStack) > numTracedWeaklings] whileTrue. - manager noUnscannedEphemerons ifTrue: - [coInterpreter - markAndTraceUntracedReachableStackPages; - markAndTraceMachineCodeOfMarkedMethods; - freeUntracedStackPages; - freeUnmarkedMachineCode. - ^self]. - self markInactiveEphemerons ifFalse: - [manager fireAllUnscannedEphemerons]. - self markAllUnscannedEphemerons] - repeat! Item was removed: - ----- Method: SpurMarker>>marking (in category 'as yet unclassified') ----- - marking - - ^ marking! Item was removed: - ----- Method: SpurMarker>>traceImmediatelySlotLimit (in category 'as yet unclassified') ----- - traceImmediatelySlotLimit - "Arbitrary level at which to defer tracing large objects until later. - The average slot size of Smalltalk objects is typically near 8. - We do require traceImmediatelySlotLimit to be < numSlotsMask." - ^64! Item was removed: - SpurMarker subclass: #SpurMarkerSimulator - instanceVariableNames: '' - classVariableNames: '' - poolDictionaries: '' - category: 'VMMaker-SpurMemoryManagerSimulation'! Item was changed: ----- Method: SpurMemoryManager class>>ancilliaryClasses (in category 'translation') ----- ancilliaryClasses "Answer any extra classes to be included in the translation." + ^{ SpurGenerationScavenger. SpurScavengeLogRecord. SpurSegmentManager. SpurSegmentInfo. SpurAllAtOnceMarker }, - ^{ SpurGenerationScavenger. SpurScavengeLogRecord. SpurSegmentManager. SpurSegmentInfo. SpurMarker }, self compactorClass classesForTranslation, SpurNewSpaceSpace withAllSubclasses ! Item was changed: ----- Method: SpurMemoryManager class>>markerClass (in category 'accessing class hierarchy') ----- markerClass "Answer the marking algorithm to use." + ^Smalltalk classNamed: (InitializationOptions at: #markerClass ifAbsent: [#SpurAllAtOnceMarker])! - ^Smalltalk classNamed: (InitializationOptions at: #markerClass ifAbsent: [#SpurMarker])! Item was changed: ----- Method: SpurMemoryManager>>classTableFirstPage (in category 'accessing') ----- classTableFirstPage + <cmacro: '() GIV(classTableFirstPage)'> + - <cmacro> ^classTableFirstPage! Item was added: + ----- Method: SpurMemoryManager>>extraRootCount (in category 'accessing') ----- + extraRootCount + + ^ extraRootCount! Item was added: + ----- Method: SpurMemoryManager>>extraRoots (in category 'accessing') ----- + extraRoots + <cmacro: '() GIV(extraRoots)'> + ^ extraRoots! Item was added: + ----- Method: SpurMemoryManager>>hiddenRootsObj (in category 'accessing') ----- + hiddenRootsObj + + ^ hiddenRootsObj! Item was added: + ----- Method: SpurMemoryManager>>lowSpaceThreshold (in category 'accessing') ----- + lowSpaceThreshold + + ^ lowSpaceThreshold! Item was changed: ----- Method: SpurMemoryManager>>markAndTrace: (in category 'gc - global') ----- markAndTrace: objOop "Mark the argument, and all objects reachable from it, and any remaining objects + on the mark stack. Follow forwarding pointers in the scan. This behaviour is now + extracted to the SpurMarker hierarchy, so bridge to it." + <doNotGenerate> - on the mark stack. Follow forwarding pointers in the scan." - <api> - <inline: #never> + ^marker markAndTrace: objOop! - marker doMarkAndTrace: objOop! Item was added: + ----- Method: SpurMemoryManager>>nilObj (in category 'accessing') ----- + nilObj + + ^ nilObj! Item was changed: ----- Method: SpurMemoryManager>>nilUnmarkedWeaklingSlots (in category 'weakness and ephemerality') ----- nilUnmarkedWeaklingSlots "Nil the unmarked slots in the weaklings on the weakling stack, finalizing those that lost references. Finally, empty the weaklingStack." <inline: #never> "for profiling" self cCode: '' inSmalltalk: [coInterpreter transcript nextPutAll: 'nilling...'; flush]. self eassert: [self allOldMarkedWeakObjectsOnWeaklingStack]. weaklingStack = nilObj ifTrue: [^self]. self objStack: weaklingStack from: 0 do: [:weakling| | anyUnmarked | anyUnmarked := self nilUnmarkedWeaklingSlotsIn: weakling. anyUnmarked ifTrue: ["fireFinalization: could grow the mournQueue and if so, additional pages must be marked to avoid being GC'ed." + self assert: marking. - self assert: marker marking. coInterpreter fireFinalization: weakling]]. self emptyObjStack: weaklingStack! Item was added: + ----- Method: SpurMemoryManager>>numClassTablePages (in category 'accessing') ----- + numClassTablePages + + ^ numClassTablePages! Item was added: + ----- Method: SpurMemoryManager>>unscannedEphemerons (in category 'accessing') ----- + unscannedEphemerons + <cmacro: '() GIV(unscannedEphemerons)'> + ^ unscannedEphemerons! Item was added: + ----- Method: VMClass class>>sourceSortingKey (in category 'translation') ----- + sourceSortingKey + "Answer the key used to sort methods when generating a source file. By + default this is the name of the class, but can be overridden to alter the + source order, for example to ensure that methods are emitted in the same + order during a refactoring where methods are moved to different classes." + ^self name! Item was changed: VMBasicConstants subclass: #VMSpurObjectRepresentationConstants instanceVariableNames: '' classVariableNames: 'BecameActiveClassFlag BecameCompiledMethodFlag BecamePointerObjectFlag OldBecameNewFlag SpurPrimitiveAccessorDepthShift SpurPrimitiveFlagsMask' poolDictionaries: '' + category: 'VMMaker-SpurMemoryManager'! - category: 'VMMaker-Interpreter'! Item was changed: VMBasicConstants subclass: #VMSqueakV3ObjectRepresentationConstants instanceVariableNames: '' classVariableNames: 'AllButTypeMask CompactClassMask HashBitsOffset HashMaskUnshifted HeaderTypeShort HeaderTypeSizeAndClass ImmutabilityBit LongSizeMask MarkBit RootBit Size4Bit SizeMask TypeMask' poolDictionaries: '' + category: 'VMMaker-V3MemoryManager'! - category: 'VMMaker-Interpreter'! + !VMSqueakV3ObjectRepresentationConstants commentStamp: '<historical>' prior: 0! - !VMSqueakV3ObjectRepresentationConstants commentStamp: '' prior: 0! I am a shared pool for the constants that define the Squeak V3 object representation shared between the object memories (e.g. ObjectMemory, NewObjectMemory), the interpreters (e.g. StackInterpreter, CoInterpreter) and the object representations (e.g. ObjectRepresentationForSqueakV3). self ensureClassPool self classPool declare: #AllButTypeMask from: VMObjectOffsets classPool (ObjectMemory classPool keys select: [:k| k includesSubString: 'Compact']) do: [:k| self classPool declare: k from: ObjectMemory classPool]!

1 0

Help: Float returns on RISCV
by ken.dickey＠whidbey.com 29 Jun '22

29 Jun '22

Greetings, I could use some help in how register values are passed in the FFI. The basic situation is that on RISC-V, simple float/double values are returned in FA0 (float reg), not A0 (integer reg). E.g. for unit test: ======================================= testConstructedDoubleCall "Test using generic FFI spec" | result meth | meth := ExternalLibraryFunction name:'ffiTestDoubles' module: FFITestLibrary moduleName callType: 0 returnType: ExternalType double argumentTypes: ((1 to: 2) collect:[:i| ExternalType double]). result := meth invokeWithArguments: (Array with: 41 with: true). self assert: result = 42.0 ======================================= EXPORT(double) ffiTestDoubles(double d1, double d2) { printf("The two floats are %f and %f\n", (float)d1, (float)d2); return d1+d2; } Looking at: ThreadedARM64FFIPlugin>>ffiCalloutTo:SpecOnStack:in: ======================================= Stepping in GDB --> ffiCallArgArrayOrNilNumArgs() .. (floatRet.d = dispatchFunctionPointerwithwithwithwithwithwithwithwith(...) At this point, I can single step to ffiTestDoubles(), the proper values are printed (41,1), 42 is placed in register FA0 But the first value in float.d is _1_ (value presumably from A0). So I need to set GDB into asm mode and crawl through the C assign to floatRet.d, but some theory of operations could help me out here. Different setup passed to #setReturnRegister:andCall:withArgsArray: ?? Thanks much for help, -KenD

1 0

VM Maker: VMMaker.oscog.seperateMarking-eem.3206.mcz
by commits＠source.squeak.org 27 Jun '22

27 Jun '22

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog.seperateMarking-eem.3206.mcz ==================== Summary ==================== Name: VMMaker.oscog.seperateMarking-eem.3206 Author: eem Time: 27 June 2022, 2:02:30.233921 pm UUID: 6a678af5-a05b-463c-8db1-946cb5495ca5 Ancestors: VMMaker.oscog.seperateMarking-eem.3205 Redo the refactoring of markAndTrace: using the <doNotGenerate> forwarding technique. This way SpurMarker implements markAndTrace: in exactly the same way as SpurMemoryManager used to, and SpurMemoryManager's markAndTrace: is invisible to the C translator. So we get the same code generated as previously, whereas with SpurMarker>>doMarkAndTrace: we get different inlining decisions. Make sure that SpurMarker has the same type for no-return methods as SpurMemoryManager. Make sure SpurMarker methods are categoriuzed appropriately. =============== Diff against VMMaker.oscog.seperateMarking-eem.3205 =============== Item was added: + ----- Method: SpurMarker class>>implicitReturnTypeFor: (in category 'translation') ----- + implicitReturnTypeFor: aSelector + "Answer the return type for methods that don't have an explicit return." + ^#void! Item was removed: - ----- Method: SpurMarker>>doMarkAndTrace: (in category 'as yet unclassified') ----- - doMarkAndTrace: objOop - "Mark the argument, and all objects reachable from it, and any remaining objects - on the mark stack. Follow forwarding pointers in the scan." - - <inline: true> - "if markAndTrace: is to follow and eliminate forwarding pointers - in its scan it cannot be handed an r-value which is forwarded. - The assert for this is in markAndShouldScan:" - (self markAndShouldScan: objOop) ifFalse: - [^self]. - - "Now scan the object, and any remaining objects on the mark stack." - self markLoopFrom: objOop! Item was changed: + ----- Method: SpurMarker>>initialize (in category 'instance initialization') ----- - ----- Method: SpurMarker>>initialize (in category 'as yet unclassified') ----- initialize marking := false! Item was changed: + ----- Method: SpurMarker>>markAccessibleObjectsAndFireEphemerons (in category 'marking') ----- - ----- Method: SpurMarker>>markAccessibleObjectsAndFireEphemerons (in category 'as yet unclassified') ----- markAccessibleObjectsAndFireEphemerons self assert: marking. self assert: manager validClassTableRootPages. self assert: manager segmentManager allBridgesMarked. self cCode: [] "for debugging markAndTrace: set (MarkStackRecord := OrderedCollection new)" inSmalltalk: [MarkStackRecord ifNotNil: [MarkStackRecord resetTo: 1]]. "This must come first to enable stack page reclamation. It clears the trace flags on stack pages and so must precede any marking. Otherwise it will clear the trace flags of reached pages." coInterpreter initStackPageGC. self markAndTraceHiddenRoots. self markAndTraceExtraRoots. self assert: manager validClassTableRootPages. coInterpreter markAndTraceInterpreterOops: true. self assert: manager validObjStacks. self markWeaklingsAndMarkAndFireEphemerons. self assert: manager validObjStacks! Item was changed: ----- Method: SpurMarker>>markAllUnscannedEphemerons (in category 'weakness and ephemerality') ----- markAllUnscannedEphemerons "After firing the unscanned ephemerons we must scan-mark them. The wrinkle is that doing so may add more ephemerons to the set. So we remove the first element, by overwriting it with the last element, and decrementing the top, and then markAndTrace its contents." self assert: (manager noUnscannedEphemerons) not. self assert: manager allUnscannedEphemeronsAreActive. [manager unscannedEphemerons top > manager unscannedEphemerons start] whileTrue: [| ephemeron key lastptr | ephemeron := manager longAt: manager unscannedEphemerons start. lastptr := manager unscannedEphemerons top - manager bytesPerOop. lastptr > manager unscannedEphemerons start ifTrue: [manager longAt: manager unscannedEphemerons start put: (manager longAt: lastptr)]. manager unscannedEphemerons top: lastptr. key := manager followedKeyOfMaybeFiredEphemeron: ephemeron. manager setIsMarkedOf: ephemeron to: false. "to get it to be fully scanned in markAndTrace:" self + markAndTrace: key; + markAndTrace: ephemeron]! - doMarkAndTrace: key; - doMarkAndTrace: ephemeron]! Item was changed: + ----- Method: SpurMarker>>markAndShouldScan: (in category 'marking') ----- - ----- Method: SpurMarker>>markAndShouldScan: (in category 'as yet unclassified') ----- markAndShouldScan: objOop "Helper for markAndTrace:. Mark the argument, and answer if its fields should be scanned now. Immediate objects don't need to be marked. Already marked objects have already been processed. Pure bits objects don't need scanning, although their class does. Weak objects should be pushed on the weakling stack. Anything else need scanning." | format | <inline: true> (manager isImmediate: objOop) ifTrue: [^false]. "if markAndTrace: is to follow and eliminate forwarding pointers in its scan it cannot be handed an r-value which is forwarded." self assert: (manager isForwarded: objOop) not. (manager isMarked: objOop) ifTrue: [^false]. manager setIsMarkedOf: objOop to: true. format := manager formatOf: objOop. (manager isPureBitsFormat: format) ifTrue: "avoid pushing non-pointer objects on the markStack." ["Avoid tracing classes of non-objects on the heap, e.g. IRC caches, Sista counters." (manager classIndexOf: objOop) > manager lastClassIndexPun ifTrue: [self markAndTraceClassOf: objOop]. ^false]. format = manager weakArrayFormat ifTrue: "push weaklings on the weakling stack to scan later" [manager push: objOop onObjStack: manager weaklingStack. ^false]. (format = manager ephemeronFormat and: [manager activeAndDeferredScan: objOop]) ifTrue: [^false]. ^true! Item was added: + ----- Method: SpurMarker>>markAndTrace: (in category 'marking') ----- + markAndTrace: objOop + "Mark the argument, and all objects reachable from it, and any remaining objects + on the mark stack. Follow forwarding pointers in the scan." + <api> + <inline: #never> + "if markAndTrace: is to follow and eliminate forwarding pointers + in its scan it cannot be handed an r-value which is forwarded. + The assert for this is in markAndShouldScan:" + (self markAndShouldScan: objOop) ifFalse: + [^self]. + + "Now scan the object, and any remaining objects on the mark stack." + self markLoopFrom: objOop! Item was changed: + ----- Method: SpurMarker>>markAndTraceClassOf: (in category 'marking') ----- - ----- Method: SpurMarker>>markAndTraceClassOf: (in category 'as yet unclassified') ----- markAndTraceClassOf: objOop "Ensure the class of the argument is marked, pushing it on the markStack if not already marked. And for one-way become, which can create duplicate entries in the class table, make sure objOop's classIndex refers to the classObj's actual classIndex. Note that this is recursive, but the metaclass chain should terminate quickly." <inline: false> | classIndex classObj realClassIndex | classIndex := manager classIndexOf: objOop. classObj := manager classOrNilAtIndex: classIndex. self assert: (coInterpreter objCouldBeClassObj: classObj). realClassIndex := manager rawHashBitsOf: classObj. (classIndex ~= realClassIndex and: [classIndex > manager lastClassIndexPun]) ifTrue: [manager setClassIndexOf: objOop to: realClassIndex]. (manager isMarked: classObj) ifFalse: [manager setIsMarkedOf: classObj to: true. self markAndTraceClassOf: classObj. manager push: classObj onObjStack: manager markStack]! Item was changed: + ----- Method: SpurMarker>>markAndTraceExtraRoots (in category 'marking') ----- - ----- Method: SpurMarker>>markAndTraceExtraRoots (in category 'as yet unclassified') ----- markAndTraceExtraRoots | oop | self assert: manager remapBufferCount = 0. 1 to: manager extraRootCount do: [:i| oop := (manager extraRoots at: i) at: 0. ((manager isImmediate: oop) or: [manager isFreeObject: oop]) ifFalse: + [self markAndTrace: oop]]! - [self doMarkAndTrace: oop]]! Item was changed: + ----- Method: SpurMarker>>markAndTraceHiddenRoots (in category 'marking') ----- - ----- Method: SpurMarker>>markAndTraceHiddenRoots (in category 'as yet unclassified') ----- markAndTraceHiddenRoots "The hidden roots hold both the class table pages and the obj stacks, and hence need special treatment. The obj stacks must be marked specially; their pages must be marked, but only the contents of the mournQueue should be marked. If a class table page is weak we can mark and trace the hiddenRoots, which will not trace through class table pages because they are weak. But if class table pages are strong, we must mark the pages and *not* trace them so that only classes reachable from the true roots will be marked, and unreachable classes will be left unmarked." self markAndTraceObjStack: manager markStack andContents: false. self markAndTraceObjStack: manager weaklingStack andContents: false. self markAndTraceObjStack: manager mournQueue andContents: true. manager setIsMarkedOf: manager rememberedSetObj to: true. manager setIsMarkedOf: manager freeListsObj to: true. (manager isWeakNonImm: manager classTableFirstPage) ifTrue: + [^self markAndTrace: manager hiddenRootsObj]. - [^self doMarkAndTrace: manager hiddenRootsObj]. manager setIsMarkedOf: manager hiddenRootsObj to: true. + self markAndTrace: manager classTableFirstPage. - self doMarkAndTrace: manager classTableFirstPage. 1 to: manager numClassTablePages - 1 do: [:i| manager setIsMarkedOf: (manager fetchPointer: i ofObject: manager hiddenRootsObj) to: true]! Item was changed: + ----- Method: SpurMarker>>markAndTraceObjStack:andContents: (in category 'marking') ----- - ----- Method: SpurMarker>>markAndTraceObjStack:andContents: (in category 'as yet unclassified') ----- markAndTraceObjStack: stackOrNil andContents: markAndTraceContents "An obj stack is a stack of objects stored in a hidden root slot, such as the markStack or the ephemeronQueue. It is a linked list of segments, with the hot end at the head of the list. It is a word object. The stack pointer is in ObjStackTopx and 0 means empty." <inline: false> | index field | stackOrNil = manager nilObj ifTrue: [^self]. manager setIsMarkedOf: stackOrNil to: true. self assert: (manager numSlotsOfAny: stackOrNil) = ObjStackPageSlots. field := manager fetchPointer: ObjStackNextx ofObject: stackOrNil. field ~= 0 ifTrue: [self markAndTraceObjStack: field andContents: markAndTraceContents]. field := stackOrNil. [field := manager fetchPointer: ObjStackFreex ofObject: field. field ~= 0] whileTrue: [manager setIsMarkedOf: field to: true]. markAndTraceContents ifFalse: [^self]. "There are four fixed slots in an obj stack, and a Topx of 0 indicates empty, so if there were 6 slots in an oop stack, full would be 2, and the last 0-rel index is 5." index := (manager fetchPointer: ObjStackTopx ofObject: stackOrNil) + ObjStackNextx. [index >= ObjStackFixedSlots] whileTrue: [field := manager followObjField: index ofObject: stackOrNil. (manager isImmediate: field) ifFalse: + [self markAndTrace: field]. - [self doMarkAndTrace: field]. index := index - 1]! Item was changed: ----- Method: SpurMarker>>markAndTraceWeaklingsFrom: (in category 'weakness and ephemerality') ----- markAndTraceWeaklingsFrom: startIndex "Mark weaklings on the weaklingStack, ignoring startIndex number of elements on the bottom of the stack. Answer the size of the stack *before* the enumeration began." ^manager objStack: manager weaklingStack from: startIndex do: [:weakling| self deny: (manager isForwarded: weakling). self markAndTraceClassOf: weakling. "N.B. generateToByDoLimitExpression:negative:on: guards against (unsigned)0 - 1 going +ve" 0 to: (manager numStrongSlotsOfWeakling: weakling) - 1 do: [:i| | field | field := manager followOopField: i ofObject: weakling. ((manager isImmediate: field) or: [manager isMarked: field]) ifFalse: + [self markAndTrace: field]]]! - [self doMarkAndTrace: field]]]! Item was changed: ----- Method: SpurMarker>>markInactiveEphemerons (in category 'weakness and ephemerality') ----- markInactiveEphemerons "Go through the unscanned ephemerons, marking the inactive ones, and removing them from the unscanned ephemerons. Answer if any inactive ones were found. We cannot fire the ephemerons until all are found to be active since scan-marking an inactive ephemeron later in the set may render a previously-observed active ephemeron as inactive." | foundInactive ptr | foundInactive := false. ptr := manager unscannedEphemerons start. [ptr < manager unscannedEphemerons top] whileTrue: [| ephemeron key | key := manager followedKeyOfEphemeron: (ephemeron := manager longAt: ptr). ((manager isImmediate: key) or: [manager isMarked: key]) ifTrue: [foundInactive := true. "Now remove the inactive ephemeron from the set, and scan-mark it. Scan-marking it may add more ephemerons to the set." manager unscannedEphemerons top: manager unscannedEphemerons top - manager bytesPerOop. manager unscannedEphemerons top > ptr ifTrue: [manager longAt: ptr put: (manager longAt: manager unscannedEphemerons top)]. + self markAndTrace: ephemeron] - self doMarkAndTrace: ephemeron] ifFalse: [ptr := ptr + manager bytesPerOop]]. ^foundInactive! Item was changed: + ----- Method: SpurMarker>>markLoopFrom: (in category 'marking') ----- - ----- Method: SpurMarker>>markLoopFrom: (in category 'as yet unclassified') ----- markLoopFrom: objOop "Scan objOop and all objects on the mark stack, until the mark stack is empty. N.B. When the incremental GC is written this will probably be refactored as markLoopFrom: objOop while: aBlock" <inline: true> | objToScan field index numStrongSlots scanLargeObject | "Now scan the object, and any remaining objects on the mark stack." objToScan := objOop. "To avoid overflowing the mark stack when we encounter large objects, we push the obj, then its numStrongSlots, and then index the object from the stack." [(manager isImmediate: objToScan) ifTrue: [scanLargeObject := true] ifFalse: [numStrongSlots := manager numStrongSlotsOfInephemeral: objToScan. scanLargeObject := numStrongSlots > self traceImmediatelySlotLimit]. scanLargeObject ifTrue: "scanning a large object. scan until hitting an unmarked object, then switch to it, if any." [(manager isImmediate: objToScan) ifTrue: [index := manager integerValueOf: objToScan. objToScan := manager topOfObjStack: manager markStack] ifFalse: [index := numStrongSlots. self markAndTraceClassOf: objToScan]. [index > 0] whileTrue: [index := index - 1. field := manager fetchPointer: index ofObject: objToScan. (manager isNonImmediate: field) ifTrue: [(manager isForwarded: field) ifTrue: "fixFollowedField: is /not/ inlined" [field := manager fixFollowedField: index ofObject: objToScan withInitialValue: field]. (self markAndShouldScan: field) ifTrue: [index > 0 ifTrue: [(manager topOfObjStack: manager markStack) ~= objToScan ifTrue: [manager push: objToScan onObjStack: manager markStack]. manager push: (manager integerObjectOf: index) onObjStack: manager markStack]. objToScan := field. index := -1]]]. index >= 0 ifTrue: "if loop terminated without finding an unmarked referent, switch to top of stack." [objToScan := manager popObjStack: manager markStack. objToScan = objOop ifTrue: [objToScan := manager popObjStack: manager markStack]]] ifFalse: "scanning a small object. scan, marking, pushing unmarked referents, then switch to the top of the stack." [index := numStrongSlots. self markAndTraceClassOf: objToScan. [index > 0] whileTrue: [index := index - 1. field := manager fetchPointer: index ofObject: objToScan. (manager isNonImmediate: field) ifTrue: [(manager isForwarded: field) ifTrue: "fixFollowedField: is /not/ inlined" [field := manager fixFollowedField: index ofObject: objToScan withInitialValue: field]. (self markAndShouldScan: field) ifTrue: [manager push: field onObjStack: manager markStack. ((manager rawNumSlotsOf: field) > self traceImmediatelySlotLimit and: [(numStrongSlots := manager numStrongSlotsOfInephemeral: field) > self traceImmediatelySlotLimit]) ifTrue: [manager push: (manager integerObjectOf: numStrongSlots) onObjStack: manager markStack]]]]. objToScan := manager popObjStack: manager markStack]. objToScan notNil] whileTrue! Item was changed: + ----- Method: SpurMarker>>markObjects: (in category 'marking') ----- - ----- Method: SpurMarker>>markObjects: (in category 'as yet unclassified') ----- markObjects: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged <inline: #never> "for profiling" "Mark all accessible objects. objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged is true if all objects are unmarked and/or if unmarked classes shoud be removed from the class table." "If the incremental collector is running mark bits may be set; stop it and clear them if necessary." self cCode: '' inSmalltalk: [coInterpreter transcript nextPutAll: 'marking...'; flush]. manager runLeakCheckerFor: GCModeFull. manager shutDownGlobalIncrementalGC: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged. manager initializeUnscannedEphemerons. manager initializeMarkStack. manager initializeWeaklingStack. marking := true. self markAccessibleObjectsAndFireEphemerons. manager expungeDuplicateAndUnmarkedClasses: objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged. manager nilUnmarkedWeaklingSlots. marking := false! Item was changed: + ----- Method: SpurMarker>>marking (in category 'marking') ----- - ----- Method: SpurMarker>>marking (in category 'as yet unclassified') ----- marking ^ marking! Item was changed: + ----- Method: SpurMarker>>traceImmediatelySlotLimit (in category 'marking') ----- - ----- Method: SpurMarker>>traceImmediatelySlotLimit (in category 'as yet unclassified') ----- traceImmediatelySlotLimit "Arbitrary level at which to defer tracing large objects until later. The average slot size of Smalltalk objects is typically near 8. We do require traceImmediatelySlotLimit to be < numSlotsMask." ^64! Item was changed: ----- Method: SpurMemoryManager>>markAndTrace: (in category 'gc - global') ----- markAndTrace: objOop "Mark the argument, and all objects reachable from it, and any remaining objects + on the mark stack. Follow forwarding pointers in the scan. This behaviour is now + extracted to the SpurMarker hierarchy, so bridge to it." + <doNotGenerate> - on the mark stack. Follow forwarding pointers in the scan." - <api> - <inline: #never> + ^marker markAndTrace: objOop! - marker doMarkAndTrace: objOop!

1 0

← Newer
1
2
3
4
5
6
7
8
9
Older →

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

Vm-dev June 2022