Vm-dev April 2017

vm-dev@lists.squeakfoundation.org

44 participants
105 discussions

Re: [Vm-dev] Fwd: Nix package for Pharo flavor of opensmalltalk-vm
by Ben Coman 20 Apr '17

20 Apr '17

Moved thread back to pharo-dev for image-side nix packaging discussion. On Thu, Apr 20, 2017 at 3:59 PM, Luke Gorrie <luke(a)snabb.co> wrote: > > On 20 April 2017 at 06:03, Ben Coman <btc(a)openinworld.com> wrote: > >> On Thu, Apr 20, 2017 at 12:21 AM, Luke Gorrie <luke(a)snabb.co> wrote: >>> >>> Then you can start one of those images with these shell commands: >>> >>> pharo-6.0 >>> pharo64-6.0 >>> pharo-5.0 >>> moose-6.1 >>> pharo-launcher-2017.02.28 >> >> Since Pharo 6 is not yet released, what are the implications of naming those >> pharo-6.dev & pharo64-6.dev [minor edit] > > On reflection I will split up my packaging work into "vm" and "image" components. I will send the vm upstream ASAP. I will leave the images on a development branch, perhaps indefinitely, because I am not sure that I am on the right track there at all. That sounds like a good approach. > So, here are more thoughts on image packaging, but with the disclaimer that I will probably not actively pursue this topic further at the moment: > > I assert that Pharo 5 and Pharo 6 are both released, The "release" event will create the PharoV60.sources file, null out the .changes file (it gets incorporated into PharoV60.sources) and Pharo 7 development on will commence. None of those things has happened yet. Last I read, this was due in May, similar timeframe to Pharo 5 release last year. > and are both fast-moving targets. The attached chart shows the dev-image build rate. There is a clear change in Pharo 5 build rate after it was released on 12-May. What happens is that during Pharo-6-development, a critical bug was fixed and deemed worthy to backport to Pharo 5. That doesn't put released-Pharo-5 and in-development-Pharo-6 on equal footing. Perhaps for packaging for distributions we need a modified process for post-release-updates, such that the released image remains constant and upon startup notifies that there are updates available to install. > > On http://pharo.org/download there is a prominent link to Pharo 6 as the "development version" ready for download. Anecdotally the Pharo community that I interact with (mailing list, twitter, slack chat, etc) seem more focused on Pharo 6 than on Pharo 5. The greater focus on Pharo 6 is because it is "in development" and you are talking to pharo-developers. > Occasionally people express surprise when I tell them I am "still" using Pharo 5. On the one hand, that might be considered overzealous recommending alpha/beta software for your primary platform. On the other hand, in practice many find the bleeding edge consistently very stable. (opinion depends on the exact critical nature the application) The thing is, if you hit a bug in the in-development version, it can get fixed quite quickly. More Pharo-developers work on the HEAD, so its self interest to get things working smoothly. Policy is that *all* fixes must *first* be done in the in-development-version. Only critical fixes get backported to the released-version. So if you hit a bug in a released-version, you might not see the fix before the next release. So there is a lot of benefit following the tip of development. > > On http://files.pharo.org/image/50/ there is a new release of Pharo 5 every few weeks. This means that each time I have downloaded "Pharo 5" in the past I have probably gotten a different image and a different VM. So from my end-user perspective I have no idea what software I am installing regardless of whether I choose Pharo 5 or Pharo 6. I consider this moving target for a released version (i.e. Pharo 5) a problem. Personally I'd like to see post-release versionning like 5.0.x, but other seem to disagree, or maybe its just resourcing. Pharo 6 is "in-development" so different rules apply. Personally I never use the "latest" download. I manually choose the latest build using PharoLauncher (couldn't live without it) > > So as a nix user it would make sense for me to be able to download both Pharo 5 and Pharo 6 and for the nix package definitions to determine exactly which software I am running (as opposed to getting an invisible update from Pharo upstream every few days/weeks potentially leading to "but it worked fine on my other machine..." sorts of problems that are exactly what can nix protect me from.) > I agree with you wrt to a released-Pharo-5, but not in-development-Pharo-6. >> Packing the other images is maybe also wrong. How would you deal with user state being stored in the image when a new build download in available? > > > The ad-hoc idea that I ran with is this: > > Running a script like pharo-5.0 (or moose-6.1, etc) will make a temporary copy of the image in the current directory. The changes file will be read-write (requirement) but the image file will be read-only. The model is "you saved it, you own it" i.e. if you want the image to survive after exit you need to "Save image as..." and once you do that then you are responsible for it. I hardly ever use "Save image as...", just "Save" and I think that might confuse existing users if they *need* to do it. Probably workable would be having the "Save image as..." dialog appear the first that "Save" is chosen. > > Code: script to run an image[1] and script to start the right vm[2]. > [1] https://github.com/lukego/nixpkgs/blob/pharo6/pkgs/development/pharo/images… [2] https://github.com/lukego/nixpkgs/blob/pharo6/pkgs/development/pharo/wrappe… > I am not sure why "Save image as..." is misbehaving for me. I have tested every combination of read/write permissions on the working directory, the image, the changes file, etc, but it was always the same. I am sure that I can work this out via the Smalltalk debugger -- but at the moment it seems to make more sense to focus on the VM than on the images. (I want to wrap this up.) > > The downside to skipping the images is that I don't maintain feature parity with Damien's original nix packaging. He packaged the launcher image and then that was the gateway to everything else. This solution doesn't feel very solid to me, since now in 2017 I don't think the launcher is accounting for all the different VM requirements properly, but I am not willing to pick up maintenance of that image so that is life. Skipping Images is different to skipping Launcher. The Launcher provides a *static* vm+image that is used to manage Images to solve "movign target" problem you are hitting. Launcher could perhaps do with some further extension to distinguish 64-bit Images, since that requirement has only arisen in the past year, and also perhaps be able to manage multiple VMs, instead of just the pre-Spur & Spur VMs configured in its settings. But otherwise Launcher works fairly well. If feasible, I'd suggest that you separately package the VMs, and then have a package for PharoLauncher that depends on that package. cheers -ben > > Cheers, > -Luke > > >

1 0

Cog Primitive Performance
by Eliot Miranda 20 Apr '17

20 Apr '17

Hi All, Clément and I have been looking at primitive performance in the context of string hash. We'll say more about string hash in a later message (and there is nothing to be alarmed about here). But it is worth describing the performance measurements of the various kinds of primitive dispatch in Cog. The following measurements are collected from a 64-bit Squeak trunk image with a 64-bit Cog Spur VM with four different implementations of hashMultiply, three of them primitive. The times are collected on a 2.3 GHz Intel Core i7 MacMini. The doit below compares the time taken to go round a loop containing 10 unrolled copies of an operation 10 million times, for a total of 100 million invocations of the operation. The operations are - doing nothing - sending yourself - invoking the SmallInteger>>hashMultiply method - invoking a version of hashMultiply written as a normal interpreter primitive (more on this below) - invoking a version of hashMultiply written as a C function called from machine code - invoking a version of hashMultiply written as a machine code primitive FYI, hash multiply is hashMultiply | low | low := self bitAnd: 16383. ^(16r260D * low + ((16r260D * (self bitShift: -14) + (16r0065 * low) bitAnd: 16383) * 16384)) bitAnd: 16r0FFFFFFF and when written as a primitive is hashMultiply | low | low := self bitAnd: 16383. ^(16r260D * low + (16r260D * (self bitShift: -14) + (16r0065 * low) * 16384)) bitAnd: 16r0FFFFFFF because we don't care about the multiply by 16384 overflowing; when written as a primitive it won't overflow into a LargePositiveInteger. Here is the doit: | n them | n := 10000000. them := { [1 to: n do: [:v| v. v. v. v. v. v. v. v. v. v]]. [1 to: n do: [:v| v yourself. v yourself. v yourself. v yourself. v yourself. v yourself. v yourself. v yourself. v yourself. v yourself]]. [1 to: n do: [:v| v hashMultiply. v hashMultiply. v hashMultiply. v hashMultiply. v hashMultiply. v hashMultiply. v hashMultiply. v hashMultiply. v hashMultiply. v hashMultiply]]. [1 to: n do: [:v| v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive. v hashMultiplyInterpreterPrimitive]]. [1 to: n do: [:v| v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive. v hashMultiplyPrimitive]]. [1 to: n do: [:v| v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive. v hashMultiplyNativePrimitive]] }. them := them, them. them collect: [:b| b timeToRun] and the results: #(19 235 2321 2453 615 314 19 233 2317 2473 614 313) Writing this as a table we have 19/19 null 235/233 v yourself (remember divide by 10 to compare against the loop overhead) 2321/2317 hashMultiply 2453/2473 hashMultiplyInterpreterPrimitive 615/614 hashMultiplyPrimitive 314/313 hashNativePrimitive (the time for) null is the cost of performing the loop arithmetic and the back jump. The JIT eliminates the push and pop of v so the block is effectively empty. v yourself is the overhead of sending a message to a SmallInteger, and returning self, plus the loop overhead. So the loop overhead is comparable to the send overhead. Unsurprising; the loop contains an inlined add and an inlined compare. hashMultiply is the cost of evaluating hashMultiply in Cog jitted code; i.e. as it exists today in standard Squeak and Pharo images hashMultiplyInterpreterPrimitive is the cost of evaluating a primitive version of hashMultiply when written as "normal interpreter primitives". Such primitives are written to take their receiver and arguments from the Smalltalk stack, accessing the stack through the stackPointer global variable, and answering the result by popping the stackPointer and replacing top of stack with the result. When called from a jitted method, the invocation of the interpreter primitive involves - writing the native stack and frame pointers to the stackPointer and framePointer variables - setting the native stack and frame pointers to the C stack (the C stack at the point the interpreter was entered either at start-up or after a callback) - calling the C function - undoing the stack switch - testing primFailCode, the flag that holds the primitive error code and hence indicates a primitive succeeded if 0 hashMultiplyPrimitive is an experimental implementation of the primitive where it is written as a C function that takes its argument (the receiver) as an argument, and answers its result by returning it, setting primFailCode and answering 0 on failure (because 0 is never a valid object; 0 can be used to flag failure). The primitive is run on the Smalltalk stack, avoiding the stack switch in a normal interpreter primitive invocation. Because the Smalltalk stack is divided into small pages this form can only be used for C functions that will not consume much stack (not recurse, or call a deep call chain, nor do any stack allocation, nor raise an exception, etc). When called from a jitted method, the invocation of the C primitive involves - saving any live caller-saved registers (i.e. the register containing the receiver) - marshaling the live registers (in this case only the register containing the receiver) as argument(s) according to the C ABI - calling the C function - restoring any caller-saved registers - testing the C result register and either copying it to the receiver/result register and returning, or falling through to primitive failure code hashMultiplyNativePrimitive is the standard fast implementation of a primitive, using the it's inbuilt assembler; i.e. the primitive is written in an executed assembly code from which the it is constructed. Because this is effectively assembly programming we restrict its use to relatively simple performance-critical primitives (SmallInteger, BoxedFloat64 and SmallFloat64 arithmetic and comparison, basicNew, basicNew:, shallowCopy, closure value, perform:[with:with:], #==. #~~, #class, basicAt:, basicAt:put:, basicSize). As you can see, normal interpreter primitives are woefully slow. The cost is so high that jitted Smalltalk code just beats the primitive, even though the normal Smalltalk code does one more operation and involves five sends (the JIT is clever enough to inline the bitShift: and bitAnd: operations). Alas, most primitives in the VM are written in this style. It has two advantages; first that there exists a large number of existing implementations using this style, and second that the style makes writing primitives that take a variable number of arguments easy (so for example getVMParameters: vmParameterAt: and vmParameterAt:put: are written as one large primitive in the VM code). Writing the primitive as a C function that takes its parameters as arguments and answers its result as the function's return value, is much faster. We're therefore interested in using this scheme to reimplement primitives such as replaceFrom:to:with:startingAt: that are performance-critical but too complex to write as native machine code primitives without developing ulcers, loosing whatever hair color one has left, getting psoriasis, etc. What's perhaps surprising, but should actually be unsurprising, is that there is still overhead in calling a very simple C function compared to embedding the code to perform the primitive directly in the jitted machine code. It is unsurprising in this case as it shows that the overhead of a send is very similar to the overhead of calling a one-argument C function. What's inconvenient about these C function called on the Smalltalk stack style primitives is that currently our C calling marshaling machinery only handles 4 arguments, a limitation that means we don't have to pass arguments on the stack on ARM and WIN64, both of which have a four-integer-register-arguments calling convention, but writing replaceFrom:to:with:startingAt: as a C function requires 5 arguments, because we have to supply the receiver as well. So the C marshalling machinery will have to be extended to pass arguments in both registers and on the stack. Volunteers welcome ;-) You may guess where this conversation is going in terms of string hash. But for the moment we can conclude that - normal interpreter primitives should not be relied upon for performance-critical primitives - the experimental C function called on the Smalltalk stack style primitives look like a good way to write more complex primitives (providing we can invoke them). While they are a little slower than machine code primitives to invoke, the cost will soon be amortized for complex operations. _,,,^..^,,,_ best, Eliot

9 27

VM/Image magic numbers (Re: [Pharo-users] Pharo 6 snap install)
by Ben Coman 19 Apr '17

19 Apr '17

The "magic decode for image files" seems related and possibly *very* useful.... http://forum.world.st/magic-decode-for-image-files-td4941712.html#a4941837 Now traditionally the VM has been backward compatible with old Images, but Pharo doesn't necessarily adhere to that and policy IIUC is release specific VM/Image pairs. So does Pharo require extra magic numbers to co-ordinate this? And how would this interact with OpenSmalltalk policy on these magic numbers? cheers -ben On Sat, Apr 15, 2017 at 4:20 AM, Stephane Ducasse <stepharo.self(a)gmail.com> wrote: > > This is what we always have when we release and we freeze it. > The vm 60 will be compatible with latest pharo 60 image. > > > > On Fri, Apr 14, 2017 at 12:09 PM, Luke Gorrie <luke(a)snabb.co> wrote: >> >> On 14 April 2017 at 08:53, Stephane Ducasse <stepharo.self(a)gmail.com> wrote: >>> >>> We always try to have a major release around mid/end of april >> >> >> Once the dust settles, I think it would be wonderful to have this invariant: >> >> - The latest Pharo VM source release is compatible with the latest Pharo image. >> >> This would make it easy for me to help nix users. My job will be to package the latest source release of the VM, period, and I will know that users can use this to run the latest image. I don't have much scope to screw things up and make people sad e.g. by shipping a bad commit from the master branch. >> >> (Of course it makes life harder for you upstream Pharo maintainers. Now updating the VM source release is a blocker for releasing a new image. Could be that this is too constraining in practice, I dunno. I'm just a guy who wants to setup a stable Pharo that I can use to build an application :-)) >> >> >

5 8

Adding build of ScratchPlugin & UnicodePlugin
by tim Rowledge 18 Apr '17

18 Apr '17

So far as I can tell the Scratch & Unicode plugins are not built for all VM builds. Whilst I can see there is no likely need for them for the NewSpeak systems, and quite possibly not for Pharo configurations, it would be nice to have them included in general Squeak/Cog/Spur VMs. The current NuScratch code works best on a cog-spur vm, at least on slower machines such as the Pi, and there are a small number of people actively trying to develop variants to use across our platforms. It would be nice to be able to assure them that they need not worry about becoming vm build experts in order to have a suitable Windows (etc) vm to run on. Assuming that I’m looking at the proper places (ie https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/Cog/build.linux32ARM… as one example) then - all the linuxARMv6 relevant builds are already setup. - The linuxARMv7 tree only seems to have some beginnings of NewSpeak builds and so doen’t need any changes. - the linux32x86/squeak.cog.spur would need ScratchPlugin adding (this is quite an important VM for the PIXELx86 OS from RPF) - linux64x64/squeak.cog.spur would also need the ScratchPlugin - the macOS builds seem to need both plugins - windows builds ditto To the best of my knowledge the linux changes should be nothing more than adding the ScratchPlugin to the lists. I have no idea at all what mac & windows would need. Please could someone assist? Whilst this request for help from someone au fait with the build server is specifically for the NuScratch related stuff, it does at least appear that we could benefit from some unification across the builds more generally. Why no B3DAccelerator plugin for mac64x64 & ARMv6? Why no MIDI, Klatt nor quicktime for mac/pharo? Would SDL2DPlugin be good across all vms? tim -- tim Rowledge; tim(a)rowledge.org; http://www.rowledge.org/tim Security announcement - as of next week, passwords will be entered in Morse code.

1 0

[OpenSmalltalk/opensmalltalk-vm] 3f2879: CogVM source as per VMMaker.oscog-eem.2197
by GitHub 18 Apr '17

18 Apr '17

Branch: refs/heads/Cog Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 3f2879e4f5d4780d0308cdb83be9adc9ff8c8227 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/3f2879e4f5d4780d03… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2017-04-18 (Tue, 18 Apr 2017) Changed paths: M nsspur64src/vm/cogit.h M nsspur64src/vm/cogitX64SysV.c M nsspur64src/vm/cogitX64WIN64.c M nsspur64src/vm/cointerp.c M nsspur64src/vm/cointerp.h M nsspur64src/vm/gcc3x-cointerp.c M nsspursrc/vm/cogit.h M nsspursrc/vm/cogitARMv5.c M nsspursrc/vm/cogitIA32.c M nsspursrc/vm/cogitMIPSEL.c M nsspursrc/vm/cointerp.c M nsspursrc/vm/cointerp.h M nsspursrc/vm/gcc3x-cointerp.c M nsspurstack64src/vm/gcc3x-interp.c M nsspurstack64src/vm/interp.c M nsspurstacksrc/vm/gcc3x-interp.c M nsspurstacksrc/vm/interp.c M spur64src/vm/cogit.h M spur64src/vm/cogitX64SysV.c M spur64src/vm/cogitX64WIN64.c M spur64src/vm/cointerp.c M spur64src/vm/cointerp.h M spur64src/vm/gcc3x-cointerp.c M spurlowcode64src/vm/cogit.h M spurlowcode64src/vm/cogitX64SysV.c M spurlowcode64src/vm/cogitX64WIN64.c M spurlowcode64src/vm/cointerp.c M spurlowcode64src/vm/cointerp.h M spurlowcode64src/vm/gcc3x-cointerp.c M spurlowcodesrc/vm/cogit.h M spurlowcodesrc/vm/cogitARMv5.c M spurlowcodesrc/vm/cogitIA32.c M spurlowcodesrc/vm/cogitMIPSEL.c M spurlowcodesrc/vm/cointerp.c M spurlowcodesrc/vm/cointerp.h M spurlowcodesrc/vm/gcc3x-cointerp.c M spurlowcodestack64src/vm/gcc3x-interp.c M spurlowcodestack64src/vm/interp.c M spurlowcodestacksrc/vm/gcc3x-interp.c M spurlowcodestacksrc/vm/interp.c M spursista64src/vm/cogit.h M spursista64src/vm/cogitX64SysV.c M spursista64src/vm/cogitX64WIN64.c M spursista64src/vm/cointerp.c M spursista64src/vm/cointerp.h M spursista64src/vm/gcc3x-cointerp.c M spursistasrc/vm/cogit.h M spursistasrc/vm/cogitARMv5.c M spursistasrc/vm/cogitIA32.c M spursistasrc/vm/cogitMIPSEL.c M spursistasrc/vm/cointerp.c M spursistasrc/vm/cointerp.h M spursistasrc/vm/gcc3x-cointerp.c M spursrc/vm/cogit.h M spursrc/vm/cogitARMv5.c M spursrc/vm/cogitIA32.c M spursrc/vm/cogitMIPSEL.c M spursrc/vm/cointerp.c M spursrc/vm/cointerp.h M spursrc/vm/gcc3x-cointerp.c M spurstack64src/vm/gcc3x-interp.c M spurstack64src/vm/interp.c M spurstacksrc/vm/gcc3x-interp.c M spurstacksrc/vm/interp.c M src/plugins/MiscPrimitivePlugin/MiscPrimitivePlugin.c M src/vm/cogit.h M src/vm/cogitARMv5.c M src/vm/cogitIA32.c M src/vm/cogitMIPSEL.c M src/vm/cointerp.c M src/vm/cointerp.h M src/vm/cointerpmt.c M src/vm/cointerpmt.h M src/vm/gcc3x-cointerp.c M src/vm/gcc3x-cointerpmt.c M stacksrc/vm/gcc3x-interp.c M stacksrc/vm/interp.c Log Message: ----------- CogVM source as per VMMaker.oscog-eem.2197 Modify the hashMultiply primitive implementations to do what's intended. Make the magic constant and modulo mask global vars shared between the three implementations. Modify translated primitive parsing to allow int as a valid variable type. Improve the commentary in MiscPrimitivePlugin class>>translatedPrimitives.

1 0

VM Maker: VMMaker.oscog-eem.2197.mcz
by commits＠source.squeak.org 18 Apr '17

18 Apr '17

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.2197.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.2197 Author: eem Time: 18 April 2017, 11:34:46.395361 am UUID: ef120220-dcf2-4825-ad2c-eab126683414 Ancestors: VMMaker.oscog-eem.2196 Modify the hashMultiply primitive implementations to do what's intended. Make the magic constant and modulo mask global vars shared between the three implementations. Modify translated primitive parsing to allow int as a valid variable type. Improve the commentary in MiscPrimitivePlugin class>>translatedPrimitives. =============== Diff against VMMaker.oscog-eem.2196 =============== Item was changed: ----- Method: CoInterpreterPrimitives>>mcprimHashMultiply: (in category 'arithmetic primitives') ----- mcprimHashMultiply: receiverArg "Machine code primitive for hash multiply. c.f. primitiveHashMultiply. mcprims consume receiver and arguments as parameters and answer the result on success, or set the primitive error code and answer 0 on failure." "Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger receivers." <api> + | value | - | receiver low | (objectMemory isIntegerObject: receiverArg) + ifTrue: [value := objectMemory integerValueOf: receiverArg] - ifTrue: [receiver := objectMemory integerValueOf: receiverArg] ifFalse: [| ok | ok := objectMemory is: receiverArg instanceOf: (objectMemory splObj: ClassLargePositiveInteger) compactClassIndex: ClassLargePositiveIntegerCompactIndex. ok ifFalse: [self primitiveFailFor: PrimErrBadReceiver. ^0]. + value := objectMemory byteSwapped32IfBigEndian: (objectMemory fetchLong32: 0 ofObject: receiverArg)]. + ^objectMemory integerObjectOf: (value * HashMultiplyConstant bitAnd: 16rFFFFFFF)! - receiver := objectMemory byteSwapped32IfBigEndian: (objectMemory fetchLong32: 0 ofObject: receiverArg)]. - low := receiver bitAnd: 16383. - "N.B. We use undefined behaviour assuming the compiler will still generate a multiply, rather than simply crap out, so as to save the unnecessary bitAnd: 16383." - ^objectMemory integerObjectOf: ((16r260D * low + ((16r260D * (receiver bitShift: -14) + (16r0065 * low) "bitAnd: 16383") * 16384)) bitAnd: 16r0FFFFFFF)! Item was added: + ----- Method: InterpreterPrimitives class>>initializeMiscConstants (in category 'class initialization') ----- + initializeMiscConstants + "Initialize the hashMultiply constants." + super initializeMiscConstants. + HashMultiplyConstant := 1664525. + HashMultiplyMask := 16rFFFFFFF "(2 raisedTo: 28) - 1"! Item was changed: ----- Method: InterpreterPrimitives>>primitiveHashMultiply (in category 'arithmetic integer primitives') ----- primitiveHashMultiply "Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger receivers." + | value | + value := self stackTop. + (objectMemory isIntegerObject: value) + ifTrue: [value := objectMemory integerValueOf: value] - | receiver low result | - receiver := self stackTop. - (objectMemory isIntegerObject: receiver) - ifTrue: [receiver := objectMemory integerValueOf: receiver] ifFalse: [| ok | + ok := objectMemory is: value instanceOf: (objectMemory splObj: ClassLargePositiveInteger) compactClassIndex: ClassLargePositiveIntegerCompactIndex. - ok := objectMemory is: receiver instanceOf: (objectMemory splObj: ClassLargePositiveInteger) compactClassIndex: ClassLargePositiveIntegerCompactIndex. ok ifFalse: [^self primitiveFailFor: PrimErrBadReceiver]. + value := objectMemory byteSwapped32IfBigEndian: (objectMemory fetchLong32: 0 ofObject: value)]. + self pop: 1 + thenPush: (objectMemory integerObjectOf: (value * HashMultiplyConstant bitAnd: 16rFFFFFFF))! - receiver := objectMemory byteSwapped32IfBigEndian: (objectMemory fetchLong32: 0 ofObject: receiver)]. - low := receiver bitAnd: 16383. - "N.B. We use undefined behaviour assuming the compiler will still generate a multiply, rather than simply crap out, so as to save the unnecessary bitAnd: 16383." - result := (16r260D * low + ((16r260D * (receiver bitShift: -14) + (16r0065 * low) "bitAnd: 16383") * 16384)) bitAnd: 16r0FFFFFFF. - self pop: 1 thenPush: (objectMemory integerObjectOf: result)! Item was changed: ----- Method: MiscPrimitivePlugin class>>translatedPrimitives (in category 'translation') ----- translatedPrimitives "an assorted list of various primitives" + "MiscPrimitivePlugin browseTranslatedPrimitives" (ByteString compiledMethodAt: #findSubstringViaPrimitive:in:startingAt:matchTable: ifAbsent: []) ifNotNil: [^#("Pharo uses findSubstringViaPrimitive:in:startingAt:matchTable:" (Bitmap compress:toByteArray:) (Bitmap decompress:fromByteArray:at:) + (Bitmap encodeBytesOf:in:at:) "merely a support function" + (Bitmap encodeInt:in:at:) "merely a support function" - (Bitmap encodeBytesOf:in:at:) - (Bitmap encodeInt:in:at:) (ByteString compare:with:collated:) (ByteString translate:from:to:table:) (ByteString findFirstInString:inSet:startingAt:) (ByteString indexOfAscii:inString:startingAt:) (String findSubstringViaPrimitive:in:startingAt:matchTable:) (ByteArray hashBytes:startingWith:) (SampledSound convert8bitSignedFrom:to16Bit:))]. + ^#((Bitmap compress:toByteArray:) - ^#( - (Bitmap compress:toByteArray:) (Bitmap decompress:fromByteArray:at:) + (Bitmap encodeBytesOf:in:at:) "merely a support function" + (Bitmap encodeInt:in:at:) "merely a support function" - (Bitmap encodeBytesOf:in:at:) - (Bitmap encodeInt:in:at:) (ByteString compare:with:collated:) (ByteString translate:from:to:table:) (ByteString findFirstInString:inSet:startingAt:) (ByteString indexOfAscii:inString:startingAt:) (ByteString findSubstring:in:startingAt:matchTable:) (ByteArray hashBytes:startingWith:) + (SampledSound convert8bitSignedFrom:to16Bit:))! - (SampledSound convert8bitSignedFrom:to16Bit:) - ) - - "| tps | - 'This opens a list browser on all translated primitives in the image'. - tps := (SystemNavigation default allImplementorsOf: #translatedPrimitives) - inject: Set new - into: [:tp :mr| - tp addAll: (mr actualClass theNonMetaClass translatedPrimitives collect: - [:pair| - MethodReference - class: (((Smalltalk at: pair first) canUnderstand: pair last) - ifTrue: [Smalltalk at: pair first] - ifFalse: [(Smalltalk at: pair first) class]) - selector: pair last]); - yourself]. - SystemNavigation default browseMessageList: tps asArray sort name: 'Translated Primitives' "! Item was changed: ----- Method: SimpleStackBasedCogit>>genPrimitiveHashMultiply (in category 'primitive generators') ----- genPrimitiveHashMultiply + "Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger receivers." + | jmpFailImm jmpFailNonImm jmpNotSmallInt reenter | - | highReg jmpFailImm jmpFailNonImm jmpNotSmallInt lowReg reenter | jmpNotSmallInt := objectRepresentation genJumpNotSmallInteger: ReceiverResultReg. + objectRepresentation genConvertSmallIntegerToIntegerInReg: ReceiverResultReg. + reenter := + self MoveCq: HashMultiplyConstant R: TempReg. + self MulR: TempReg R: ReceiverResultReg. + self AndCq: HashMultiplyMask R: ReceiverResultReg. - reenter := self MoveR: ReceiverResultReg R: (highReg := Arg1Reg). - self - ArithmeticShiftRightCq: 14 R: highReg; "highReg := receiver bitShift: -14" - AndCq: 16383 R: ReceiverResultReg; - MoveR: ReceiverResultReg R: (lowReg := Arg0Reg); "lowReg := receiver bitAnd: 16383" - MoveCq: 16r260D R: TempReg; - MulR: TempReg R: ReceiverResultReg; "RRR := 16r260D * low" - MulR: TempReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14))" - MoveCq: 16r0065 R: TempReg; - MulR: TempReg R: lowReg; "lowReg := 16r0065 * low" - AddR: lowReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14)) + (16r0065 * low)" - MoveCq: 16384 R: TempReg; - MulR: TempReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14)) + (16r0065 * low)" - AddR: highReg R: ReceiverResultReg; - AndCq: 16r0FFFFFFF R: ReceiverResultReg. objectRepresentation genConvertIntegerToSmallIntegerInReg: ReceiverResultReg. self RetN: 0. + jmpNotSmallInt jmpTarget: self Label. jmpFailImm := objectRepresentation genJumpImmediate: ReceiverResultReg. objectRepresentation genGetCompactClassIndexNonImmOf: ReceiverResultReg into: ClassReg. self CmpCq: ClassLargePositiveIntegerCompactIndex R: ClassReg. jmpFailNonImm := self JumpNonZero: 0. objectRepresentation genLoadSlot: 0 sourceReg: ReceiverResultReg destReg: ReceiverResultReg. self Jump: reenter. + jmpFailImm jmpTarget: (jmpFailNonImm jmpTarget: self Label). ^0! Item was changed: ----- Method: TMethod>>argConversionExprFor:stackIndex: (in category 'primitive compilation') ----- argConversionExprFor: varName stackIndex: stackIndex "Return the parse tree for an expression that fetches and converts the primitive argument at the given stack offset." + | exprList decl type stmtList | - | exprList decl stmtList | exprList := OrderedCollection new. + ((decl := declarations at: varName ifAbsent: []) notNil + and: ['int' ~= (type := (decl copyReplaceAll: varName with: '') withBlanksTrimmed)]) + ifTrue: + [(decl includes: $*) ifTrue: "array" + [(decl includesSubString: 'char') + ifTrue: + [| expr | + expr := '(interpreterProxy isBytes: (interpreterProxy stackValue: (stackIndex))) ifFalse: [^interpreterProxy primitiveFail]'. + expr := expr copyReplaceAll: 'interpreterProxy' with: self vmNameString. + expr := expr copyReplaceAll: 'stackIndex' with: stackIndex printString. + exprList addLast: expr]. + exprList addLast: varName , ' := ', self vmNameString, ' arrayValueOf: (', self vmNameString, ' stackValue: (' , stackIndex printString , '))'. + exprList addLast: varName , ' := ' , varName , ' - 1'] "so that varName[1] is the zero'th element" + ifFalse: "must be a double" + [type ~= 'double' ifTrue: + [self error: 'unsupported type declaration in a translated primitive method']. + exprList addLast: varName , ' := ', self vmNameString, ' stackFloatValue: ' , stackIndex printString]] + ifFalse: "undeclared variables are taken to be integer" + [exprList addLast: varName , ' := ', self vmNameString, ' stackIntegerValue: ' , stackIndex printString]. - (declarations includesKey: varName) ifTrue:[ - decl := declarations at: varName. - (decl includes: $*) ifTrue:["array" - (decl includesSubString: 'char') ifTrue:[ | expr | - expr := '(interpreterProxy isBytes: (interpreterProxy stackValue: (stackIndex))) ifFalse:[^interpreterProxy primitiveFail].'. - expr := expr copyReplaceAll: 'interpreterProxy' with: self vmNameString. - expr := expr copyReplaceAll: 'stackIndex' with: stackIndex printString. - exprList add: expr. - ]. - exprList add: varName , ' := ', self vmNameString, ' arrayValueOf: (', self vmNameString, ' stackValue: (' , stackIndex printString , '))'. - exprList add: varName , ' := ' , varName , ' - 1'. - ] ifFalse:["must be a double" - (decl findString: 'double' startingAt: 1) = 0 ifTrue: [ - self error: 'unsupported type declaration in a primitive method' - ]. - exprList add: varName , ' := ', self vmNameString, ' stackFloatValue: ' , stackIndex printString. - ] - ] ifFalse: ["undeclared variables are taken to be integer" - exprList add: varName , ' := ', self vmNameString, ' stackIntegerValue: ' , stackIndex printString - ]. stmtList := OrderedCollection new. exprList do: [:e | stmtList addAll: (self statementsFor: e varName: varName)]. ^ stmtList! Item was changed: SharedPool subclass: #VMBasicConstants instanceVariableNames: '' + classVariableNames: 'BaseHeaderSize BytecodeSetHasExtensions BytesPerOop BytesPerWord COGMTVM COGVM DisownVMLockOutFullGC DoAssertionChecks DoExpensiveAssertionChecks GCCheckPrimCall GCModeBecome GCModeFreeSpace GCModeFull GCModeImageSegment GCModeIncremental GCModeNewSpace HashMultiplyConstant HashMultiplyMask IMMUTABILITY LowcodeVM MULTIPLEBYTECODESETS NewspeakVM PharoVM PrimErrBadArgument PrimErrBadIndex PrimErrBadMethod PrimErrBadNumArgs PrimErrBadReceiver PrimErrCallbackError PrimErrGenericFailure PrimErrInappropriate PrimErrLimitExceeded PrimErrNamedInternal PrimErrNoCMemory PrimErrNoMemory PrimErrNoModification PrimErrNotFound PrimErrObjectIsPinned PrimErrObjectMayMove PrimErrObjectMoved PrimErrObjectNotPinned PrimErrUnsupported PrimErrWritePastObject PrimNoErr SPURVM STACKVM SistaVM VMBIGENDIAN' - classVariableNames: 'BaseHeaderSize BytecodeSetHasExtensions BytesPerOop BytesPerWord COGMTVM COGVM DisownVMLockOutFullGC DoAssertionChecks DoExpensiveAssertionChecks GCCheckPrimCall GCModeBecome GCModeFreeSpace GCModeFull GCModeImageSegment GCModeIncremental GCModeNewSpace IMMUTABILITY LowcodeVM MULTIPLEBYTECODESETS NewspeakVM PharoVM PrimErrBadArgument PrimErrBadIndex PrimErrBadMethod PrimErrBadNumArgs PrimErrBadReceiver PrimErrCallbackError PrimErrGenericFailure PrimErrInappropriate PrimErrLimitExceeded PrimErrNamedInternal PrimErrNoCMemory PrimErrNoMemory PrimErrNoModification PrimErrNotFound PrimErrObjectIsPinned PrimErrObjectMayMove PrimErrObjectMoved PrimErrObjectNotPinned PrimErrUnsupported PrimErrWritePastObject PrimNoErr SPURVM STACKVM SistaVM VMBIGENDIAN' poolDictionaries: '' category: 'VMMaker-Interpreter'! !VMBasicConstants commentStamp: '<historical>' prior: 0! I am a shared pool for basic constants upon which the VM as a whole depends. self ensureClassPool. self classPool declare: #BytesPerWord from: VMSqueakV3ObjectRepresentationConstants classPool. self classPool declare: #BaseHeaderSize from: VMSqueakV3ObjectRepresentationConstants classPool (ObjectMemory classPool keys select: [:k| k beginsWith: 'Byte']) do: [:k| self classPool declare: k from: ObjectMemory classPool]!

1 0

VM Maker: VMMaker.oscog-eem.2196.mcz
by commits＠source.squeak.org 18 Apr '17

18 Apr '17

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.2196.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.2196 Author: eem Time: 17 April 2017, 7:13:06.452145 pm UUID: e6b24407-301d-4fef-9243-8e7765bb1ec7 Ancestors: VMMaker.oscog-eem.2195 Use genGetCompactClassIndexNonImmOf:into: in genPrimitiveHashMultiply so as to work on V3. =============== Diff against VMMaker.oscog-eem.2195 =============== Item was changed: ----- Method: SimpleStackBasedCogit>>genPrimitiveHashMultiply (in category 'primitive generators') ----- genPrimitiveHashMultiply | highReg jmpFailImm jmpFailNonImm jmpNotSmallInt lowReg reenter | jmpNotSmallInt := objectRepresentation genJumpNotSmallInteger: ReceiverResultReg. objectRepresentation genConvertSmallIntegerToIntegerInReg: ReceiverResultReg. reenter := self MoveR: ReceiverResultReg R: (highReg := Arg1Reg). self ArithmeticShiftRightCq: 14 R: highReg; "highReg := receiver bitShift: -14" AndCq: 16383 R: ReceiverResultReg; MoveR: ReceiverResultReg R: (lowReg := Arg0Reg); "lowReg := receiver bitAnd: 16383" MoveCq: 16r260D R: TempReg; MulR: TempReg R: ReceiverResultReg; "RRR := 16r260D * low" MulR: TempReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14))" MoveCq: 16r0065 R: TempReg; MulR: TempReg R: lowReg; "lowReg := 16r0065 * low" AddR: lowReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14)) + (16r0065 * low)" MoveCq: 16384 R: TempReg; MulR: TempReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14)) + (16r0065 * low)" AddR: highReg R: ReceiverResultReg; AndCq: 16r0FFFFFFF R: ReceiverResultReg. objectRepresentation genConvertIntegerToSmallIntegerInReg: ReceiverResultReg. self RetN: 0. jmpNotSmallInt jmpTarget: self Label. jmpFailImm := objectRepresentation genJumpImmediate: ReceiverResultReg. + objectRepresentation genGetCompactClassIndexNonImmOf: ReceiverResultReg into: ClassReg. - objectRepresentation genGetClassIndexOfNonImm: ReceiverResultReg into: ClassReg. self CmpCq: ClassLargePositiveIntegerCompactIndex R: ClassReg. jmpFailNonImm := self JumpNonZero: 0. objectRepresentation genLoadSlot: 0 sourceReg: ReceiverResultReg destReg: ReceiverResultReg. self Jump: reenter. jmpFailImm jmpTarget: (jmpFailNonImm jmpTarget: self Label). ^0!

2 1

[OpenSmalltalk/opensmalltalk-vm] 13e8b6: CogVM source as per VMMaker.oscog-eem.2195
by GitHub 18 Apr '17

18 Apr '17

Branch: refs/heads/Cog Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 13e8b6fd4e3556a63eeffddcb18f43c00fd517bc https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/13e8b6fd4e3556a63e… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2017-04-17 (Mon, 17 Apr 2017) Changed paths: M nsspur64src/vm/cogit.h M nsspur64src/vm/cogitX64SysV.c M nsspur64src/vm/cogitX64WIN64.c M nsspur64src/vm/cointerp.c M nsspur64src/vm/cointerp.h M nsspur64src/vm/gcc3x-cointerp.c M nsspursrc/vm/cogit.h M nsspursrc/vm/cogitARMv5.c M nsspursrc/vm/cogitIA32.c M nsspursrc/vm/cogitMIPSEL.c M nsspursrc/vm/cointerp.c M nsspursrc/vm/cointerp.h M nsspursrc/vm/gcc3x-cointerp.c M nsspurstack64src/vm/gcc3x-interp.c M nsspurstack64src/vm/interp.c M nsspurstacksrc/vm/gcc3x-interp.c M nsspurstacksrc/vm/interp.c M spur64src/vm/cogit.h M spur64src/vm/cogitX64SysV.c M spur64src/vm/cogitX64WIN64.c M spur64src/vm/cointerp.c M spur64src/vm/cointerp.h M spur64src/vm/gcc3x-cointerp.c M spurlowcode64src/vm/cogit.h M spurlowcode64src/vm/cogitX64SysV.c M spurlowcode64src/vm/cogitX64WIN64.c M spurlowcode64src/vm/cointerp.c M spurlowcode64src/vm/cointerp.h M spurlowcode64src/vm/gcc3x-cointerp.c M spurlowcodesrc/vm/cogit.h M spurlowcodesrc/vm/cogitARMv5.c M spurlowcodesrc/vm/cogitIA32.c M spurlowcodesrc/vm/cogitMIPSEL.c M spurlowcodesrc/vm/cointerp.c M spurlowcodesrc/vm/cointerp.h M spurlowcodesrc/vm/gcc3x-cointerp.c M spurlowcodestack64src/vm/gcc3x-interp.c M spurlowcodestack64src/vm/interp.c M spurlowcodestacksrc/vm/gcc3x-interp.c M spurlowcodestacksrc/vm/interp.c M spursista64src/vm/cogit.h M spursista64src/vm/cogitX64SysV.c M spursista64src/vm/cogitX64WIN64.c M spursista64src/vm/cointerp.c M spursista64src/vm/cointerp.h M spursista64src/vm/gcc3x-cointerp.c M spursistasrc/vm/cogit.h M spursistasrc/vm/cogitARMv5.c M spursistasrc/vm/cogitIA32.c M spursistasrc/vm/cogitMIPSEL.c M spursistasrc/vm/cointerp.c M spursistasrc/vm/cointerp.h M spursistasrc/vm/gcc3x-cointerp.c M spursrc/vm/cogit.h M spursrc/vm/cogitARMv5.c M spursrc/vm/cogitIA32.c M spursrc/vm/cogitMIPSEL.c M spursrc/vm/cointerp.c M spursrc/vm/cointerp.h M spursrc/vm/gcc3x-cointerp.c M spurstack64src/vm/gcc3x-interp.c M spurstack64src/vm/interp.c M spurstacksrc/vm/gcc3x-interp.c M spurstacksrc/vm/interp.c M src/vm/cogit.h M src/vm/cogitARMv5.c M src/vm/cogitIA32.c M src/vm/cogitMIPSEL.c M src/vm/cointerp.c M src/vm/cointerp.h M src/vm/cointerpmt.c M src/vm/cointerpmt.h M src/vm/gcc3x-cointerp.c M src/vm/gcc3x-cointerpmt.c M stacksrc/vm/gcc3x-interp.c M stacksrc/vm/interp.c Log Message: ----------- CogVM source as per VMMaker.oscog-eem.2195 StackInterpreter: Add hash multiply under primitive number 159. Remove PrimitiveExternalCallIndex an favour of PrimNumberExternalCall. Cogit: Fix ancient bug with non-local return in the StackToRegisterMappingCogit; the stack must be flushed before calling the non-local return trampoline. Solves some, if not all, of the stack depth mismatches on non-local return. Implement calling C primitive on Smalltalk stack support in compileMachineCodeInterpreterPrimitive:. Refactor compileInterpreterPrimitive: to compileInterpreterPrimitive:flags:, accessed via the CoInterpreter supplying the PrimCallOnSmalltalkStack flag, moving the flags extraction to compilePrimitive. Leave an unused C primitive on Smalltalk stack version of hashMultiply (mcprimHashMultiply:). Implement as machine code (genPrimitiveHashMultiply) because its significantly faster. Have compileAbstractInstructionsFrom:through: only check that extensions are consumed if the last bytecode generator succeeded. Sista: Implement ensureAllocableSlots: support. Use duff's device to generate more compact instance intialization in the inline pointer new primitive bytecode. As yet untested!! Comment the inverse form of extJumpIfNotInstanceOfBehaviorsBytecode Fix a regression in VMMaker.oscog-eem.2138 & VMMaker.oscog-eem.2143 where receiverTags work broke counter trips in special selector comparisons of known SmallIntegers. Fix mapping errors for genExtStorePopRemoteTemp & genSistaExtStoreAndPopReceiverVariableBytecode. Fix a slip in genExtEnsureAllocableSlots; get the branch sense right. Commit: bde475b8a6bae043c57ca127ea1da478ea1189f7 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/bde475b8a6bae043c5… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2017-04-17 (Mon, 17 Apr 2017) Changed paths: M platforms/unix/vm/sqUnixHeartbeat.c Log Message: ----------- Merge branch 'Cog' of http://github.com/OpenSmalltalk/vm into Cog Commit: 96eb5cc0077b3f3463791ddfe3cf19e021833797 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/96eb5cc0077b3f3463… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2017-04-17 (Mon, 17 Apr 2017) Changed paths: M src/vm/cogit.h M src/vm/cogitARMv5.c M src/vm/cogitIA32.c M src/vm/cogitMIPSEL.c Log Message: ----------- CogVM source as per VMMaker.oscog-eem.2196 Use genGetCompactClassIndexNonImmOf:into: in genPrimitiveHashMultiply so as to work on V3. Compare: https://github.com/OpenSmalltalk/opensmalltalk-vm/compare/1be1bf987fee...96…

1 0

VM Maker: VMMaker.oscog-eem.2195.mcz
by commits＠source.squeak.org 18 Apr '17

18 Apr '17

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.2195.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.2195 Author: eem Time: 17 April 2017, 5:11:48.443128 pm UUID: 6a437cbf-eb21-432f-83ea-a1d28e00b193 Ancestors: VMMaker.oscog-eem.2194 StackInterpreter: Add hash multiply under primitive number 159. Cogit: Implement calling C primitive on Smalltalk stack support in compileMachineCodeInterpreterPrimitive:. Refactor compileInterpreterPrimitive: to compileInterpreterPrimitive:flags:, accessed via the CoInterrpeter supplying the PrimCallOnSmalltalkStack flag, moving the flags extraction to compilePrimitive. Leave an unused C primitive on Smalltalk stack version of hashMultiply (mcprimHashMultiply:). Implement as machine code (genPrimitiveHashMultiply) because its significantly faster. Remove PrimitiveExternalCallIndex an favour of PrimNumberExternalCall. Sista: Use duff's device to generate more compact instane intialization in the inline pointer new primitive bytecode. As yet untested!! Comment the inverse form of extJumpIfNotInstanceOfBehaviorsBytecode Slang: Corrct a comment and a variable name in emitCAPIExportHeaderOn:. =============== Diff against VMMaker.oscog-eem.2194 =============== Item was changed: ----- Method: CCodeGenerator>>emitCAPIExportHeaderOn: (in category 'C code generator') ----- emitCAPIExportHeaderOn: aStream + "Store prototype declarations for all API methods on the given stream." + | exportedAPIMethods usedConstants | + exportedAPIMethods := self sortMethods: (methods select: [:m| m isAPIMethod]). + exportedAPIMethods do: - "Store prototype declarations for all non-inlined methods on the given stream." - | apiMethods usedConstants | - apiMethods := self sortMethods: (methods select: [:m| m isAPIMethod]). - apiMethods do: [:m| m static ifTrue: [logger ensureCr; show: m selector, ' excluded from export API because it is static'; cr]]. + self emitCFunctionPrototypes: exportedAPIMethods on: aStream. - self emitCFunctionPrototypes: apiMethods on: aStream. self emitGlobalCVariablesOn: aStream. + usedConstants := self emitCMacros: exportedAPIMethods on: aStream. - usedConstants := self emitCMacros: apiMethods on: aStream. self emitCConstants: usedConstants on: aStream! Item was changed: StackInterpreterPrimitives subclass: #CoInterpreter instanceVariableNames: 'cogit cogMethodZone gcMode cogCodeSize desiredCogCodeSize heapBase lastCoggableInterpretedBlockMethod reenterInterpreter deferSmash deferredSmash primTraceLog primTraceLogIndex traceLog traceLogIndex traceSources cogCompiledCodeCompactionCalledFor statCodeCompactionCount statCodeCompactionUsecs lastUncoggableInterpretedBlockMethod flagInterpretedMethods maxLiteralCountForCompile minBackwardJumpCountForCompile' + classVariableNames: 'CSCallbackEnter CSCallbackLeave CSCheckEvents CSEnterCriticalSection CSExitCriticalSection CSOwnVM CSResume CSSignal CSSuspend CSSwitchIfNeccessary CSThreadBind CSThreadSchedulingLoop CSWait CSYield HasBeenReturnedFromMCPC HasBeenReturnedFromMCPCOop MFMethodFlagFrameIsMarkedFlag MinBackwardJumpCountForCompile PrimNumberHashMultiply PrimTraceLogSize ReturnToInterpreter RumpCStackSize TraceBlockActivation TraceBlockCreation TraceBufferSize TraceCodeCompaction TraceContextSwitch TraceDisownVM TraceFullGC TraceIncrementalGC TraceIsFromInterpreter TraceIsFromMachineCode TraceOwnVM TracePreemptDisowningThread TracePrimitiveFailure TracePrimitiveRetry TraceSources TraceStackOverflow TraceThreadSwitch TraceVMCallback TraceVMCallbackReturn' - classVariableNames: 'CSCallbackEnter CSCallbackLeave CSCheckEvents CSEnterCriticalSection CSExitCriticalSection CSOwnVM CSResume CSSignal CSSuspend CSSwitchIfNeccessary CSThreadBind CSThreadSchedulingLoop CSWait CSYield HasBeenReturnedFromMCPC HasBeenReturnedFromMCPCOop MFMethodFlagFrameIsMarkedFlag MinBackwardJumpCountForCompile PrimTraceLogSize ReturnToInterpreter RumpCStackSize TraceBlockActivation TraceBlockCreation TraceBufferSize TraceCodeCompaction TraceContextSwitch TraceDisownVM TraceFullGC TraceIncrementalGC TraceIsFromInterpreter TraceIsFromMachineCode TraceOwnVM TracePreemptDisowningThread TracePrimitiveFailure TracePrimitiveRetry TraceSources TraceStackOverflow TraceThreadSwitch TraceVMCallback TraceVMCallbackReturn' poolDictionaries: 'CogMethodConstants VMStackFrameOffsets' category: 'VMMaker-JIT'! !CoInterpreter commentStamp: '<historical>' prior: 0! I am a variant of the StackInterpreter that can co-exist with the Cog JIT. I interpret unjitted methods, either because they have been found for the first time or because they are judged to be too big to JIT. See CogMethod class's comment for method interoperability.! Item was changed: ----- Method: CoInterpreter class>>initializeMiscConstants (in category 'initialization') ----- initializeMiscConstants super initializeMiscConstants. COGVM := true. MinBackwardJumpCountForCompile := 40. MaxNumArgs := 15. PrimCallNeedsNewMethod := 1. PrimCallNeedsPrimitiveFunction := 2. PrimCallMayCallBack := 4. + PrimCallOnSmalltalkStack := 8. + PrimCallCollectsProfileSamples := 16. + CheckAllocationFillerAfterPrimCall := 32. + PrimCallDoNotJIT := 64. - PrimCallCollectsProfileSamples := 8. - CheckAllocationFillerAfterPrimCall := 16. - PrimCallDoNotJIT := 32. ReturnToInterpreter := 1. "setjmp/longjmp code." PrimTraceLogSize := 256. "Room for 256 selectors. Must be 256 because we use a byte to hold the index" TraceBufferSize := 256 * 3. "Room for 256 events" TraceContextSwitch := self objectMemoryClass basicNew integerObjectOf: 1. TraceBlockActivation := self objectMemoryClass basicNew integerObjectOf: 2. TraceBlockCreation := self objectMemoryClass basicNew integerObjectOf: 3. TraceIncrementalGC := self objectMemoryClass basicNew integerObjectOf: 4. TraceFullGC := self objectMemoryClass basicNew integerObjectOf: 5. TraceCodeCompaction := self objectMemoryClass basicNew integerObjectOf: 6. TraceOwnVM := self objectMemoryClass basicNew integerObjectOf: 7. TraceDisownVM := self objectMemoryClass basicNew integerObjectOf: 8. TraceThreadSwitch := self objectMemoryClass basicNew integerObjectOf: 9. TracePreemptDisowningThread := self objectMemoryClass basicNew integerObjectOf: 10. TraceVMCallback := self objectMemoryClass basicNew integerObjectOf: 11. TraceVMCallbackReturn := self objectMemoryClass basicNew integerObjectOf: 12. TraceStackOverflow := self objectMemoryClass basicNew integerObjectOf: 13. TracePrimitiveFailure := self objectMemoryClass basicNew integerObjectOf: 14. TracePrimitiveRetry := self objectMemoryClass basicNew integerObjectOf: 15. TraceIsFromMachineCode := 1. TraceIsFromInterpreter := 2. CSCallbackEnter := 3. CSCallbackLeave := 4. CSEnterCriticalSection := 5. CSExitCriticalSection := 6. CSResume := 7. CSSignal := 8. CSSuspend := 9. CSWait := 10. CSYield := 11. CSCheckEvents := 12. CSThreadSchedulingLoop := 13. CSOwnVM := 14. CSThreadBind := 15. CSSwitchIfNeccessary := 16. TraceSources := CArrayAccessor on: #('?' 'm' 'i' 'callbackEnter' 'callbackLeave' 'enterCritical' 'exitCritical' 'resume' 'signal' 'suspend' 'wait' 'yield' 'eventcheck' 'threadsched' 'ownVM' 'bindToThread' 'switchIfNecessary'). "this is simulation only" RumpCStackSize := 4096! Item was changed: ----- Method: CoInterpreter class>>initializePrimitiveTable (in category 'initialization') ----- initializePrimitiveTable super initializePrimitiveTable. + PrimNumberHashMultiply := 159. + self assert: (PrimitiveTable at: PrimNumberHashMultiply + 1) = #primitiveHashMultiply. + #(216 253) do: [:pidx| self assert: (PrimitiveTable at: pidx + 1) = #primitiveFail]. self assert: (PrimitiveTable at: 215 + 1) = #primitiveFlushCacheByMethod. PrimitiveTable at: 253 + 1 put: #primitiveCollectCogCodeConstituents; at: 215 + 1 put: #primitiveVoidVMStateForMethod; at: 216 + 1 put: #primitiveMethodXray! Item was changed: ----- Method: CoInterpreter>>flushExternalPrimitiveOf: (in category 'plugin primitive support') ----- flushExternalPrimitiveOf: methodObj "methodObj is a CompiledMethod containing an external primitive. Flush the function address and session ID of the CM. Override to also flush the machine code call if one exists." <api> | primIdx | primIdx := super flushExternalPrimitiveOf: methodObj. + (primIdx = PrimNumberExternalCall - (primIdx = PrimitiveExternalCallIndex and: [self methodHasCogMethod: methodObj]) ifTrue: [cogit rewritePrimInvocationIn: (self cogMethodOf: methodObj) to: #primitiveExternalCall]! Item was added: + ----- Method: CoInterpreter>>mcprimFunctionForPrimitiveIndex: (in category 'cog jit support') ----- + mcprimFunctionForPrimitiveIndex: primIndex + <api> + primIndex = PrimNumberHashMultiply ifTrue: + [^#mcprimHashMultiply:]. + self error: 'unknown mcprim'. + ^nil! Item was changed: ----- Method: CoInterpreter>>primitivePropertyFlagsForSpur: (in category 'cog jit support') ----- primitivePropertyFlagsForSpur: primIndex <inline: true> "Answer any special requirements of the given primitive. Spur always needs to set primitiveFunctionPointer and newMethod so primitives can retry on failure due to forwarders." | baseFlags | + self cCode: [] inSmalltalk: [#(mcprimHashMultiply: primitiveExternalCall primitiveCalloutToFFI)]. "For senders..." + primIndex = PrimNumberHashMultiply ifTrue: + [^PrimCallOnSmalltalkStack]. baseFlags := PrimCallNeedsPrimitiveFunction + PrimCallNeedsNewMethod. profileSemaphore ~= objectMemory nilObject ifTrue: [baseFlags := baseFlags bitOr: PrimCallCollectsProfileSamples]. - self cCode: [] inSmalltalk: [#(primitiveExternalCall primitiveCalloutToFFI)]. "For senders..." (primIndex = PrimNumberExternalCall "#primitiveExternalCall" or: [primIndex = PrimNumberFFICall "#primitiveCalloutToFFI"]) ifTrue: "For callbacks" [baseFlags := baseFlags bitOr: PrimCallMayCallBack. checkAllocFiller ifTrue: [baseFlags := baseFlags bitOr: CheckAllocationFillerAfterPrimCall]]. ^baseFlags! Item was added: + ----- Method: CoInterpreterPrimitives>>mcprimHashMultiply: (in category 'arithmetic primitives') ----- + mcprimHashMultiply: receiverArg + "Machine code primitive for hash multiply. c.f. primitiveHashMultiply. + mcprims consume receiver and arguments as parameters and answer the + result on success, or set the primitive error code and answer 0 on failure." + "Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger receivers." + <api> + | receiver low | + (objectMemory isIntegerObject: receiverArg) + ifTrue: [receiver := objectMemory integerValueOf: receiverArg] + ifFalse: + [| ok | + ok := objectMemory is: receiverArg instanceOf: (objectMemory splObj: ClassLargePositiveInteger) compactClassIndex: ClassLargePositiveIntegerCompactIndex. + ok ifFalse: + [self primitiveFailFor: PrimErrBadReceiver. + ^0]. + receiver := objectMemory byteSwapped32IfBigEndian: (objectMemory fetchLong32: 0 ofObject: receiverArg)]. + low := receiver bitAnd: 16383. + "N.B. We use undefined behaviour assuming the compiler will still generate a multiply, rather than simply crap out, so as to save the unnecessary bitAnd: 16383." + ^objectMemory integerObjectOf: ((16r260D * low + ((16r260D * (receiver bitShift: -14) + (16r0065 * low) "bitAnd: 16383") * 16384)) bitAnd: 16r0FFFFFFF)! Item was changed: SharedPool subclass: #CogMethodConstants instanceVariableNames: '' + classVariableNames: 'CMBlock CMClosedPIC CMFree CMMaxUsageCount CMMethod CMOpenPIC CheckAllocationFillerAfterPrimCall CompletePrimitive EncounteredUnknownBytecode InsufficientCodeSpace MaxLiteralCountForCompile MaxMethodSize MaxNegativeErrorCode MaxNumArgs MaxStackCheckOffset MethodTooBig NotFullyInitialized PrimCallCollectsProfileSamples PrimCallDoNotJIT PrimCallMayCallBack PrimCallNeedsNewMethod PrimCallNeedsPrimitiveFunction PrimCallOnSmalltalkStack ShouldNotJIT UnfailingPrimitive UnimplementedPrimitive YoungSelectorInPIC' - classVariableNames: 'CMBlock CMClosedPIC CMFree CMMaxUsageCount CMMethod CMOpenPIC CheckAllocationFillerAfterPrimCall CompletePrimitive EncounteredUnknownBytecode InsufficientCodeSpace MaxLiteralCountForCompile MaxMethodSize MaxNegativeErrorCode MaxNumArgs MaxStackCheckOffset MethodTooBig NotFullyInitialized PrimCallCollectsProfileSamples PrimCallDoNotJIT PrimCallMayCallBack PrimCallNeedsNewMethod PrimCallNeedsPrimitiveFunction ShouldNotJIT UnfailingPrimitive UnimplementedPrimitive YoungSelectorInPIC' poolDictionaries: '' category: 'VMMaker-JIT'! Item was added: + ----- Method: CogObjectRepresentation>>genPrimitiveHashMultiply (in category 'primitive generators') ----- + genPrimitiveHashMultiply + <doNotGenerate> + ^cogit genPrimitiveHashMultiply! Item was added: + ----- Method: CogObjectRepresentationForSpur>>genGetInstanceOfFixedClass:into:initializingIf: (in category 'bytecode generator support') ----- + genGetInstanceOfFixedClass: classObj into: destReg initializingIf: initializeInstance + "Create an instance of classObj and assign it to destReg, initializing the instance + if initializeInstance is true with nil or 0 as appropriate This is for inline primitives. + Assume there is sufficient space in new space to complete the operation. + Answer zero on success." + | classIndex classFormat header slots branch constReg inst loop delta loopCount slotsPerIteration | + ((objectMemory isNonImmediate: classObj) + and: [(coInterpreter objCouldBeClassObj: classObj) + and: [(classIndex := objectMemory rawHashBitsOf: classObj) ~= 0 + and: [(objectMemory isFixedSizePointerFormat: (objectMemory instSpecOfClassFormat: (classFormat := objectMemory formatOfClass: classObj))) + and: [(slots := objectMemory fixedFieldsOfClassFormat: classFormat) < objectMemory numSlotsMask]]]]) ifFalse: + [^UnimplementedOperation]. + + header := objectMemory + headerForSlots: slots + format: (objectMemory instSpecOfClassFormat: classFormat) + classIndex: classIndex. + + cogit MoveAw: objectMemory freeStartAddress R: destReg. + self genStoreHeader: header intoNewInstance: destReg using: TempReg. + cogit + LoadEffectiveAddressMw: (objectMemory smallObjectBytesForSlots: slots) r: destReg R: TempReg; + MoveR: TempReg Aw: objectMemory freeStartAddress. + (initializeInstance and: [slots > 0]) ifFalse: + [^0]. + slots <= (slotsPerIteration := 8) ifTrue: "slotsPerIteration must be a power of two. see bitAnd: below" + [cogit genMoveConstant: objectMemory nilObject R: TempReg. + 0 to: slots - 1 do: + [:i| cogit MoveR: TempReg + Mw: i * objectMemory wordSize + objectMemory baseHeaderSize + r: destReg]. + ^0]. + constReg := cogit allocateRegNotConflictingWith: destReg. + cogit genMoveConstant: objectMemory nilObject R: constReg. + + slots \\ slotsPerIteration ~= 0 + ifTrue: + [delta := objectMemory baseHeaderSize - ((slotsPerIteration - (slots \\ slotsPerIteration) bitAnd: slotsPerIteration - 1) * objectMemory bytesPerOop). + delta ~= 0 ifTrue: + [cogit AddCq: delta R: destReg]. + branch := cogit Jump: 0] + ifFalse: + [delta := objectMemory baseHeaderSize. + cogit AddCq: objectMemory baseHeaderSize R: destReg]. + loopCount := slots + slotsPerIteration - 1 // slotsPerIteration. + self assert: loopCount > 1. + loop := cogit Label. + 0 to: 7 do: + [:i| + inst := cogit MoveR: constReg Mw: i * objectMemory bytesPerOop r: destReg. + slotsPerIteration - (slots \\ slotsPerIteration) = i ifTrue: + [branch jmpTarget: inst]]. + "N.B. We get away with comparing against TempReg, which points to the start of the next + object, not necessarily immediately after the last slot, because if the size is a multiple of 8, + TempReg will point after the last slot, and if the size is not a multiple of 8 then the add of + slotsPerIteration * objectMemory bytesPerOop will put destReg beyond TempReg any way." + cogit + AddCq: slotsPerIteration * objectMemory bytesPerOop R: destReg; + CmpR: TempReg R: destReg; + JumpBelow: loop; + SubCq: delta + (loopCount * slotsPerIteration * objectMemory bytesPerOop) R: destReg. + ^0! Item was added: + ----- Method: CogVMSimulator>>mcprimFunctionForPrimitiveIndex: (in category 'cog jit support') ----- + mcprimFunctionForPrimitiveIndex: primIndex + ^self mapFunctionToAddress: (super mcprimFunctionForPrimitiveIndex: primIndex)! Item was added: + ----- Method: InterpreterPrimitives>>primitiveHashMultiply (in category 'arithmetic integer primitives') ----- + primitiveHashMultiply + "Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger receivers." + | receiver low result | + receiver := self stackTop. + (objectMemory isIntegerObject: receiver) + ifTrue: [receiver := objectMemory integerValueOf: receiver] + ifFalse: + [| ok | + ok := objectMemory is: receiver instanceOf: (objectMemory splObj: ClassLargePositiveInteger) compactClassIndex: ClassLargePositiveIntegerCompactIndex. + ok ifFalse: + [^self primitiveFailFor: PrimErrBadReceiver]. + receiver := objectMemory byteSwapped32IfBigEndian: (objectMemory fetchLong32: 0 ofObject: receiver)]. + low := receiver bitAnd: 16383. + "N.B. We use undefined behaviour assuming the compiler will still generate a multiply, rather than simply crap out, so as to save the unnecessary bitAnd: 16383." + result := (16r260D * low + ((16r260D * (receiver bitShift: -14) + (16r0065 * low) "bitAnd: 16383") * 16384)) bitAnd: 16r0FFFFFFF. + self pop: 1 thenPush: (objectMemory integerObjectOf: result)! Item was changed: Cogit subclass: #SimpleStackBasedCogit instanceVariableNames: 'primitiveGeneratorTable primSetFunctionLabel primInvokeInstruction externalPrimCallOffsets externalPrimJumpOffsets externalSetPrimOffsets introspectionDataIndex introspectionData' classVariableNames: '' + poolDictionaries: 'VMMethodCacheConstants VMObjectIndices VMSqueakClassIndices' - poolDictionaries: 'VMMethodCacheConstants VMObjectIndices' category: 'VMMaker-JIT'! !SimpleStackBasedCogit commentStamp: '<historical>' prior: 0! I am the stage one JIT for Cog that does not attempt to eliminate the stack via deferred code generation.! Item was changed: ----- Method: SimpleStackBasedCogit class>>initializePrimitiveTableForSqueak (in category 'class initialization') ----- initializePrimitiveTableForSqueak "Initialize the table of primitive generators. This does not include normal primitives implemented in the coInterpreter. N.B. primitives that don't have an explicit arg count (the integer following the generator) may be variadic." "SimpleStackBasedCogit initializePrimitiveTableForSqueak" MaxCompiledPrimitiveIndex := self objectRepresentationClass wordSize = 8 ifTrue: [555] ifFalse: [222]. primitiveTable := CArrayAccessor on: (Array new: MaxCompiledPrimitiveIndex + 1). self table: primitiveTable from: #( "Integer Primitives (0-19)" (1 genPrimitiveAdd 1) (2 genPrimitiveSubtract 1) (3 genPrimitiveLessThan 1) (4 genPrimitiveGreaterThan 1) (5 genPrimitiveLessOrEqual 1) (6 genPrimitiveGreaterOrEqual 1) (7 genPrimitiveEqual 1) (8 genPrimitiveNotEqual 1) (9 genPrimitiveMultiply 1) (10 genPrimitiveDivide 1) (11 genPrimitiveMod 1) (12 genPrimitiveDiv 1) (13 genPrimitiveQuo 1) (14 genPrimitiveBitAnd 1) (15 genPrimitiveBitOr 1) (16 genPrimitiveBitXor 1) (17 genPrimitiveBitShift 1) "(18 primitiveMakePoint)" "(19 primitiveFail)" "Guard primitive for simulation -- *must* fail" "LargeInteger Primitives (20-39)" "(20 primitiveFail)" "(21 primitiveAddLargeIntegers)" "(22 primitiveSubtractLargeIntegers)" "(23 primitiveLessThanLargeIntegers)" "(24 primitiveGreaterThanLargeIntegers)" "(25 primitiveLessOrEqualLargeIntegers)" "(26 primitiveGreaterOrEqualLargeIntegers)" "(27 primitiveEqualLargeIntegers)" "(28 primitiveNotEqualLargeIntegers)" "(29 primitiveMultiplyLargeIntegers)" "(30 primitiveDivideLargeIntegers)" "(31 primitiveModLargeIntegers)" "(32 primitiveDivLargeIntegers)" "(33 primitiveQuoLargeIntegers)" "(34 primitiveBitAndLargeIntegers)" "(35 primitiveBitOrLargeIntegers)" "(36 primitiveBitXorLargeIntegers)" "(37 primitiveBitShiftLargeIntegers)" "Float Primitives (38-59)" "(38 genPrimitiveFloatAt)" "(39 genPrimitiveFloatAtPut)" (40 genPrimitiveAsFloat 0) (41 genPrimitiveFloatAdd 1) (42 genPrimitiveFloatSubtract 1) (43 genPrimitiveFloatLessThan 1) (44 genPrimitiveFloatGreaterThan 1) (45 genPrimitiveFloatLessOrEqual 1) (46 genPrimitiveFloatGreaterOrEqual 1) (47 genPrimitiveFloatEqual 1) (48 genPrimitiveFloatNotEqual 1) (49 genPrimitiveFloatMultiply 1) (50 genPrimitiveFloatDivide 1) "(51 genPrimitiveTruncated)" "(52 genPrimitiveFractionalPart)" "(53 genPrimitiveExponent)" "(54 genPrimitiveTimesTwoPower)" (55 genPrimitiveFloatSquareRoot 0) "(56 genPrimitiveSine)" "(57 genPrimitiveArctan)" "(58 genPrimitiveLogN)" "(59 genPrimitiveExp)" "Subscript and Stream Primitives (60-67)" (60 genPrimitiveAt 1) (61 genPrimitiveAtPut 2) (62 genPrimitiveSize 0) (63 genPrimitiveStringAt 1) (64 genPrimitiveStringAtPut 2) "The stream primitives no longer pay their way; normal Smalltalk code is faster." (65 genFastPrimFail)"was primitiveNext" (66 genFastPrimFail) "was primitiveNextPut" (67 genFastPrimFail) "was primitiveAtEnd" "StorageManagement Primitives (68-79)" (68 genPrimitiveObjectAt 1) "Good for debugger/InstructionStream performance" "(69 primitiveObjectAtPut)" (70 genPrimitiveNew 0) (71 genPrimitiveNewWithArg 1) "(72 primitiveArrayBecomeOneWay)" "Blue Book: primitiveBecome" "(73 primitiveInstVarAt)" "(74 primitiveInstVarAtPut)" (75 genPrimitiveIdentityHash 0) "(76 primitiveStoreStackp)" "Blue Book: primitiveAsObject" "(77 primitiveSomeInstance)" "(78 primitiveNextInstance)" (79 genPrimitiveNewMethod 2) "Control Primitives (80-89)" "(80 primitiveFail)" "Blue Book: primitiveBlockCopy" "(81 primitiveFail)" "Blue Book: primitiveValue" "(82 primitiveFail)" "Blue Book: primitiveValueWithArgs" (83 genPrimitivePerform) "(84 primitivePerformWithArgs)" "(85 primitiveSignal)" "(86 primitiveWait)" "(87 primitiveResume)" "(88 primitiveSuspend)" "(89 primitiveFlushCache)" "System Primitives (110-119)" (110 genPrimitiveIdentical 1) (111 genPrimitiveClass) "Support both class and Context>>objectClass:" "(112 primitiveBytesLeft)" "(113 primitiveQuit)" "(114 primitiveExitToDebugger)" "(115 primitiveChangeClass)" "Blue Book: primitiveOopsLeft" "(116 primitiveFlushCacheByMethod)" "(117 primitiveExternalCall)" "(118 primitiveDoPrimitiveWithArgs)" "(119 primitiveFlushCacheSelective)" (148 genPrimitiveShallowCopy 0) "a.k.a. clone" + (159 genPrimitiveHashMultiply 0) + (169 genPrimitiveNotIdentical 1) (170 genPrimitiveAsCharacter) "SmallInteger>>asCharacter, Character class>>value:" (171 genPrimitiveImmediateAsInteger 0) "Character>>value SmallFloat64>>asInteger" "(173 primitiveSlotAt 1)" "(174 primitiveSlotAtPut 2)" (175 genPrimitiveIdentityHash 0) "Behavior>>identityHash" "Old closure primitives" "(186 primitiveFail)" "was primitiveClosureValue" "(187 primitiveFail)" "was primitiveClosureValueWithArgs" "Perform method directly" "(188 primitiveExecuteMethodArgsArray)" "(189 primitiveExecuteMethod)" "Unwind primitives" "(195 primitiveFindNextUnwindContext)" "(196 primitiveTerminateTo)" "(197 primitiveFindHandlerContext)" (198 genFastPrimFail "primitiveMarkUnwindMethod") (199 genFastPrimFail "primitiveMarkHandlerMethod") "new closure primitives" "(200 primitiveClosureCopyWithCopiedValues)" (201 genPrimitiveClosureValue 0) "value" (202 genPrimitiveClosureValue 1) "value:" (203 genPrimitiveClosureValue 2) "value:value:" (204 genPrimitiveClosureValue 3) "value:value:value:" (205 genPrimitiveClosureValue 4) "value:value:value:value:" "(206 genPrimitiveClosureValueWithArgs)" "valueWithArguments:" (207 genPrimitiveFullClosureValue) "value[:value:value:value:] et al" "(208 genPrimitiveFullClosureValueWithArgs)" "valueWithArguments:" (209 genPrimitiveFullClosureValue) "valueNoContextSwitch[:value:] et al" "(210 primitiveContextAt)" "(211 primitiveContextAtPut)" "(212 primitiveContextSize)" "(218 primitiveDoNamedPrimitiveWithArgs)" "(219 primitiveFail)" "reserved for Cog primitives" "(220 primitiveFail)" "reserved for Cog primitives" (221 genPrimitiveClosureValue 0) "valueNoContextSwitch" (222 genPrimitiveClosureValue 1) "valueNoContextSwitch:" "SmallFloat primitives (540-559)" (541 genPrimitiveSmallFloatAdd 1) (542 genPrimitiveSmallFloatSubtract 1) (543 genPrimitiveSmallFloatLessThan 1) (544 genPrimitiveSmallFloatGreaterThan 1) (545 genPrimitiveSmallFloatLessOrEqual 1) (546 genPrimitiveSmallFloatGreaterOrEqual 1) (547 genPrimitiveSmallFloatEqual 1) (548 genPrimitiveSmallFloatNotEqual 1) (549 genPrimitiveSmallFloatMultiply 1) (550 genPrimitiveSmallFloatDivide 1) "(551 genPrimitiveSmallFloatTruncated 0)" "(552 genPrimitiveSmallFloatFractionalPart 0)" "(553 genPrimitiveSmallFloatExponent 0)" "(554 genPrimitiveSmallFloatTimesTwoPower 1)" (555 genPrimitiveSmallFloatSquareRoot 0) "(556 genPrimitiveSmallFloatSine 0)" "(557 genPrimitiveSmallFloatArctan 0)" "(558 genPrimitiveSmallFloatLogN 0)" "(559 genPrimitiveSmallFloatExp 0)" )! Item was removed: - ----- Method: SimpleStackBasedCogit>>compileInterpreterPrimitive: (in category 'primitive generators') ----- - compileInterpreterPrimitive: primitiveRoutine - "Compile a call to an interpreter primitive. Call the C routine with the - usual stack-switching dance, test the primFailCode and then either - return on success or continue to the method body." - <var: #primitiveRoutine declareC: 'void (*primitiveRoutine)(void)'> - | flags jmp jmpSamplePrim continuePostSamplePrim jmpSampleNonPrim continuePostSampleNonPrim | - <var: #jmp type: #'AbstractInstruction *'> - <var: #jmpSamplePrim type: #'AbstractInstruction *'> - <var: #jmpSampleNonPrim type: #'AbstractInstruction *'> - <var: #continuePostSamplePrim type: #'AbstractInstruction *'> - <var: #continuePostSampleNonPrim type: #'AbstractInstruction *'> - - "Save processor fp, sp and return pc in the interpreter's frame stack and instruction pointers" - self genExternalizePointersForPrimitiveCall. - "Switch to the C stack." - self genLoadCStackPointersForPrimCall. - - flags := coInterpreter primitivePropertyFlags: primitiveIndex. - (flags anyMask: PrimCallDoNotJIT) ifTrue: - [^ShouldNotJIT]. - - (flags anyMask: PrimCallCollectsProfileSamples) ifTrue: - ["Test nextProfileTick for being non-zero and call checkProfileTick if so" - objectMemory wordSize = 4 - ifTrue: - [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. - self MoveAw: coInterpreter nextProfileTickAddress + objectMemory wordSize R: ClassReg. - self OrR: TempReg R: ClassReg] - ifFalse: - [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. - self CmpCq: 0 R: TempReg]. - "If set, jump to record sample call." - jmpSampleNonPrim := self JumpNonZero: 0. - continuePostSampleNonPrim := self Label]. - - "Old full prim trace is in VMMaker-eem.550 and prior" - self recordPrimTrace ifTrue: - [self genFastPrimTraceUsing: ClassReg and: SendNumArgsReg]. - - "Clear the primFailCode and set argumentCount" - self MoveCq: 0 R: TempReg. - self MoveR: TempReg Aw: coInterpreter primFailCodeAddress. - methodOrBlockNumArgs ~= 0 ifTrue: - [self MoveCq: methodOrBlockNumArgs R: TempReg]. - self MoveR: TempReg Aw: coInterpreter argumentCountAddress. - - "If required, set primitiveFunctionPointer and newMethod" - (flags anyMask: PrimCallNeedsPrimitiveFunction) ifTrue: - [self MoveCw: primitiveRoutine asInteger R: TempReg. - primSetFunctionLabel := - self MoveR: TempReg Aw: coInterpreter primitiveFunctionPointerAddress]. - (flags anyMask: PrimCallNeedsNewMethod+PrimCallMayCallBack) ifTrue: - ["The ceActivateFailingPrimitiveMethod: machinery can't handle framelessness." - (flags anyMask: PrimCallMayCallBack) ifTrue: - [needsFrame := true]. - methodLabel addDependent: - (self annotateAbsolutePCRef: - (self MoveCw: methodLabel asInteger R: ClassReg)). - self MoveMw: (self offset: CogMethod of: #methodObject) r: ClassReg R: TempReg. - self MoveR: TempReg Aw: coInterpreter newMethodAddress]. - - "Invoke the primitive" - self PrefetchAw: coInterpreter primFailCodeAddress. - (flags anyMask: PrimCallMayCallBack) - ifTrue: "Sideways call the C primitive routine so that we return through cePrimReturnEnterCogCode." - ["On Spur ceActivateFailingPrimitiveMethod: would like to retry if forwarders - are found. So insist on PrimCallNeedsPrimitiveFunction being set too." - self assert: (flags anyMask: PrimCallNeedsPrimitiveFunction). - backEnd genSubstituteReturnAddress: - ((flags anyMask: PrimCallCollectsProfileSamples) - ifTrue: [cePrimReturnEnterCogCodeProfiling] - ifFalse: [cePrimReturnEnterCogCode]). - primInvokeInstruction := self JumpFullRT: primitiveRoutine asInteger. - jmp := jmpSamplePrim := continuePostSamplePrim := nil] - ifFalse: - ["Call the C primitive routine." - primInvokeInstruction := self CallFullRT: primitiveRoutine asInteger. - (flags anyMask: PrimCallCollectsProfileSamples) ifTrue: - [self assert: (flags anyMask: PrimCallNeedsNewMethod). - "Test nextProfileTick for being non-zero and call checkProfileTick if so" - objectMemory wordSize = 4 - ifTrue: - [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. - self MoveAw: coInterpreter nextProfileTickAddress + objectMemory wordSize R: ClassReg. - self OrR: TempReg R: ClassReg] - ifFalse: - [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. - self CmpCq: 0 R: TempReg]. - "If set, jump to record sample call." - jmpSamplePrim := self JumpNonZero: 0. - continuePostSamplePrim := self Label]. - objectRepresentation maybeCompileRetryOnPrimitiveFail: primitiveIndex. - self maybeCompileAllocFillerCheck. - "Switch back to the Smalltalk stack. Stack better be in either of these two states: - success: stackPointer -> result (was receiver) - arg1 - ... - argN - return pc - failure: receiver - arg1 - ... - stackPointer -> argN - return pc - In either case we can push the instructionPointer or load it into the LinkRegister to reestablish the return pc" - self MoveAw: coInterpreter instructionPointerAddress - R: (backEnd hasLinkRegister ifTrue: [LinkReg] ifFalse: [ClassReg]). - backEnd genLoadStackPointers. - "Test primitive failure" - self MoveAw: coInterpreter primFailCodeAddress R: TempReg. - backEnd hasLinkRegister ifFalse: [self PushR: ClassReg]. "Restore return pc on CISCs" - self flag: 'ask concrete code gen if move sets condition codes?'. - self CmpCq: 0 R: TempReg. - jmp := self JumpNonZero: 0. - "Fetch result from stack" - self MoveMw: (backEnd hasLinkRegister ifTrue: [0] ifFalse: [objectMemory wordSize]) - r: SPReg - R: ReceiverResultReg. - self RetN: objectMemory wordSize]. "return to caller, popping receiver" - - (flags anyMask: PrimCallCollectsProfileSamples) ifTrue: - ["The sample is collected by cePrimReturnEnterCogCode for external calls" - jmpSamplePrim ifNotNil: - ["Call ceCheckProfileTick: to record sample and then continue." - jmpSamplePrim jmpTarget: self Label. - self assert: (flags anyMask: PrimCallNeedsNewMethod). - self CallFullRT: (self cCode: [#ceCheckProfileTick asUnsignedIntegerPtr] - inSmalltalk: [self simulatedTrampolineFor: #ceCheckProfileTick]). - "reenter the post-primitive call flow" - self Jump: continuePostSamplePrim]. - "Null newMethod and call ceCheckProfileTick: to record sample and then continue. - ceCheckProfileTick will map null/0 to coInterpreter nilObject" - jmpSampleNonPrim jmpTarget: self Label. - self MoveCq: 0 R: TempReg. - self MoveR: TempReg Aw: coInterpreter newMethodAddress. - self CallFullRT: (self cCode: [#ceCheckProfileTick asUnsignedIntegerPtr] - inSmalltalk: [self simulatedTrampolineFor: #ceCheckProfileTick]). - "reenter the post-primitive call flow" - self Jump: continuePostSampleNonPrim]. - - jmp ifNotNil: - ["Jump to restore of receiver reg and proceed to frame build for failure." - jmp jmpTarget: self Label. - "Restore receiver reg from stack. If on RISCs ret pc is in LinkReg, if on CISCs ret pc is on stack." - self MoveMw: objectMemory wordSize * (methodOrBlockNumArgs + (backEnd hasLinkRegister ifTrue: [0] ifFalse: [1])) - r: SPReg - R: ReceiverResultReg]. - ^0! Item was added: + ----- Method: SimpleStackBasedCogit>>compileInterpreterPrimitive:flags: (in category 'primitive generators') ----- + compileInterpreterPrimitive: primitiveRoutine flags: flags + "Compile a call to an interpreter primitive. Call the C routine with the + usual stack-switching dance, test the primFailCode and then either + return on success or continue to the method body." + <var: #primitiveRoutine declareC: 'void (*primitiveRoutine)(void)'> + | jmp jmpSamplePrim continuePostSamplePrim jmpSampleNonPrim continuePostSampleNonPrim | + <var: #jmp type: #'AbstractInstruction *'> + <var: #jmpSamplePrim type: #'AbstractInstruction *'> + <var: #jmpSampleNonPrim type: #'AbstractInstruction *'> + <var: #continuePostSamplePrim type: #'AbstractInstruction *'> + <var: #continuePostSampleNonPrim type: #'AbstractInstruction *'> + + "Save processor fp, sp and return pc in the interpreter's frame stack and instruction pointers" + self genExternalizePointersForPrimitiveCall. + "Switch to the C stack." + self genLoadCStackPointersForPrimCall. + + (flags anyMask: PrimCallCollectsProfileSamples) ifTrue: + ["Test nextProfileTick for being non-zero and call checkProfileTick if so" + objectMemory wordSize = 4 + ifTrue: + [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. + self MoveAw: coInterpreter nextProfileTickAddress + objectMemory wordSize R: ClassReg. + self OrR: TempReg R: ClassReg] + ifFalse: + [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. + self CmpCq: 0 R: TempReg]. + "If set, jump to record sample call." + jmpSampleNonPrim := self JumpNonZero: 0. + continuePostSampleNonPrim := self Label]. + + "Old full prim trace is in VMMaker-eem.550 and prior" + self recordPrimTrace ifTrue: + [self genFastPrimTraceUsing: ClassReg and: SendNumArgsReg]. + + "Clear the primFailCode and set argumentCount" + self MoveCq: 0 R: TempReg. + self MoveR: TempReg Aw: coInterpreter primFailCodeAddress. + methodOrBlockNumArgs ~= 0 ifTrue: + [self MoveCq: methodOrBlockNumArgs R: TempReg]. + self MoveR: TempReg Aw: coInterpreter argumentCountAddress. + + "If required, set primitiveFunctionPointer and newMethod" + (flags anyMask: PrimCallNeedsPrimitiveFunction) ifTrue: + [self MoveCw: primitiveRoutine asInteger R: TempReg. + primSetFunctionLabel := + self MoveR: TempReg Aw: coInterpreter primitiveFunctionPointerAddress]. + (flags anyMask: PrimCallNeedsNewMethod+PrimCallMayCallBack) ifTrue: + ["The ceActivateFailingPrimitiveMethod: machinery can't handle framelessness." + (flags anyMask: PrimCallMayCallBack) ifTrue: + [needsFrame := true]. + methodLabel addDependent: + (self annotateAbsolutePCRef: + (self MoveCw: methodLabel asInteger R: ClassReg)). + self MoveMw: (self offset: CogMethod of: #methodObject) r: ClassReg R: TempReg. + self MoveR: TempReg Aw: coInterpreter newMethodAddress]. + + "Invoke the primitive" + self PrefetchAw: coInterpreter primFailCodeAddress. + (flags anyMask: PrimCallMayCallBack) + ifTrue: "Sideways call the C primitive routine so that we return through cePrimReturnEnterCogCode." + ["On Spur ceActivateFailingPrimitiveMethod: would like to retry if forwarders + are found. So insist on PrimCallNeedsPrimitiveFunction being set too." + self assert: (flags anyMask: PrimCallNeedsPrimitiveFunction). + backEnd genSubstituteReturnAddress: + ((flags anyMask: PrimCallCollectsProfileSamples) + ifTrue: [cePrimReturnEnterCogCodeProfiling] + ifFalse: [cePrimReturnEnterCogCode]). + primInvokeInstruction := self JumpFullRT: primitiveRoutine asInteger. + jmp := jmpSamplePrim := continuePostSamplePrim := nil] + ifFalse: + ["Call the C primitive routine." + primInvokeInstruction := self CallFullRT: primitiveRoutine asInteger. + (flags anyMask: PrimCallCollectsProfileSamples) ifTrue: + [self assert: (flags anyMask: PrimCallNeedsNewMethod). + "Test nextProfileTick for being non-zero and call checkProfileTick if so" + objectMemory wordSize = 4 + ifTrue: + [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. + self MoveAw: coInterpreter nextProfileTickAddress + objectMemory wordSize R: ClassReg. + self OrR: TempReg R: ClassReg] + ifFalse: + [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. + self CmpCq: 0 R: TempReg]. + "If set, jump to record sample call." + jmpSamplePrim := self JumpNonZero: 0. + continuePostSamplePrim := self Label]. + objectRepresentation maybeCompileRetryOnPrimitiveFail: primitiveIndex. + self maybeCompileAllocFillerCheck. + "Switch back to the Smalltalk stack. Stack better be in either of these two states: + success: stackPointer -> result (was receiver) + arg1 + ... + argN + return pc + failure: receiver + arg1 + ... + stackPointer -> argN + return pc + In either case we can push the instructionPointer or load it into the LinkRegister to reestablish the return pc" + self MoveAw: coInterpreter instructionPointerAddress + R: (backEnd hasLinkRegister ifTrue: [LinkReg] ifFalse: [ClassReg]). + backEnd genLoadStackPointers. + "Test primitive failure" + self MoveAw: coInterpreter primFailCodeAddress R: TempReg. + backEnd hasLinkRegister ifFalse: [self PushR: ClassReg]. "Restore return pc on CISCs" + self flag: 'ask concrete code gen if move sets condition codes?'. + self CmpCq: 0 R: TempReg. + jmp := self JumpNonZero: 0. + "Fetch result from stack" + self MoveMw: (backEnd hasLinkRegister ifTrue: [0] ifFalse: [objectMemory wordSize]) + r: SPReg + R: ReceiverResultReg. + self RetN: objectMemory wordSize]. "return to caller, popping receiver" + + (flags anyMask: PrimCallCollectsProfileSamples) ifTrue: + ["The sample is collected by cePrimReturnEnterCogCode for external calls" + jmpSamplePrim ifNotNil: + ["Call ceCheckProfileTick: to record sample and then continue." + jmpSamplePrim jmpTarget: self Label. + self assert: (flags anyMask: PrimCallNeedsNewMethod). + self CallFullRT: (self cCode: [#ceCheckProfileTick asUnsignedIntegerPtr] + inSmalltalk: [self simulatedTrampolineFor: #ceCheckProfileTick]). + "reenter the post-primitive call flow" + self Jump: continuePostSamplePrim]. + "Null newMethod and call ceCheckProfileTick: to record sample and then continue. + ceCheckProfileTick will map null/0 to coInterpreter nilObject" + jmpSampleNonPrim jmpTarget: self Label. + self MoveCq: 0 R: TempReg. + self MoveR: TempReg Aw: coInterpreter newMethodAddress. + self CallFullRT: (self cCode: [#ceCheckProfileTick asUnsignedIntegerPtr] + inSmalltalk: [self simulatedTrampolineFor: #ceCheckProfileTick]). + "reenter the post-primitive call flow" + self Jump: continuePostSampleNonPrim]. + + jmp ifNotNil: + ["Jump to restore of receiver reg and proceed to frame build for failure." + jmp jmpTarget: self Label. + "Restore receiver reg from stack. If on RISCs ret pc is in LinkReg, if on CISCs ret pc is on stack." + self MoveMw: objectMemory wordSize * (methodOrBlockNumArgs + (backEnd hasLinkRegister ifTrue: [0] ifFalse: [1])) + r: SPReg + R: ReceiverResultReg]. + ^0! Item was added: + ----- Method: SimpleStackBasedCogit>>compileMachineCodeInterpreterPrimitive: (in category 'primitive generators') ----- + compileMachineCodeInterpreterPrimitive: primitiveRoutine + "Compile a call to a machine-code convention interpreter primitive. Call the C routine + on the Smalltalk stack, assuming it consumes little or no stack space." + <var: #primitiveRoutine declareC: 'void (*primitiveRoutine)(void)'> + | jmpFail liveRegsMask | + "for now handle functions with less than 4 arguments; our C call marshalling machinery + extends up to 4 arguments only, and the first argument of an mcprim is the receiver." + self assert: methodOrBlockNumArgs <= 3. + liveRegsMask := (methodOrBlockNumArgs > self numRegArgs + or: [methodOrBlockNumArgs = 0]) + ifTrue: + [self registerMaskFor: ReceiverResultReg] + ifFalse: + [(self numRegArgs > 1 and: [methodOrBlockNumArgs > 1]) + ifFalse: [self registerMaskFor: ReceiverResultReg and: Arg0Reg] + ifTrue: [self registerMaskFor: ReceiverResultReg and: Arg0Reg and: Arg1Reg]]. + backEnd genSaveRegs: (liveRegsMask bitAnd: CallerSavedRegisterMask). + methodOrBlockNumArgs > self numRegArgs ifTrue: + ["Wrangle args into Arg0Reg, Arg1Reg, SendNumArgsReg & ClassReg" + "offset := self bitCountOf: (liveRegsMask bitAnd: CallerSavedRegisterMask)." + self shouldBeImplemented]. + backEnd + genMarshallNArgs: methodOrBlockNumArgs + 1 + arg: ReceiverResultReg + arg: Arg0Reg + arg: Arg1Reg + arg: SendNumArgsReg + "arg: ClassReg (when we extend C call marchalling to support 5 args for replaceFrom:to:with:startingAt:". + self CallFullRT: primitiveRoutine asInteger. + backEnd + genRemoveNArgsFromStack: methodOrBlockNumArgs + 1; + genRestoreRegs: (liveRegsMask bitAnd: CallerSavedRegisterMask). + self CmpCq: 0 R: backEnd cResultRegister. + jmpFail := self JumpZero: 0. + backEnd cResultRegister ~= ReceiverResultReg ifTrue: + [self MoveR: backEnd cResultRegister R: ReceiverResultReg]. + self RetN: (methodOrBlockNumArgs > self numRegArgs + ifTrue: [methodOrBlockNumArgs + 1 * objectMemory wordSize] + ifFalse: [0]). + jmpFail jmpTarget: self Label. + ^0! Item was changed: ----- Method: SimpleStackBasedCogit>>compilePrimitive (in category 'primitive generators') ----- compilePrimitive "Compile a primitive. If possible, performance-critical primtiives will be generated by their own routines (primitiveGenerator). Otherwise, if there is a primitive at all, we call the C routine with the usual stack-switching dance, test the primFailCode and then either return on success or continue to the method body." <inline: false> + | code opcodeIndexAtPrimitive primitiveDescriptor primitiveRoutine flags | - | code opcodeIndexAtPrimitive primitiveDescriptor primitiveRoutine | <var: #primitiveDescriptor type: #'PrimitiveDescriptor *'> <var: #primitiveRoutine declareC: 'void (*primitiveRoutine)(void)'> primitiveIndex = 0 ifTrue: [^0]. code := 0. "Note opcodeIndex so that compileFallbackToInterpreterPrimitive: can discard arg load instructions for unimplemented primitives." opcodeIndexAtPrimitive := opcodeIndex. "If a descriptor specifies an argument count (by numArgs >= 0) then it must match for the generated code to be correct. For example for speed many primitives use ResultReceiverReg instead of accessing the stack, so the receiver better be at numArgs down the stack. Use the interpreter version if not." ((primitiveDescriptor := self primitiveGeneratorOrNil) notNil and: [primitiveDescriptor primitiveGenerator notNil and: [(primitiveDescriptor primNumArgs < 0 "means don't care" or: [primitiveDescriptor primNumArgs = (coInterpreter argumentCountOf: methodObj)])]]) ifTrue: [code := objectRepresentation perform: primitiveDescriptor primitiveGenerator]. (code < 0 and: [code ~= UnimplementedPrimitive]) ifTrue: "Generator failed, so no point continuing..." [^code]. code = UnfailingPrimitive ifTrue: [^0]. "If the machine code verison handles all cases the only reason to call the interpreter primitive is to reap the primitive error code. Don't bother if it isn't used." (code = CompletePrimitive and: [(self methodUsesPrimitiveErrorCode: methodObj header: methodHeader) not]) ifTrue: [^0]. "Discard any arg load code generated by the primitive generator." code = UnimplementedPrimitive ifTrue: [opcodeIndex := opcodeIndexAtPrimitive]. + + flags := coInterpreter primitivePropertyFlags: primitiveIndex. + (flags anyMask: PrimCallDoNotJIT) ifTrue: + [^ShouldNotJIT]. + + (flags anyMask: PrimCallOnSmalltalkStack) ifTrue: + [self assert: flags = PrimCallOnSmalltalkStack. + ^self compileMachineCodeInterpreterPrimitive: (coInterpreter mcprimFunctionForPrimitiveIndex: primitiveIndex)]. + ((primitiveRoutine := coInterpreter functionPointerForCompiledMethod: methodObj + primitiveIndex: primitiveIndex) = 0 "no primitive" + or: [primitiveRoutine = #primitiveFail]) ifTrue: - primitiveIndex: primitiveIndex) isNil "no primitive" - or: [primitiveRoutine = (coInterpreter functionPointerFor: 0 inClass: nil) "routine = primitiveFail"]) ifTrue: [^self genFastPrimFail]. minValidCallAddress := minValidCallAddress min: primitiveRoutine asUnsignedInteger. + ^self compileInterpreterPrimitive: primitiveRoutine flags: flags! - ^self compileInterpreterPrimitive: primitiveRoutine! Item was changed: ----- Method: SimpleStackBasedCogit>>genPrimitiveClosureValue (in category 'primitive generators') ----- genPrimitiveClosureValue "Check the argument count. Fail if wrong. Get the method from the outerContext and see if it is cogged. If so, jump to the block entry or the no-context-switch entry, as appropriate, and we're done. If not, invoke the interpreter primitive." | jumpFailNArgs jumpFail1 jumpFail2 jumpFail3 jumpFail4 jumpBCMethod primitiveRoutine result | <var: #jumpFail1 type: #'AbstractInstruction *'> <var: #jumpFail2 type: #'AbstractInstruction *'> <var: #jumpFail3 type: #'AbstractInstruction *'> <var: #jumpFail4 type: #'AbstractInstruction *'> <var: #jumpFailNArgs type: #'AbstractInstruction *'> <var: #jumpBCMethod type: #'AbstractInstruction *'> <var: #primitiveRoutine declareC: 'void (*primitiveRoutine)()'> objectRepresentation genLoadSlot: ClosureNumArgsIndex sourceReg: ReceiverResultReg destReg: TempReg. self CmpCq: (objectMemory integerObjectOf: methodOrBlockNumArgs) R: TempReg. jumpFailNArgs := self JumpNonZero: 0. objectRepresentation genLoadSlot: ClosureOuterContextIndex sourceReg: ReceiverResultReg destReg: ClassReg. jumpFail1 := objectRepresentation genJumpImmediate: ClassReg. objectRepresentation genGetCompactClassIndexNonImmOf: ClassReg into: TempReg. objectRepresentation genCmpClassMethodContextCompactIndexR: TempReg. jumpFail2 := self JumpNonZero: 0. "We defer unforwarding the receiver to the prologue; scanning blocks for inst var refs and only unforwarding if the block refers to inst vars." (false and: [objectRepresentation hasSpurMemoryManagerAPI]) ifTrue: [objectRepresentation genLoadSlot: ReceiverIndex sourceReg: ClassReg destReg: SendNumArgsReg; genEnsureOopInRegNotForwarded: SendNumArgsReg scratchReg: TempReg updatingSlot: ReceiverIndex in: ClassReg]. objectRepresentation genLoadSlot: MethodIndex sourceReg: ClassReg destReg: SendNumArgsReg. jumpFail3 := objectRepresentation genJumpImmediate: SendNumArgsReg. objectRepresentation genGetFormatOf: SendNumArgsReg into: TempReg. self CmpCq: objectMemory firstCompiledMethodFormat R: TempReg. jumpFail4 := self JumpLess: 0. objectRepresentation genLoadSlot: HeaderIndex sourceReg: SendNumArgsReg destReg: ClassReg. jumpBCMethod := objectRepresentation genJumpImmediate: ClassReg. self MoveM16: (self offset: CogMethod of: #blockEntryOffset) r: ClassReg R: TempReg. self AddR: ClassReg R: TempReg. primitiveRoutine := coInterpreter functionPointerForCompiledMethod: methodObj primitiveIndex: primitiveIndex. primitiveRoutine = #primitiveClosureValueNoContextSwitch ifTrue: [blockNoContextSwitchOffset = nil ifTrue: [^NotFullyInitialized]. self SubCq: blockNoContextSwitchOffset R: TempReg]. self JumpR: TempReg. jumpBCMethod jmpTarget: (jumpFail1 jmpTarget: (jumpFail2 jmpTarget: (jumpFail3 jmpTarget: (jumpFail4 jmpTarget: self Label)))). + (result := self + compileInterpreterPrimitive: primitiveRoutine + flags: (coInterpreter primitivePropertyFlags: primitiveIndex)) < 0 ifTrue: - (result := self compileInterpreterPrimitive: primitiveRoutine) < 0 ifTrue: [^result]. jumpFailNArgs jmpTarget: self Label. ^CompletePrimitive! Item was changed: ----- Method: SimpleStackBasedCogit>>genPrimitiveFullClosureValue (in category 'primitive generators') ----- genPrimitiveFullClosureValue "Check the argument count. Fail if wrong. Get the method from the outerContext and see if it is cogged. If so, jump to the block entry or the no-context-switch entry, as appropriate, and we're done. If not, invoke the interpreter primitive." | jumpFailNArgs jumpFailImmediateMethod jumpFail4 jumpBCMethod primitiveRoutine result | <option: #SistaV1BytecodeSet> <var: #jumpFailImmediateMethod type: #'AbstractInstruction *'> <var: #jumpFail4 type: #'AbstractInstruction *'> <var: #jumpFailNArgs type: #'AbstractInstruction *'> <var: #jumpBCMethod type: #'AbstractInstruction *'> <var: #primitiveRoutine declareC: 'void (*primitiveRoutine)()'> objectRepresentation genLoadSlot: ClosureNumArgsIndex sourceReg: ReceiverResultReg destReg: TempReg. self CmpCq: (objectMemory integerObjectOf: methodOrBlockNumArgs) R: TempReg. jumpFailNArgs := self JumpNonZero: 0. "We defer unforwarding the receiver to the prologue; scanning blocks for inst var refs and only unforwarding if the block refers to inst vars." (false and: [objectRepresentation hasSpurMemoryManagerAPI]) ifTrue: [objectRepresentation genLoadSlot: FullClosureReceiverIndex sourceReg: ReceiverResultReg destReg: SendNumArgsReg; genEnsureOopInRegNotForwarded: SendNumArgsReg scratchReg: TempReg updatingSlot: FullClosureReceiverIndex in: ReceiverResultReg]. objectRepresentation genLoadSlot: FullClosureCompiledBlockIndex sourceReg: ReceiverResultReg destReg: SendNumArgsReg. jumpFailImmediateMethod := objectRepresentation genJumpImmediate: SendNumArgsReg. objectRepresentation genGetFormatOf: SendNumArgsReg into: TempReg. self CmpCq: objectMemory firstCompiledMethodFormat R: TempReg. jumpFail4 := self JumpLess: 0. objectRepresentation genLoadSlot: HeaderIndex sourceReg: SendNumArgsReg destReg: ClassReg. jumpBCMethod := objectRepresentation genJumpImmediate: ClassReg. primitiveRoutine := coInterpreter functionPointerForCompiledMethod: methodObj primitiveIndex: primitiveIndex. self AddCq: (primitiveRoutine = #primitiveFullClosureValueNoContextSwitch ifTrue: [self fullBlockNoContextSwitchEntryOffset] ifFalse: [self fullBlockEntryOffset]) R: ClassReg. self JumpR: ClassReg. jumpBCMethod jmpTarget: (jumpFailImmediateMethod jmpTarget: (jumpFail4 jmpTarget: self Label)). + (result := self + compileInterpreterPrimitive: primitiveRoutine + flags: (coInterpreter primitivePropertyFlags: primitiveIndex)) < 0 ifTrue: - (result := self compileInterpreterPrimitive: primitiveRoutine) < 0 ifTrue: [^result]. jumpFailNArgs jmpTarget: self Label. ^CompletePrimitive! Item was added: + ----- Method: SimpleStackBasedCogit>>genPrimitiveHashMultiply (in category 'primitive generators') ----- + genPrimitiveHashMultiply + | highReg jmpFailImm jmpFailNonImm jmpNotSmallInt lowReg reenter | + jmpNotSmallInt := objectRepresentation genJumpNotSmallInteger: ReceiverResultReg. + objectRepresentation genConvertSmallIntegerToIntegerInReg: ReceiverResultReg. + reenter := self MoveR: ReceiverResultReg R: (highReg := Arg1Reg). + self + ArithmeticShiftRightCq: 14 R: highReg; "highReg := receiver bitShift: -14" + AndCq: 16383 R: ReceiverResultReg; + MoveR: ReceiverResultReg R: (lowReg := Arg0Reg); "lowReg := receiver bitAnd: 16383" + MoveCq: 16r260D R: TempReg; + MulR: TempReg R: ReceiverResultReg; "RRR := 16r260D * low" + MulR: TempReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14))" + MoveCq: 16r0065 R: TempReg; + MulR: TempReg R: lowReg; "lowReg := 16r0065 * low" + AddR: lowReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14)) + (16r0065 * low)" + MoveCq: 16384 R: TempReg; + MulR: TempReg R: highReg; "highReg := (16r260D * (receiver bitShift: -14)) + (16r0065 * low)" + AddR: highReg R: ReceiverResultReg; + AndCq: 16r0FFFFFFF R: ReceiverResultReg. + objectRepresentation genConvertIntegerToSmallIntegerInReg: ReceiverResultReg. + self RetN: 0. + jmpNotSmallInt jmpTarget: self Label. + jmpFailImm := objectRepresentation genJumpImmediate: ReceiverResultReg. + objectRepresentation genGetClassIndexOfNonImm: ReceiverResultReg into: ClassReg. + self CmpCq: ClassLargePositiveIntegerCompactIndex R: ClassReg. + jmpFailNonImm := self JumpNonZero: 0. + objectRepresentation genLoadSlot: 0 sourceReg: ReceiverResultReg destReg: ReceiverResultReg. + self Jump: reenter. + jmpFailImm jmpTarget: (jmpFailNonImm jmpTarget: self Label). + ^0! Item was changed: ----- Method: SistaCogit>>genUnaryInlinePrimitive: (in category 'inline primitive generators') ----- genUnaryInlinePrimitive: prim "Unary inline primitives." "SistaV1: 248 11111000 iiiiiiii mjjjjjjj Call Primitive #iiiiiiii + (jjjjjjj * 256) m=1 means inlined primitive, no hard return after execution. See EncoderForSistaV1's class comment and StackInterpreter>>#unaryInlinePrimitive:" | rcvrReg resultReg | rcvrReg := self allocateRegForStackEntryAt: 0. resultReg := self allocateRegNotConflictingWith: (self registerMaskFor: rcvrReg). prim caseOf: { "00 unchecked class" [1] -> "01 unchecked pointer numSlots" [self ssTop popToReg: rcvrReg. self ssPop: 1. objectRepresentation genGetNumSlotsOf: rcvrReg into: resultReg; genConvertIntegerToSmallIntegerInReg: resultReg]. "02 unchecked pointer basicSize" [3] -> "03 unchecked byte numBytes" [self ssTop popToReg: rcvrReg. self ssPop: 1. objectRepresentation genGetNumBytesOf: rcvrReg into: resultReg; genConvertIntegerToSmallIntegerInReg: resultReg]. "04 unchecked short16Type format numShorts" "05 unchecked word32Type format numWords" "06 unchecked doubleWord64Type format numDoubleWords" [11] -> "11 unchecked fixed pointer basicNew" [self ssTop type ~= SSConstant ifTrue: [^EncounteredUnknownBytecode]. (objectRepresentation + genGetInstanceOfFixedClass: self ssTop constant - genGetInstanceOf: self ssTop constant into: resultReg initializingIf: self extBSpecifiesInitializeInstance) ~= 0 ifTrue: [^ShouldNotJIT]. "e.g. bad class" self ssPop: 1] . [20] -> "20 identityHash" [objectRepresentation genGetIdentityHash: rcvrReg resultReg: resultReg. self ssPop: 1] . "21 identityHash (SmallInteger)" "22 identityHash (Character)" "23 identityHash (SmallFloat64)" "24 identityHash (Behavior)" "30 immediateAsInteger (Character) 31 immediateAsInteger (SmallFloat64) 35 immediateAsFloat (SmallInteger) " [30] -> [self ssTop popToReg: resultReg. objectRepresentation genConvertCharacterToSmallIntegerInReg: resultReg. self ssPop: 1]. [35] -> [self assert: self processorHasDoublePrecisionFloatingPointSupport. self MoveR: rcvrReg R: TempReg. self genConvertSmallIntegerToIntegerInReg: TempReg. self ConvertR: TempReg Rd: DPFPReg0. self flag: #TODO. "Should never fail" self genAllocFloatValue: DPFPReg0 into: resultReg scratchReg: TempReg scratchReg: NoReg. "scratch2 for V3 only"] } otherwise: [^EncounteredUnknownBytecode]. extB := 0. numExtB := 0. self ssPushRegister: resultReg. ^0! Item was changed: InterpreterPrimitives subclass: #StackInterpreter instanceVariableNames: 'currentBytecode bytecodeSetSelector localFP localIP localSP stackLimit stackPage stackPages method instructionPointer stackPointer framePointer localReturnValue localAbsentReceiver localAbsentReceiverOrZero extA extB numExtB primitiveFunctionPointer methodCache nsMethodCache atCache lkupClassTag lkupClass methodDictLinearSearchLimit highestRunnableProcessPriority nextWakeupUsecs nextPollUsecs inIOProcessEvents interruptKeycode interruptPending savedWindowSize imageHeaderFlags fullScreenFlag deferDisplayUpdates pendingFinalizationSignals extraVMMemory interpreterProxy showSurfaceFn primitiveTable primitiveAccessorDepthTable externalPrimitiveTable externalPrimitiveTableFirstFreeIndex overflowedPage extraFramesToMoveOnOverflow globalSessionID jmpBuf jmpDepth suspendedCallbacks suspendedMethods numStackPages desiredNumStackPages desiredEdenBytes classNameIndex thisClassIndex metaclassNumSlots interruptCheckChain suppressHeartbeatFlag breakSelector breakSelector Length longRunningPrimitiveCheckMethod longRunningPrimitiveCheckSemaphore longRunningPrimitiveStartUsecs longRunningPrimitiveStopUsecs longRunningPrimitiveGCUsecs longRunningPrimitiveCheckSequenceNumber longRunningPrimitiveSignalUndelivered checkAllocFiller tempOop tempOop2 tempOop3 theUnknownShort the2ndUnknownShort imageFloatsBigEndian maxExtSemTabSizeSet lastMethodCacheProbeWrite gcSemaphoreIndex classByteArrayCompactIndex checkedPluginName nativeSP nativeStackPointer lowcodeCalloutState shadowCallStackPointer statForceInterruptCheck statStackOverflow statStackPageDivorce statCheckForEvents statProcessSwitch statIOProcessEvents statPendingFinalizationSignals statIdleUsecs debugCallbackPath debugCallbackReturns debugCallbackInvokes' + classVariableNames: 'AccessModifierPrivate AccessModifierProtected AccessModifierPublic AltBytecodeEncoderClassName AltLongStoreBytecode AlternateHeaderHasPrimFlag AlternateHeaderIsOptimizedFlag AlternateHeaderNumLiteralsMask AtCacheFixedFields AtCacheFmt AtCacheMask AtCacheOop AtCacheSize AtCacheTotalSize AtPutBase BytecodeEncoderClassName BytecodeTable CacheProbeMax DirBadPath DirEntryFound DirNoMoreEntries DumpStackOnLowSpace EnclosingMixinIndex EnclosingObjectIndex EnforceAccessControl FailImbalancedPrimitives LongStoreBytecode MaxExternalPrimitiveTableSize MaxJumpBuf MaxPrimitiveIndex MaxQuickPrimitiveIndex MethodHeaderArgCountShift MethodHeaderFlagBitPosition MethodHeaderTempCountShift MixinIndex PrimNumberDoExternalCall PrimNumberExternalCall PrimNumberFFICall PrimitiveTable StackPageReachedButUntraced StackPageTraceInvalid StackPageTraced StackPageUnreached V3PrimitiveBitsMask' - classVariableNames: 'AccessModifierPrivate AccessModifierProtected AccessModifierPublic AltBytecodeEncoderClassName AltLongStoreBytecode AlternateHeaderHasPrimFlag AlternateHeaderIsOptimizedFlag AlternateHeaderNumLiteralsMask AtCacheFixedFields AtCacheFmt AtCacheMask AtCacheOop AtCacheSize AtCacheTotalSize AtPutBase BytecodeEncoderClassName BytecodeTable CacheProbeMax DirBadPath DirEntryFound DirNoMoreEntries DumpStackOnLowSpace EnclosingMixinIndex EnclosingObjectIndex EnforceAccessControl FailImbalancedPrimitives LongStoreBytecode MaxExternalPrimitiveTableSize MaxJumpBuf MaxPrimitiveIndex MaxQuickPrimitiveIndex MethodHeaderArgCountShift MethodHeaderFlagBitPosition MethodHeaderTempCountShift MixinIndex PrimNumberDoExternalCall PrimNumberExternalCall PrimNumberFFICall PrimitiveExternalCallIndex PrimitiveTable StackPageReachedButUntraced StackPageTraceInvalid StackPageTraced StackPageUnreached V3PrimitiveBitsMask' poolDictionaries: 'VMBasicConstants VMBytecodeConstants VMMethodCacheConstants VMObjectIndices VMSpurObjectRepresentationConstants VMSqueakClassIndices VMStackFrameOffsets' category: 'VMMaker-Interpreter'! !StackInterpreter commentStamp: 'eem 12/5/2014 11:32' prior: 0! This class is a complete implementation of the Smalltalk-80 virtual machine, derived originally from the Blue Book specification but quite different in some areas. This VM supports Closures but *not* old-style BlockContexts. It has been modernized with 32-bit pointers, better management of Contexts (see next item), and attention to variable use that allows the CCodeGenerator (qv) to keep, eg, the instruction pointer and stack pointer in registers as well as keeping most simple variables in a global array that seems to improve performance for most platforms. The VM does not use Contexts directly. Instead Contexts serve as proxies for a more conventional stack format that is invisible to the image. There is considerable explanation at http://www.mirandabanda.org/cogblog/2009/01/14/under-cover-contexts-and-the…. The VM maintains a fixed-size stack zone divided into pages, each page being capable of holding several method/block activations. A send establishes a new frame in the current stack page, a return returns to the previous frame. This eliminates allocation/deallocation of contexts and the moving of receiver and arguments from caller to callee on each send/return. Contexts are created lazily when an activation needs a context (creating a block, explicit use of thisContext, access to sender when sender is a frame, or linking of stack pages together). Contexts are either conventional and heap-resident ("single") or "married" and serve as proxies for their corresponding frame or "widowed", meaning that their spouse f rame has been returned from (died). A married context is specially marked (more details in the code) and refers to its frame. Likewise a married frame is specially marked and refers to its context. In addition to SmallInteger arithmetic and Floats, the VM supports logic on 32-bit PositiveLargeIntegers, thus allowing it to simulate itself much more effectively than would otherwise be the case. StackInterpreter and subclasses support multiple memory managers. Currently there are two. NewMemoryManager is a slightly refined version of ObjectMemory, and is the memory manager and garbage collector for the original Squeak object representation as described in "Back to the Future The Story of Squeak, A Practical Smalltalk Written in Itself", see http://ftp.squeak.org/docs/OOPSLA.Squeak.html. Spur is a faster, more regular object representation that is designed for more performance and functionality, and to have a common header format for both 32-bit and 64-bit versions. You can read about it in SpurMemoryManager's class comment. There is also a video of a presentation at ESUG 2014 (https://www.youtube.com/watch?v=k0nBNS1aHZ4), along with slides (http://www.slideshare.net/esug/spur-a-new-object-representation-for-cog?rel…).! Item was changed: ----- Method: StackInterpreter class>>initializeMiscConstants (in category 'initialization') ----- initializeMiscConstants super initializeMiscConstants. STACKVM := true. "These flags function to identify a GC operation, or to specify what operations the leak checker should be run for." GCModeFull := 1. "stop-the-world global GC" GCModeNewSpace := 2. "Spur's scavenge, or V3's incremental" GCModeIncremental := 4. "incremental global gc (Dijkstra tri-colour marking); as yet unimplemented" GCModeBecome := 8. "v3 post-become sweeping/Spur forwarding" GCModeImageSegment := 16. "just a flag for leak checking image segments" GCModeFreeSpace := 32. "just a flag for leak checking free space; Spur only" GCCheckPrimCall := 64. "just a flag for leak checking external primitive calls" StackPageTraceInvalid := -1. StackPageUnreached := 0. StackPageReachedButUntraced := 1. StackPageTraced := 2. DumpStackOnLowSpace := 0. - PrimitiveExternalCallIndex := 117. "Primitive index for #primitiveExternalCall" MillisecondClockMask := 16r1FFFFFFF. "Note: The external primitive table should actually be dynamically sized but for the sake of inferior platforms (e.g., Mac :-) who cannot allocate memory in any reasonable way, we keep it static (and cross our fingers...)" MaxExternalPrimitiveTableSize := 4096. "entries" MaxJumpBuf := 32. "max. callback depth" FailImbalancedPrimitives := initializationOptions at: #FailImbalancedPrimitives ifAbsentPut: [true]. EnforceAccessControl := initializationOptions at: #EnforceAccessControl ifAbsent: [true]! Item was changed: ----- Method: StackInterpreter class>>initializePrimitiveTable (in category 'initialization') ----- (excessive size, no diff calculated) Item was changed: ----- Method: StackInterpreter>>extJumpIfNotInstanceOfBehaviorsBytecode (in category 'sista bytecodes') ----- extJumpIfNotInstanceOfBehaviorsBytecode + "254 11111110 kkkkkkkk jjjjjjjj branch If Not Instance Of Behavior/Array Of Behavior kkkkkkkk (+ Extend A * 256, where Extend A >= 0) distance jjjjjjjj (+ Extend B * 256, where Extend B between: 0 and: 127) + 254 11111110 kkkkkkkk jjjjjjjj branch If Instance Of Behavior/Array Of Behavior kkkkkkkk (+ Extend A * 256, where Extend A >= 0) distance jjjjjjjj (+ Extend B - 128 * 256, where Extend B between: 128 and: 255)" - "254 11111110 kkkkkkkk jjjjjjjj branch If Not Instance Of Behavior/Array Of Behavior kkkkkkkk (+ Extend A * 256, where Extend A >= 0) distance jjjjjjjj (+ Extend B * 256, where Extend B >= 0)" | tosClassTag literal distance inverse | SistaVM ifFalse: [^self respondToUnknownBytecode]. self assert: ((extB bitAnd: 128) = 0 or: [extB < 0]). (inverse := extB < 0) ifTrue: [extB := extB + 128]. tosClassTag := objectMemory fetchClassTagOf: self internalPopStack. literal := self literal: extA << 8 + self fetchByte. distance := extB << 8 + self fetchByte. extA := extB := numExtB := 0. (objectMemory isArrayNonImm: literal) ifTrue: [0 to: (objectMemory numSlotsOf: literal) asInteger - 1 do: [:i | tosClassTag = (objectMemory rawClassTagForClass: (objectMemory fetchPointer: i ofObject: literal)) ifTrue: [inverse ifTrue: [ localIP := localIP + distance ]. ^self fetchNextBytecode ] ]. inverse ifFalse: [localIP := localIP + distance]. ^self fetchNextBytecode]. tosClassTag = (objectMemory rawClassTagForClass: literal) = inverse ifTrue: [localIP := localIP + distance]. self fetchNextBytecode! Item was changed: ----- Method: StackInterpreter>>flushExternalPrimitiveOf: (in category 'plugin primitive support') ----- flushExternalPrimitiveOf: methodObj "methodObj is a CompiledMethod. If it contains an external primitive, flush the function address and session ID of the CM. Answer the prim index for the benefit of subclass overrides." <inline: false> | header primIdx lit | header := objectMemory methodHeaderOf: methodObj. primIdx := self primitiveIndexOfMethod: methodObj header: header. + (primIdx = PrimNumberExternalCall - (primIdx = PrimitiveExternalCallIndex and: [(objectMemory literalCountOfMethodHeader: header) > 0]) ifTrue: "If not, something's broken" [lit := self literal: 0 ofMethod: methodObj. ((objectMemory isArray: lit) and: [(objectMemory numSlotsOf: lit) = 4]) ifTrue: "If not, something's broken" [objectMemory storePointerUnchecked: 2 ofObject: lit withValue: ConstZero; storePointerUnchecked: 3 ofObject: lit withValue: ConstZero]]. ^primIdx!

1 0

Crashes on snapshot with the new compactor
by Eliot Miranda 17 Apr '17

17 Apr '17

Hi All, a number of people are being affected by crashes on snapshotting the image, the worst possible time for a crash. There is a bug in the new compactor that unfortunately bites when saving. The compactor is invoked as part of a full garbage collect after the garbage collector has feed unreachable objects. Normally the new compactor makes only a single pass through the heap, which may not move all the objects that are possible to move. (The amount of objects that can be moved in a single pass is limited by available free space.) But on snapshot the compactor makes as may passes as are necessary to slide all movable objects down as far as possible. Unfortunately there is a bug in this second pass. Fixing this bug is now my priority. I have an example image from Esteban Lorenzano to test. I am asking anyone else that can provide an image that reliably crashes when trying to save it to make the image and changes available to me for testing if possible. In the mean time one may be able to work around the problem by doing a full garbage collect before snapshot. This should do a GC with a single compaction pass which should not fail, and then make it much more likely that the GC during snapshot will do a single compaction pass, since fewer objects should be mobile after the single pass compaction in the explicit GC. To do this in Pharo I would put a full gc here: SessionManager>>snapshot: save andQuit: quit | isImageStarting snapshotResult | ChangesLog default logSnapshot: save andQuit: quit. >> SmalltalkImage current primitiveGarbageCollect. self currentSession stop: quit. "Image not usable from here until the session is restarted!" ... In Squeak I would put a full GC here: snapshot: save andQuit: quit withExitCode: exitCode embedded: embeddedFlag "Mark the changes file and close all files as part of #processShutdownList. If save is true, save the current state of this Smalltalk in the image file. If quit is true, then exit to the outer OS shell. If exitCode is not nil, then use it as exit code. The latter part of this method runs when resuming a previously saved image. This resume logic checks for a document file to process when starting up." | resuming msg | Object flushDependents. Object flushEvents. ... Smalltalk processShutDownList: quit. >> SmalltalkImage current primitiveGarbageCollect. Cursor write show. save ifTrue: [resuming := embeddedFlag ifTrue: [self snapshotEmbeddedPrimitive] ifFalse: [self snapshotPrimitive]] "<-- PC frozen here on image file" ifFalse: [resuming := false]. I do apologise for the bug. I hope it will be fixed within a few days. _,,,^..^,,,_ best, Eliot

2 3

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

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

Vm-dev April 2017