Vm-dev September 2023

vm-dev@lists.squeakfoundation.org

7 participants
8 discussions

[OpenSmalltalk/opensmalltalk-vm] mmap() sqUnixSpurMemory patch (Issue #665)
by David Stes 03 Mar '24

03 Mar '24

Hi, I have sent in the past email to Eliot Miranda about an issue which I discovered in August 2021 (two years ago), and I thought to raise an issue here. It is a Linux/UNIX patch issue with the behavior of the mmap() system call or library call as used by the OpenSmalltalk COG vm. When way back in 2021 some changes were made for Linux ARM8 to the file saUnixSpurMemory.c I reported that this was breaking the Solaris 11.3 build. Curiously the Solaris 11.4 build was still working fine. I think (I don't know) that perhaps the behavior of mmap() on Solaris 11.4 is slightly diferent than on 11.3, to match (perhaps) the Linux kernel behavior of mmap(). An idea that I have is to ask some UNIX guru's whether there exist a autoconf-archive (configure script) test or script to test the behavior of mmap() for portability. However here I will just report what the issue is : since august 2021 I am building succesfully on Solaris with the following patch ``` --- opensmalltalk-vm-sun-v5.0.34/platforms/unix/vm/sqUnixSpurMemory.c Fri Aug 13 19:54:42 2021 +++ p0/opensmalltalk-vm-sun-v5.0.34/platforms/unix/vm/sqUnixSpurMemory.c Sun Aug 15 14:11:58 2021 @@ -277,16 +277,21 @@ { void *hint = sbrk(0); // a hint of the lowest possible address for mmap void *result; + char *address; + unsigned long alignment; pageSize = getpagesize(); pageMask = ~(pageSize - 1); + alignment = max(pageSize,1024*1024); + address = (char *)(((usqInt)hint + alignment - 1) & ~(alignment - 1)); + #if !defined(MAP_JIT) # define MAP_JIT 0 #endif *desiredSize = roundUpToPage(*desiredSize); - result = mmap(hint, *desiredSize, + result = mmap(address, *desiredSize, #if DUAL_MAPPED_CODE_ZONE PROT_READ | PROT_EXEC, #else ``` I really need Eliot's help on this. Eliot : what I did was try to understand your code and you seem to make some alignment calculations on the desired memory location that you request through mmap(). I believe that the traditional UNIX mmap() or the Solaris 10 and Solaris 11.3 mmap() is reacting slightly differently to the requested memory "hint". By some experimentatoin and debugging I found the above patch, which I wrote based on looking at your code and try to mirror the calculations that you are doing, which are not fully symmetric. By copying some code, I discovered that with the above patch the build for both Solaris 11.3 and Solaris 11.4 are working fine again. I think this is a general UNIX issue that could be of interest to all UNIX software. If an autoconfigure autoconf-archive test would exist to test the behavior of mmap() then that could be dealt in all software that uses mmap() with anonymous memory mapping. As far as I know the history of the mmap() call is that it originated in the world of Sun and Solaris and is since a very long time present in Linux as well, and I think some improvements in Linux where then backported to Solaris 11.4. That would explain why the current OpenSmalltalk-VM code works fine on Solaris 11.4. For reasons of portability to all flavors of UNIX and Linux, I think a configure build test for the code could benefit portability of your Cog VM. Let us know please what you think. I could simply submit my patch as a patch to mainstream upstream OpenSmalltalk but I don't know your opinion about it. And the way I have been using it as a platform specific patch (that I apply prior to the build on Solaris) is fine for me as well. Regards, David Stes -- Reply to this email directly or view it on GitHub: https://github.com/OpenSmalltalk/opensmalltalk-vm/issues/665 You are receiving this because you are subscribed to this thread. Message ID: <OpenSmalltalk/opensmalltalk-vm/issues/665(a)github.com>

4 19

[OpenSmalltalk/opensmalltalk-vm] BitBlt rgbMul is broken for depth 1 and not correctly rounded above depth 4 (Issue #651)
by Nicolas Cellier 24 Nov '23

24 Nov '23

In depth 1, the resulting bits will always be 0. It's not a big problem because rgbMul is just a bitAnd operation at this depth. So a quick workaround would be to detect the case in BitBltSimulation destDepth = 1 ifTrue: [^self bitAnd: sourceWord with: destinationWord]. That would also accelerate the Bit BLock Transfer operation, so it's a good hack. But there is more. What we want is multiply ratios in interval [0,1]. dstRatio * srcRatio Our implementation is scaled ratio (scaled by `1 << nBits - 1`): src := (srcRatio * scale) rounded. dst := (dstRatio * scale) rounded. So what we want is: ((dst/scale) * (src/scale) * scale) rounded that is: (dst*src / (1<<nBits-1)) rounded Unfortunately, that's the other grief with the current implementation used for rounding: (dst+1)*(src+1) - 1 >> nBits It only equals correctly rounded operation for depths 2 and 4. For rounding we might use: (((dst/scale) * (src/scale) + 0.5) * scale) truncated. that is expressed with truncated division: dst*src + (scale+1//2) // scale So here is a nicer formulation for doing the job at any depth (including 5bits rgb channels for 16 bits depth) with correctly rounded division: aux := src * dst + (1 << (nBits - 1)). "add mid-scale for rounding" result := aux << (nBits - 1) + aux << (nBits -1). "divide by scale" This is because instead of dividing by scale, we can multiply by shifted inverse (sort of double precision), then shift right. (2 to: 32) allSatisfy: [:nBits | (1 << (nBits * 2) / (1 << nBits - 1)) rounded = (1 << nBits + 1)]. Multiplying by this inverse is easy and cheap: x * (1 << nBits + 1) = (x << nBits + x). And then applying the right shift `>> (2 * nBits)` is equivalent to: x >> nBits + x >> nBits. We must first add 0.5 (scaled), that is `src * dst + (1 << (nBits -1))` - our formulation of aux, and we're done. We verify: { (0 to: 1<<20-1) allSatisfy: [:i | (1<<9+i)>>10+ (1<<9+i)>>10 = (i/1023) rounded]. (0 to: 1<<18-1) allSatisfy: [:i | (1<<8+i)>>9+ (1<<8+i)>>9 = (i/511) rounded]. (0 to: 1<<16-1) allSatisfy: [:i | (1<<7+i)>>8+ (1<<7+i)>>8 = (i/255) rounded]. (0 to: 1<<14-1) allSatisfy: [:i | (1<<6+i)>>7+ (1<<6+i)>>7 = (i/127) rounded]. (0 to: 1<<12-1) allSatisfy: [:i | (1<<5+i)>>6+ (1<<5+i)>>6 = (i/63) rounded]. (0 to: 1<<10-1) allSatisfy: [:i | (1<<4+i)>>5+ (1<<4+i)>>5 = (i/31) rounded]. (0 to: 1<<8-1) allSatisfy: [:i | (1<<3+i)>>4+ (1<<3+i)>>4 = (i/15) rounded]. (0 to: 1<<6-1) allSatisfy: [:i | (1<<2+i)>>3+ (1<<2+i)>>3 = (i/7) rounded]. (0 to: 1<<4-1) allSatisfy: [:i | (1<<1+i)>>2+ (1<<1+i)>>2 = (i/3) rounded]. } allSatisfy: #yourself. The nice thing is that above down-scaling operation can be multiplexed. Suppose that we have p groups of 2*nBits `M` holding square-scale multiplication of each channel concatenated in a double-Word-Mul. doubleWordMul = Mp .... M5 M3 M1 Note we arrange to have odd channels in low word, and even channels in high word. We first form a `groupMask` on a word with (p+1)/2 groups of nBits alternating all one `i` and all zero `o`, `oioi...ioi`. channelMask := 1 << nBits - 1. groupMask := 0. 0 to: wordBits // (2 * nBits) do: [:i | groupMask = groupMask << (2 * nBits) + channelMask]. Where wordBits is the number of bits in a word (usually we want to operate on 32 bits words in BitBlt). We form the `doubleGroupMask` on a double-word with p groups of 2*nBits `oi`: doubleGroupMask := groupMask >> nBits. doubleGroupMask := doubleGroupMask << wordBits + groupMask. And we perform the division by scale: doubleWordMul := (doubleWordMul >> nBits bitAnd: doubleGroupMask) + doubleWord >> nBits bitAnd: doubleGroupMask. At this stage we obtain a double word containing scaled multiplicands interleaved with groups of nBits zeros: o mp ... o m3 o m1 Now the final result can be obtained by shifting back: doubleWordMul >> (wordBits - nBits) + (doubleWordMul bitAnd: groupMask) The only problem remaining is how to obtain the squared-scale multiplicands. It would be easy to form the alternate even-odd channels for each src and dst operands: doubleWordSrc := src >> nBits bitAnd: groupMask. doubleWordSrc := doubleWordSrc << wordBits + (src bitAnd: groupMask). doubleWordDst := dst >> nBits bitAnd: groupMask. doubleWordDst := doubleWordDst << wordBits + (dst bitAnd: groupMask). we now get `o sp ... o s3 o s1` and `0 dp ... o d3 o d1`, but we would now need a SIMD integer multiplication operating on groups of 2*nBits in parallel... We don't have that, at least in portable C code. So we still have to emulate it with a loop. half := 1 << (nBits - 1). shift := 0. doubleWordMul := 0 0 to: nChannels - 1 do: [:i | doubleWordMul := doubleWordMul + (((doubleWordSrc >> shift bitAnd: channelMask) * (doubleWordSrc >> shift bitAnd: channelMask) + half) << shift). shift := shift + nBits + nBits]. We know that each operation cannot overflow on upper neighbour group of 2*nBits, because the maximum value is: (1<<nBits-1) squared + (1 << (nBits-1)) = 1 << (2*nBits) - (2*(1<<nBits)) + (1 << (nBits-1)) - 1 < (1 << (2*nBits) - 1) It remains the odd case of 16 bits depth, which has 3 groups of 5 bits and a leading zero. I believe that above algorithm works without splitting in two half-words... To be tested. We have gathered the pieces for a correctly rounded almost-multiplexed rgbMul. Somehow have our cake and eat it too. -- Reply to this email directly or view it on GitHub: https://github.com/OpenSmalltalk/opensmalltalk-vm/issues/651 You are receiving this because you are subscribed to this thread. Message ID: <OpenSmalltalk/opensmalltalk-vm/issues/651(a)github.com>

2 4

Building VMMaker image supporting AMD64 and AArch64 ISAs on Linux
by Jan Vrany 04 Oct '23

04 Oct '23

Hi Eliot and others, I'm trying to build working VMMaker image in order to see what machine code Cog generates for some simple methods - without success so far. All this is on Linux on AMD64. Detailed report on what exactly I did and what errors I got is below. In short: (i) does AArch64 sim plugin works on modern linuxes, does anyone use it there? (ii) if so, what's the correct incantation to compile it. (iii) using code in workspace labelled "In-Image Compilation Workspace", is it supposed to work for every method and every ISA or is it normal that it fails with DNU for some methods? I managed to compile but the trivial ones. Thanks! Jan ================================================== ==== Below details what I did and errors I got === I'm using this commit: commit 330d6779ad2ecbce1f07131f53d75cd168165f0b (HEAD -> Cog, origin/HEAD, origin/Cog) Author: Christoph Thiede <christoph.thiede(a)student.hpi.de> Date: Thu Aug 17 13:32:52 2023 +0200 Here's what I did: * IIUC, first I need to build bochs and BOCHS 64 simulator, so cd opensmalltalk-vm/building/linux64x64/bochsx64 ./conf.COG ./makeem That built just fine. * Then I built gdbarm64 simulator: cd opensmalltalk-vm/building/linux64x64/gdbarm64$ ./conf.COG ./makeem Again, no problem so far. * Then I tried to build the VM: cd opensmalltalk-vm/building/linux64x64/squeak.cog.spur/build ./mvm That failed soon: .../opensmalltalk-vm/platforms/unix/vm/sqUnixMain.c:1832:10: warning: format string is not a string literal (potentially insecure) [-Wformat-security] printf(optionStrings[count]); ^~~~~~~~~~~~~~~~~~~~ .../opensmalltalk-vm/platforms/unix/vm/sqUnixMain.c:1832:10: note: treat the string as an argument to avoid this printf(optionStrings[count]); ^ "%s", .../opensmalltalk-vm/platforms/unix/vm/sqUnixMain.c:2324:38: error: incompatible function pointer types assigning to 'void (*)(int, siginfo_t *, void *)' from 'void (int, siginfo_t *, ucontext_t *)' (aka 'void (int, siginfo_t *, struct ucontext_t *)') [-Wincompatible-function-pointer-types] sigsegv_handler_action.sa_sigaction = sigsegv; ^ ~~~~~~~ .../opensmalltalk-vm/platforms/unix/vm/sqUnixMain.c:2331:38: error: incompatible function pointer types assigning to 'void (*)(int, siginfo_t *, void *)' from 'void (int, siginfo_t *, ucontext_t *)' (aka 'void (int, siginfo_t *, struct ucontext_t *)') [-Wincompatible-function-pointer-types] sigusr1_handler_action.sa_sigaction = sigusr1; ^ ~~~~~~~ 1 warning and 2 errors generated. This is using clang version 16.0.6 (which mvm script enforces on line 20) * Then I tried to build the VM again, this time with GCC (version 13.2.0 by editing mvm line 20): cd opensmalltalk-vm/building/linux64x64/squeak.cog.spur/build ./mvm This failed to compile too, though with different error: libtool: compile: gcc -Wall -g -O2 -DNDEBUG -DDEBUGVM=0 -msse2 -DCOGMTVM=0 -pthread -DLSB_FIRST=1 -m64 -Wno-missing-braces -Wno-unknown-pragmas -Wno-unused- value -Wno-unused-label -Wno-unused-function -Wno-unused-variable -Wno-unused-but-set-variable -DHAVE_CONFIG_H -I.../opensmalltalk- vm/building/linux64x64/squeak.cog.spur/build -I.../opensmalltalk-vm/building/linux64x64/squeak.cog.spur/build -I.../opensmalltalk-vm/platforms/unix/vm - I.../opensmalltalk-vm/platforms/Cross/vm -I.../opensmalltalk-vm/src/spur64.cog -I/usr/local/include -I.../opensmalltalk- vm/platforms/Cross/plugins/GdbARMv8Plugin -I../../../../processors/ARM/gdb-8.3.1/include -I../../../../processors/ARM/gdb-8.3.1/sim/aarch64 -m64 -Wno-missing- braces -Wno-unknown-pragmas -Wno-unused-value -Wno-unused-label -Wno-unused-function -Wno-unused-variable -Wno-unused-but-set-variable -c .../opensmalltalk- vm/platforms/Cross/plugins/GdbARMv8Plugin/sqGdbARMv8Plugin.c -fPIC -DPIC -o .libs/sqGdbARMv8Plugin.o In file included from .../opensmalltalk-vm/platforms/Cross/vm/sqMemoryAccess.h:23, from .../opensmalltalk-vm/platforms/unix/vm/sqPlatformSpecific.h:35, from .../opensmalltalk-vm/platforms/Cross/vm/sqAssert.h:16, from .../opensmalltalk-vm/platforms/Cross/plugins/GdbARMv8Plugin/sqGdbARMv8Plugin.c:4: .../opensmalltalk-vm/building/linux64x64/squeak.cog.spur/build/config.h:40:2: error: #error This file was included too late. Please make sure it is included earlier 40 | #error This file was included too late. Please make sure it is included earlier | ^~~~~ .../opensmalltalk-vm/platforms/Cross/plugins/GdbARMv8Plugin/sqGdbARMv8Plugin.c:9:10: fatal error: aarch64/config.h: No such file or directory 9 | #include <aarch64/config.h> | ^~~~~~~~~~~~~~~~~~ compilation terminated. make[1]: *** [Makefile:197: sqGdbARMv8Plugin.lo] Error 1 make: *** [Makefile:557: GdbARMv8Plugin.la] Error 2 * Then I gave up on AArch64 support and tried only with AMD64 by cleaning opensmalltalk-vm/building/linux64x64/gdbarm64. This time VM compiled fine. * As a next step, I built VMMaker image: cd opensmalltalk-vm/image ./buildspurtrunkvmmaker64image.sh -vm ../building/linux64x64/squeak.cog.spur/build/squeak.sh This worked just fine, producing Spur64VMMaker.image * Finally, I tried to see AMD64 (since I could not build AArch64 sim plugin) machine code for some method, so I executed following smalltalk code in a workspace (which is just a modification of what is suggested in one of pre-opened workspaces I only changed memory manager class and ISA): StackToRegisterMappingCogit genAndDis: SequenceableCollection>>#indexOf:startingAt:ifAbsent: options: #(ObjectMemory Spur64BitCoMemoryManager ISA X64). This resulted in DNU: 28 September 2023 1:07:59.435358 pm VM: unix - Smalltalk Image: Squeak6.1alpha [latest update: #22775] SecurityManager state: Restricted: false FileAccess: true SocketAccess: true Working Dir /home/jv/Projects/Squeak/opensmalltalk-vm/image Trusted Dir /home/jv/Projects/Squeak/opensmalltalk-vm/image/secure Untrusted Dir /home/jv/Projects/Squeak/opensmalltalk-vm/image/My Squeak UndefinedObject(Object)>>doesNotUnderstand: #isCMBlock Receiver: nil Arguments and temporary variables: aMessage: isCMBlock exception: MessageNotUnderstood: UndefinedObject>>isCMBlock resumeValue: nil Receiver's instance variables: nil StackToRegisterMappingCogit(Cogit)>>disassembleMethod:on: Receiver: a StackToRegisterMappingCogit Arguments and temporary variables: surrogateOrAddress: nil aStream: a TranscriptStream cogMethod: nil mapEntries: nil codeRanges: nil i: nil iLimiT: nil Receiver's instance variables: coInterpreter: a CurrentImageCoInterpreterFacadeFor64BitSpurObjectRepresentation...etc... objectMemory: a CurrentImageCoInterpreterFacadeFor64BitSpurObjectRepresentation...etc... objectRepresentation: a CogObjectRepresentationFor64BitSpur processor: a BochsX64Alien64 rax: 00000101 (257) rbx: 00000000 rcx: 00000000 rdx...etc... processorLock: a Mutex() methodZone: a CogMethodZone methodZoneBase: 5784 codeBase: 1024 lastNInstructions: an OrderedCollection(a DoubleWordArray(0 0 0 0 4193216 41932...etc... simulatedAddresses: a Dictionary(#argumentCount->9223372036854775932 #ceActivateFailingPrimitiveMethod:...etc... simulatedTrampolines: a Dictionary(9223372036854775980->MessageSend(#ceSend:super:to:numArgs:...etc... simulatedVariableGetters: a Dictionary() simulatedVariableSetters: a Dictionary() printRegisters: false printInstructions: false compilationTrace: 0 clickConfirm: false clickStepping: false breakPC: nil breakBlock: nil singleStep: true guardPageSize: 1024 traceFlags: 8 traceStores: 0 breakMethod: nil methodObj: nil enumeratingCogMethod: nil methodHeader: nil initialPC: 0 endPC: nil methodOrBlockNumArgs: 0 inBlock: nil needsFrame: nil hasYoungReferent: false hasMovableLiteral: true primitiveIndex: nil backEnd: a CogInLineLiteralsX64Compiler literalsManager: an InLineLiteralsManager methodLabel: a CogInLineLiteralsX64Compiler (Label 0 @1698) stackCheckLabel: nil blockEntryLabel: nil blockEntryNoContextSwitch: nil blockNoContextSwitchOffset: nil stackOverflowCall: a CogInLineLiteralsX64Compiler (MoveCqR 0 ReceiverResultReg ...etc... sendMiss: a CogInLineLiteralsX64Compiler (Call 1680/690 E8 A0 F0 FF FF @15EB) missOffset: 48 entryPointMask: 7 checkedEntryAlignment: 0 uncheckedEntryAlignment: 7 cmEntryOffset: 48 entry: a CogInLineLiteralsX64Compiler (Label 1 @16C8) cmNoCheckEntryOffset: 71 noCheckEntry: a CogInLineLiteralsX64Compiler (Label 3 @1607) fullBlockEntry: nil cbEntryOffset: nil fullBlockNoContextSwitchEntry: nil cbNoSwitchEntryOffset: nil picMNUAbort: a CogInLineLiteralsX64Compiler (MoveCqR 0 ClassReg 48 31 C9 @16C0)...etc... picInterpretAbort: a CogInLineLiteralsX64Compiler (Call 2336/920 E8 58 F2 FF FF...etc... endCPICCase0: a CogInLineLiteralsX64Compiler (Label 3 @1617) endCPICCase1: a CogInLineLiteralsX64Compiler (Label 4 @162D) firstCPICCaseOffset: 87 cPICCaseSize: 22 cPICEndSize: 12 closedPICSize: 216 openPICSize: 360 fixups: a CArrayAccessor on: {a CogSSBytecodeFixup ( 0 ix 2) . a CogSSBytecodeFixup...etc... abstractOpcodes: a CArrayAccessor on: {a CogInLineLiteralsX64Compiler (MoveCqR ...etc... generatorTable: a CArrayAccessor on: {a CogBytecodeDescriptor (genPushReceiverVariableBytecode...etc... byte0: nil byte1: nil byte2: nil byte3: nil bytecodePC: nil bytecodeSetOffset: nil opcodeIndex: 64 numAbstractOpcodes: 100 blockStarts: nil blockCount: nil labelCounter: 5 cStackAlignment: 32 expectedSPAlignment: 0 expectedFPAlignment: 16 codeModified: nil maxLitIndex: nil ceMethodAbortTrampoline: nil cePICAbortTrampoline: nil ceCheckForInterruptTrampoline: 4648 ceCPICMissTrampoline: nil ceReturnToInterpreterTrampoline: 4872 ceBaseFrameReturnTrampoline: 4920 ceReapAndResetErrorCodeTrampoline: 2768 ceSendMustBeBooleanAddTrueTrampoline: 4544 ceSendMustBeBooleanAddFalseTrampoline: 4488 ceCannotResumeTrampoline: 4800 ceEnterCogCodePopReceiverReg: 4960 ceCallCogCodePopReceiverReg: 4984 ceCallCogCodePopReceiverAndClassRegs: 5008 cePrimReturnEnterCogCode: 5032 cePrimReturnEnterCogCodeProfiling: 5120 ceNonLocalReturnTrampoline: 4600 ceFetchContextInstVarTrampoline: 4696 ceStoreContextInstVarTrampoline: 4744 ceEnclosingObjectTrampoline: nil ceFlushDCache: nil ceFlushICache: nil ceTraceLinkedSendTrampoline: 9223372036854776172 ceTraceBlockActivationTrampoline: 9223372036854776180 ceTraceStoreTrampoline: 9223372036854776188 ceGetFP: 1024 ceGetSP: 1032 ceCaptureCStackPointers: 1040 ceInvokeInterpret: 4840 ordinarySendTrampolines: a CArrayAccessor on: #(1144 1208 1280 1352) superSendTrampolines: a CArrayAccessor on: #(1408 1480 1552 1624) directedSuperSendTrampolines: nil directedSuperBindingSendTrampolines: nil dynamicSuperSendTrampolines: nil outerSendTrampolines: nil selfSendTrampolines: nil firstSend: 1144 lastSend: 1624 realCEEnterCogCodePopReceiverReg: nil realCECallCogCodePopReceiverReg: nil realCECallCogCodePopReceiverAndClassRegs: nil trampolineTableIndex: 124 trampolineAddresses: a CArrayAccessor on: #('ceGetFP' 1024 'ceGetSP' 1032 'ceCa...etc... objectReferencesInRuntime: a CArrayAccessor on: #() runtimeObjectRefIndex: 0 cFramePointerInUse: true ceTryLockVMOwner: nil extA: 0 extB: 0 numExtB: 0 tempOop: nil numIRCs: nil indexOfIRC: nil theIRCs: nil receiverTags: nil implicitReceiverSendTrampolines: nil cogMethodSurrogateClass: CogMethodSurrogate64 cogBlockMethodSurrogateClass: CogBlockMethodSurrogate64 nsSendCacheSurrogateClass: NSSendCacheSurrogate64 cPICPrototype: a CogMethodSurrogate64 @5568/16r15C0 cPICEndOfCodeOffset: 209 cPICEndOfCodeLabel: a CogInLineLiteralsX64Compiler (Label 6 @1691) ceMallocTrampoline: nil ceFreeTrampoline: nil ceFFICalloutTrampoline: nil debugBytecodePointers: a Set() debugOpcodeIndices: a Set() disassemblingMethod: nil cogConstituentIndex: nil directedSendUsesBinding: nil processorFrameValid: false codeToDataDelta: 0 varBaseAddress: 2097160 codeZoneIsExecutableNotWritable: false debugAPISelector: nil shortCutTrampolineBlocks: an IdentityDictionary(#ceShortCutTraceBlockActivation:...etc... ioHighResClock: 996 perMethodProfile: nil instructionProfile: nil primitiveGeneratorTable: a CArrayAccessor on: {a CogPrimitiveDescriptor . a CogPrimitiveDescriptor...etc... introspectionDataIndex: nil introspectionData: nil prevBCDescriptor: nil numPushNilsFunction: #v3:Num:Push:Nils: pushNilSizeFunction: #v3PushNilSize:numInitialNils: methodOrBlockNumTemps: nil regArgsHaveBeenPushed: nil simStack: a CArrayAccessor on: {a CogSimStackEntry . a CogSimStackEntry . a CogSimStackEntry...etc... simStackPtr: nil simSpillBase: nil ceCallCogCodePopReceiverArg0Regs: 5248 ceCallCogCodePopReceiverArg1Arg0Regs: 5272 methodAbortTrampolines: a CArrayAccessor on: #(1680 1792 1904 2016) picAbortTrampolines: a CArrayAccessor on: #(2104 2216 2336 2456) picMissTrampolines: a CArrayAccessor on: #(2552 2608 2664 2720) ceCall0ArgsPIC: 5296 ceCall1ArgsPIC: 5328 ceCall2ArgsPIC: 5360 debugStackPointers: nil debugFixupBreaks: a Set() realCECallCogCodePopReceiverArg0Regs: nil realCECallCogCodePopReceiverArg1Arg0Regs: nil deadCode: nil useTwoPaths: nil currentCallCleanUpSize: nil simNativeStack: a CArrayAccessor on: {a CogSimStackNativeEntry . a CogSimStackNativeEntry...etc... simNativeStackPtr: nil simNativeSpillBase: nil simNativeStackSize: nil hasNativeFrame: nil compilationPass: nil StackToRegisterMappingCogit(Cogit)>>disassembleMethod: Receiver: a StackToRegisterMappingCogit Arguments and temporary variables: surrogateOrAddress: nil Receiver's instance variables: coInterpreter: a CurrentImageCoInterpreterFacadeFor64BitSpurObjectRepresentation...etc... objectMemory: a CurrentImageCoInterpreterFacadeFor64BitSpurObjectRepresentation...etc... objectRepresentation: a CogObjectRepresentationFor64BitSpur processor: a BochsX64Alien64 rax: 00000101 (257) rbx: 00000000 rcx: 00000000 rdx...etc... processorLock: a Mutex() methodZone: a CogMethodZone methodZoneBase: 5784 codeBase: 1024 lastNInstructions: an OrderedCollection(a DoubleWordArray(0 0 0 0 4193216 41932...etc... simulatedAddresses: a Dictionary(#argumentCount->9223372036854775932 #ceActivateFailingPrimitiveMethod:...etc... simulatedTrampolines: a Dictionary(9223372036854775980->MessageSend(#ceSend:super:to:numArgs:...etc... simulatedVariableGetters: a Dictionary() simulatedVariableSetters: a Dictionary() printRegisters: false printInstructions: false compilationTrace: 0 clickConfirm: false clickStepping: false breakPC: nil breakBlock: nil singleStep: true guardPageSize: 1024 traceFlags: 8 traceStores: 0 breakMethod: nil methodObj: nil enumeratingCogMethod: nil methodHeader: nil initialPC: 0 endPC: nil methodOrBlockNumArgs: 0 inBlock: nil needsFrame: nil hasYoungReferent: false hasMovableLiteral: true primitiveIndex: nil backEnd: a CogInLineLiteralsX64Compiler literalsManager: an InLineLiteralsManager methodLabel: a CogInLineLiteralsX64Compiler (Label 0 @1698) stackCheckLabel: nil blockEntryLabel: nil blockEntryNoContextSwitch: nil blockNoContextSwitchOffset: nil stackOverflowCall: a CogInLineLiteralsX64Compiler (MoveCqR 0 ReceiverResultReg ...etc... sendMiss: a CogInLineLiteralsX64Compiler (Call 1680/690 E8 A0 F0 FF FF @15EB) missOffset: 48 entryPointMask: 7 checkedEntryAlignment: 0 uncheckedEntryAlignment: 7 cmEntryOffset: 48 entry: a CogInLineLiteralsX64Compiler (Label 1 @16C8) cmNoCheckEntryOffset: 71 noCheckEntry: a CogInLineLiteralsX64Compiler (Label 3 @1607) fullBlockEntry: nil cbEntryOffset: nil fullBlockNoContextSwitchEntry: nil cbNoSwitchEntryOffset: nil picMNUAbort: a CogInLineLiteralsX64Compiler (MoveCqR 0 ClassReg 48 31 C9 @16C0)...etc... picInterpretAbort: a CogInLineLiteralsX64Compiler (Call 2336/920 E8 58 F2 FF FF...etc... endCPICCase0: a CogInLineLiteralsX64Compiler (Label 3 @1617) endCPICCase1: a CogInLineLiteralsX64Compiler (Label 4 @162D) firstCPICCaseOffset: 87 cPICCaseSize: 22 cPICEndSize: 12 closedPICSize: 216 openPICSize: 360 fixups: a CArrayAccessor on: {a CogSSBytecodeFixup ( 0 ix 2) . a CogSSBytecodeFixup...etc... abstractOpcodes: a CArrayAccessor on: {a CogInLineLiteralsX64Compiler (MoveCqR ...etc... generatorTable: a CArrayAccessor on: {a CogBytecodeDescriptor (genPushReceiverVariableBytecode...etc... byte0: nil byte1: nil byte2: nil byte3: nil bytecodePC: nil bytecodeSetOffset: nil opcodeIndex: 64 numAbstractOpcodes: 100 blockStarts: nil blockCount: nil labelCounter: 5 cStackAlignment: 32 expectedSPAlignment: 0 expectedFPAlignment: 16 codeModified: nil maxLitIndex: nil ceMethodAbortTrampoline: nil cePICAbortTrampoline: nil ceCheckForInterruptTrampoline: 4648 ceCPICMissTrampoline: nil ceReturnToInterpreterTrampoline: 4872 ceBaseFrameReturnTrampoline: 4920 ceReapAndResetErrorCodeTrampoline: 2768 ceSendMustBeBooleanAddTrueTrampoline: 4544 ceSendMustBeBooleanAddFalseTrampoline: 4488 ceCannotResumeTrampoline: 4800 ceEnterCogCodePopReceiverReg: 4960 ceCallCogCodePopReceiverReg: 4984 ceCallCogCodePopReceiverAndClassRegs: 5008 cePrimReturnEnterCogCode: 5032 cePrimReturnEnterCogCodeProfiling: 5120 ceNonLocalReturnTrampoline: 4600 ceFetchContextInstVarTrampoline: 4696 ceStoreContextInstVarTrampoline: 4744 ceEnclosingObjectTrampoline: nil ceFlushDCache: nil ceFlushICache: nil ceTraceLinkedSendTrampoline: 9223372036854776172 ceTraceBlockActivationTrampoline: 9223372036854776180 ceTraceStoreTrampoline: 9223372036854776188 ceGetFP: 1024 ceGetSP: 1032 ceCaptureCStackPointers: 1040 ceInvokeInterpret: 4840 ordinarySendTrampolines: a CArrayAccessor on: #(1144 1208 1280 1352) superSendTrampolines: a CArrayAccessor on: #(1408 1480 1552 1624) directedSuperSendTrampolines: nil directedSuperBindingSendTrampolines: nil dynamicSuperSendTrampolines: nil outerSendTrampolines: nil selfSendTrampolines: nil firstSend: 1144 lastSend: 1624 realCEEnterCogCodePopReceiverReg: nil realCECallCogCodePopReceiverReg: nil realCECallCogCodePopReceiverAndClassRegs: nil trampolineTableIndex: 124 trampolineAddresses: a CArrayAccessor on: #('ceGetFP' 1024 'ceGetSP' 1032 'ceCa...etc... objectReferencesInRuntime: a CArrayAccessor on: #() runtimeObjectRefIndex: 0 cFramePointerInUse: true ceTryLockVMOwner: nil extA: 0 extB: 0 numExtB: 0 tempOop: nil numIRCs: nil indexOfIRC: nil theIRCs: nil receiverTags: nil implicitReceiverSendTrampolines: nil cogMethodSurrogateClass: CogMethodSurrogate64 cogBlockMethodSurrogateClass: CogBlockMethodSurrogate64 nsSendCacheSurrogateClass: NSSendCacheSurrogate64 cPICPrototype: a CogMethodSurrogate64 @5568/16r15C0 cPICEndOfCodeOffset: 209 cPICEndOfCodeLabel: a CogInLineLiteralsX64Compiler (Label 6 @1691) ceMallocTrampoline: nil ceFreeTrampoline: nil ceFFICalloutTrampoline: nil debugBytecodePointers: a Set() debugOpcodeIndices: a Set() disassemblingMethod: nil cogConstituentIndex: nil directedSendUsesBinding: nil processorFrameValid: false codeToDataDelta: 0 varBaseAddress: 2097160 codeZoneIsExecutableNotWritable: false debugAPISelector: nil shortCutTrampolineBlocks: an IdentityDictionary(#ceShortCutTraceBlockActivation:...etc... ioHighResClock: 996 perMethodProfile: nil instructionProfile: nil primitiveGeneratorTable: a CArrayAccessor on: {a CogPrimitiveDescriptor . a CogPrimitiveDescriptor...etc... introspectionDataIndex: nil introspectionData: nil prevBCDescriptor: nil numPushNilsFunction: #v3:Num:Push:Nils: pushNilSizeFunction: #v3PushNilSize:numInitialNils: methodOrBlockNumTemps: nil regArgsHaveBeenPushed: nil simStack: a CArrayAccessor on: {a CogSimStackEntry . a CogSimStackEntry . a CogSimStackEntry...etc... simStackPtr: nil simSpillBase: nil ceCallCogCodePopReceiverArg0Regs: 5248 ceCallCogCodePopReceiverArg1Arg0Regs: 5272 methodAbortTrampolines: a CArrayAccessor on: #(1680 1792 1904 2016) picAbortTrampolines: a CArrayAccessor on: #(2104 2216 2336 2456) picMissTrampolines: a CArrayAccessor on: #(2552 2608 2664 2720) ceCall0ArgsPIC: 5296 ceCall1ArgsPIC: 5328 ceCall2ArgsPIC: 5360 debugStackPointers: nil debugFixupBreaks: a Set() realCECallCogCodePopReceiverArg0Regs: nil realCECallCogCodePopReceiverArg1Arg0Regs: nil deadCode: nil useTwoPaths: nil currentCallCleanUpSize: nil simNativeStack: a CArrayAccessor on: {a CogSimStackNativeEntry . a CogSimStackNativeEntry...etc... simNativeStackPtr: nil simNativeSpillBase: nil simNativeStackSize: nil hasNativeFrame: nil compilationPass: nil StackToRegisterMappingCogit class(Cogit class)>>genAndDis:options: Receiver: StackToRegisterMappingCogit Arguments and temporary variables: methodOrDoitString: (SequenceableCollection>>#indexOf:startingAt:ifAbsent: "a CompiledMethod...etc... optionsDictionaryOrArray: #(#ObjectMemory #Spur64BitCoMemoryManager #ISA #X64) tuple: {a CurrentImageCoInterpreterFacadeFor64BitSpurObjectRepresentation . a StackToRegisterMappingCogit...etc... Receiver's instance variables: superclass: SimpleStackBasedCogit methodDict: a MethodDictionary(size 607) format: 65731 instanceVariables: #('prevBCDescriptor' 'numPushNilsFunction' 'pushNilSizeFunct...etc... organization: ('accessing' simSelf) ('bytecode generator stores' genGenericStorePop:MaybeContextSlotIndex:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck:...etc... subclasses: {RegisterAllocatingCogit . SistaCogit . StackToRegisterMappingCogitChecker...etc... name: #StackToRegisterMappingCogit classPool: a Dictionary(#NeedsMergeFixupFlag->nil #NeedsNonMergeFixupFlag->nil ...etc... sharedPools: an OrderedCollection(CogCompilationConstants VMMethodCacheConstants...etc... environment: Smalltalk category: #'VMMaker-JIT' timeStamp: 3873358619 generatorTable: a CArrayAccessor on: {a CogBytecodeDescriptor (genPushReceiverVariableBytecode...etc... primitiveTable: a CArrayAccessor on: {a CogPrimitiveDescriptor . a CogPrimitiveDescriptor...etc... numPushNilsFunction: #v3:Num:Push:Nils: pushNilSizeFunction: #v3PushNilSize:numInitialNils: UndefinedObject>>DoIt Receiver: nil Arguments and temporary variables: Receiver's instance variables: nil Compiler>>evaluateCue:ifFail: Receiver: a Compiler Arguments and temporary variables: aCue: a CompilationCue failBlock: [closure] in Compiler>>evaluateCue:ifFail:logged: methodNode: DoIt ^ StackToRegisterMappingCogit genAndDis: SequenceableCollecti...etc... method: (UndefinedObject>>#DoIt "a CompiledMethod(4121528)") value: nil Receiver's instance variables: parser: a Parser cue: a CompilationCue Compiler>>evaluateCue:ifFail:logged: Receiver: a Compiler Arguments and temporary variables: aCue: a CompilationCue failBlock: [closure] in [] in SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo:...etc... logFlag: true value: nil Receiver's instance variables: parser: a Parser cue: a CompilationCue Compiler>>evaluate:in:to:environment:notifying:ifFail:logged: Receiver: a Compiler Arguments and temporary variables: textOrStream: a ReadStream aContext: nil receiver: nil anEnvironment: Smalltalk aRequestor: a SmalltalkEditor failBlock: [closure] in [] in SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo:...etc... logFlag: true Receiver's instance variables: parser: a Parser cue: a CompilationCue [] in SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: Receiver: a SmalltalkEditor Arguments and temporary variables: aBlock: [closure] in SmalltalkEditor(TextEditor)>>evaluateSelection result: nil rcvr: nil ctxt: nil Receiver's instance variables: morph: a TextMorphForEditView(216877) model: a Workspace paragraph: a NewParagraph markBlock: a CharacterBlock with index 613 and character Character return and r...etc... pointBlock: a CharacterBlock with index 767 and rectangle 422@290 corner: 422@3...etc... beginTypeInIndex: nil emphasisHere: {a TextColor code: Color black} lastParenLocation: nil otherInterval: (613 to: 766) oldInterval: (627 to: 626) typeAhead: a WriteStream history: a TextEditorCommandHistory FullBlockClosure(BlockClosure)>>on:do: Receiver: [closure] in SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: Arguments and temporary variables: exceptionOrExceptionSet: OutOfScopeNotification handlerAction: [closure] in SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo:...etc... handlerActive: true handlerRearmed: false Receiver's instance variables: outerContext: SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: startpcOrMethod: ([] in TextEditor>>#evaluateSelectionAndDo: "a CompiledBlock(3...etc... numArgs: 0 receiver: a SmalltalkEditor SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: Receiver: a SmalltalkEditor Arguments and temporary variables: aBlock: [closure] in SmalltalkEditor(TextEditor)>>evaluateSelection result: nil rcvr: nil ctxt: nil Receiver's instance variables: morph: a TextMorphForEditView(216877) model: a Workspace paragraph: a NewParagraph markBlock: a CharacterBlock with index 613 and character Character return and r...etc... pointBlock: a CharacterBlock with index 767 and rectangle 422@290 corner: 422@3...etc... beginTypeInIndex: nil emphasisHere: {a TextColor code: Color black} lastParenLocation: nil otherInterval: (613 to: 766) oldInterval: (627 to: 626) typeAhead: a WriteStream history: a TextEditorCommandHistory SmalltalkEditor(TextEditor)>>evaluateSelection Receiver: a SmalltalkEditor Arguments and temporary variables: Receiver's instance variables: morph: a TextMorphForEditView(216877) model: a Workspace paragraph: a NewParagraph markBlock: a CharacterBlock with index 613 and character Character return and r...etc... pointBlock: a CharacterBlock with index 767 and rectangle 422@290 corner: 422@3...etc... beginTypeInIndex: nil emphasisHere: {a TextColor code: Color black} lastParenLocation: nil otherInterval: (613 to: 766) oldInterval: (627 to: 626) typeAhead: a WriteStream history: a TextEditorCommandHistory SmalltalkEditor(TextEditor)>>doIt Receiver: a SmalltalkEditor Arguments and temporary variables: Receiver's instance variables: morph: a TextMorphForEditView(216877) model: a Workspace paragraph: a NewParagraph markBlock: a CharacterBlock with index 613 and character Character return and r...etc... pointBlock: a CharacterBlock with index 767 and rectangle 422@290 corner: 422@3...etc... beginTypeInIndex: nil emphasisHere: {a TextColor code: Color black} lastParenLocation: nil otherInterval: (613 to: 766) oldInterval: (627 to: 626) typeAhead: a WriteStream history: a TextEditorCommandHistory SmalltalkEditor(TextEditor)>>doIt: Receiver: a SmalltalkEditor Arguments and temporary variables: aKeyboardEvent: [104@339 keystroke '<Ctrl-Cmd-d>' (100) 3090] Receiver's instance variables: morph: a TextMorphForEditView(216877) model: a Workspace paragraph: a NewParagraph markBlock: a CharacterBlock with index 613 and character Character return and r...etc... pointBlock: a CharacterBlock with index 767 and rectangle 422@290 corner: 422@3...etc... beginTypeInIndex: nil emphasisHere: {a TextColor code: Color black} lastParenLocation: nil otherInterval: (613 to: 766) oldInterval: (627 to: 626) typeAhead: a WriteStream history: a TextEditorCommandHistory SmalltalkEditor(TextEditor)>>dispatchOnKeyboardEvent: Receiver: a SmalltalkEditor Arguments and temporary variables: aKeyboardEvent: [104@339 keystroke '<Ctrl-Cmd-d>' (100) 3090] honorCommandKeys: true typedChar: $d Receiver's instance variables: morph: a TextMorphForEditView(216877) model: a Workspace paragraph: a NewParagraph markBlock: a CharacterBlock with index 613 and character Character return and r...etc... pointBlock: a CharacterBlock with index 767 and rectangle 422@290 corner: 422@3...etc... beginTypeInIndex: nil emphasisHere: {a TextColor code: Color black} lastParenLocation: nil otherInterval: (613 to: 766) oldInterval: (627 to: 626) typeAhead: a WriteStream history: a TextEditorCommandHistory SmalltalkEditor(TextEditor)>>keyStroke: Receiver: a SmalltalkEditor Arguments and temporary variables: anEvent: [104@339 keystroke '<Ctrl-Cmd-d>' (100) 3090] Receiver's instance variables: morph: a TextMorphForEditView(216877) model: a Workspace paragraph: a NewParagraph markBlock: a CharacterBlock with index 613 and character Character return and r...etc... pointBlock: a CharacterBlock with index 767 and rectangle 422@290 corner: 422@3...etc... beginTypeInIndex: nil emphasisHere: {a TextColor code: Color black} lastParenLocation: nil otherInterval: (613 to: 766) oldInterval: (627 to: 626) typeAhead: a WriteStream history: a TextEditorCommandHistory [] in [] in TextMorphForEditView(TextMorph)>>keyStroke: Receiver: a TextMorphForEditView(216877) Arguments and temporary variables: evt: [104@339 keystroke '<Ctrl-Cmd-d>' (100) 3090] action: nil Receiver's instance variables: bounds: 0@0 corner: 753@308 owner: a TransformMorph(217319) submorphs: #() fullBounds: 0@0 corner: 753@308 color: Color black extension: a MorphExtension (1612197) [other: (unfocusedSelectionColor -> (Col...etc... borderWidth: 0 borderColor: Color black textStyle: a TextStyle(6) Bitmap DejaVu Sans 10.5pt 96ppi 14px Normal text: a Text for '"See what code the JIT generates for as method in the current...etc... wrapFlag: true paragraph: a NewParagraph editor: a SmalltalkEditor container: nil predecessor: nil successor: nil backgroundColor: nil margins: 3@2 corner: 3@2 readOnly: false autoFit: true plainTextOnly: false numCharactersPerLine: nil editView: a PluggableTextMorphPlus(1615011) acceptOnCR: false TextMorphForEditView(TextMorph)>>handleInteraction:fromEvent: Receiver: a TextMorphForEditView(216877) Arguments and temporary variables: interactionBlock: [closure] in [] in TextMorphForEditView(TextMorph)>>keyStroke:...etc... evt: [104@339 keystroke '<Ctrl-Cmd-d>' (100) 3090] oldEditor: a SmalltalkEditor oldParagraph: a NewParagraph oldText: a Text for '"See what code the JIT generates for as method in the curr...etc... oldSelection: an OrderedCollection(3@242 corner: 750@290 3@290 corner: 422@306)...etc... Receiver's instance variables: bounds: 0@0 corner: 753@308 owner: a TransformMorph(217319) submorphs: #() fullBounds: 0@0 corner: 753@308 color: Color black extension: a MorphExtension (1612197) [other: (unfocusedSelectionColor -> (Col...etc... borderWidth: 0 borderColor: Color black textStyle: a TextStyle(6) Bitmap DejaVu Sans 10.5pt 96ppi 14px Normal text: a Text for '"See what code the JIT generates for as method in the current...etc... wrapFlag: true paragraph: a NewParagraph editor: a SmalltalkEditor container: nil predecessor: nil successor: nil backgroundColor: nil margins: 3@2 corner: 3@2 readOnly: false autoFit: true plainTextOnly: false numCharactersPerLine: nil editView: a PluggableTextMorphPlus(1615011) acceptOnCR: false TextMorphForEditView>>handleInteraction:fromEvent: Receiver: a TextMorphForEditView(216877) Arguments and temporary variables: interActionBlock: [closure] in [] in TextMorphForEditView(TextMorph)>>keyStroke:...etc... evt: [104@339 keystroke '<Ctrl-Cmd-d>' (100) 3090] Receiver's instance variables: bounds: 0@0 corner: 753@308 owner: a TransformMorph(217319) submorphs: #() fullBounds: 0@0 corner: 753@308 color: Color black extension: a MorphExtension (1612197) [other: (unfocusedSelectionColor -> (Col...etc... borderWidth: 0 borderColor: Color black textStyle: a TextStyle(6) Bitmap DejaVu Sans 10.5pt 96ppi 14px Normal text: a Text for '"See what code the JIT generates for as method in the current...etc... wrapFlag: true paragraph: a NewParagraph editor: a SmalltalkEditor container: nil predecessor: nil successor: nil backgroundColor: nil margins: 3@2 corner: 3@2 readOnly: false autoFit: true plainTextOnly: false numCharactersPerLine: nil editView: a PluggableTextMorphPlus(1615011) acceptOnCR: false --- The full stack --- UndefinedObject(Object)>>doesNotUnderstand: #isCMBlock StackToRegisterMappingCogit(Cogit)>>disassembleMethod:on: StackToRegisterMappingCogit(Cogit)>>disassembleMethod: StackToRegisterMappingCogit class(Cogit class)>>genAndDis:options: UndefinedObject>>DoIt Compiler>>evaluateCue:ifFail: Compiler>>evaluateCue:ifFail:logged: Compiler>>evaluate:in:to:environment:notifying:ifFail:logged: [] in SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: FullBlockClosure(BlockClosure)>>on:do: SmalltalkEditor(TextEditor)>>evaluateSelectionAndDo: SmalltalkEditor(TextEditor)>>evaluateSelection SmalltalkEditor(TextEditor)>>doIt SmalltalkEditor(TextEditor)>>doIt: SmalltalkEditor(TextEditor)>>dispatchOnKeyboardEvent: SmalltalkEditor(TextEditor)>>keyStroke: [] in [] in TextMorphForEditView(TextMorph)>>keyStroke: TextMorphForEditView(TextMorph)>>handleInteraction:fromEvent: TextMorphForEditView>>handleInteraction:fromEvent: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - [] in TextMorphForEditView(TextMorph)>>keyStroke: StandardToolSet class>>codeCompletionAround:textMorph:keyStroke: ToolSet class>>codeCompletionAround:textMorph:keyStroke: TextMorphForEditView(TextMorph)>>keyStroke: TextMorphForEditView>>keyStroke: TextMorphForEditView(Morph)>>handleKeystroke: TextMorphForEditView(TextMorph)>>handleKeystroke: KeyboardEvent>>sentTo: TextMorphForEditView(Morph)>>handleEvent: TextMorphForEditView(Morph)>>handleFocusEvent: MorphicEventDispatcher>>doHandlingForFocusEvent:with: MorphicEventDispatcher>>dispatchFocusEvent:with: TextMorphForEditView(Morph)>>processFocusEvent:using: TextMorphForEditView(Morph)>>processFocusEvent: [] in [] in [] in HandMorph>>sendFocusEvent:to:clear: [] in ActiveEventVariable class(DynamicVariable class)>>value:during: FullBlockClosure(BlockClosure)>>ensure: ActiveEventVariable class(DynamicVariable class)>>value:during: [] in ActiveEventVariable class>>value:during: FullBlockClosure(BlockClosure)>>ensure: ActiveEventVariable class>>value:during: KeyboardEvent(MorphicEvent)>>becomeActiveDuring: [] in [] in HandMorph>>sendFocusEvent:to:clear: [] in ActiveHandVariable class(DynamicVariable class)>>value:during: FullBlockClosure(BlockClosure)>>ensure: ActiveHandVariable class(DynamicVariable class)>>value:during: [] in ActiveHandVariable class>>value:during: FullBlockClosure(BlockClosure)>>ensure: ActiveHandVariable class>>value:during: HandMorph>>becomeActiveDuring: [] in HandMorph>>sendFocusEvent:to:clear: [] in ActiveWorldVariable class(DynamicVariable class)>>value:during: FullBlockClosure(BlockClosure)>>ensure: ActiveWorldVariable class(DynamicVariable class)>>value:during: [] in ActiveWorldVariable class>>value:during: FullBlockClosure(BlockClosure)>>ensure: ActiveWorldVariable class>>value:during: PasteUpMorph>>becomeActiveDuring: HandMorph>>sendFocusEvent:to:clear: HandMorph>>sendEvent:focus:clear: HandMorph>>sendKeyboardEvent: HandMorph>>handleEvent: -- and more not shown --

2 3

Re: [Newbies] FreeBSD VM
by Tobias Pape 30 Sep '23

30 Sep '23

Hi David > On 30. Mar 2023, at 16:09, David Gray <dgray(a)iesl.forth.gr> wrote: > > I’ve been trying to get a working VM for FreeBSD. However even though I manage to get the system to start and update itself it gives a segmentation error when I open a workspace and type any character at all. I used the latest linux64x64 cog.spur. > Both the 6.0 and 5.3 images behaved the same. To get it to compile I had the comment out the Joystick plugin and edit the baud rates inside the serial plugin. I’m a complete beginner with squeak so I don’t know how to proceed from here. Based on your comments, I went and tried to verify that the VM still builds. I have made similar adjustments and was able to build a VM with the recents commits to the Cog branch of the VM. Can you please build a debug vm and try to recreate the error? I am very interested in that. Best regards -Tobias

4 5

[OpenSmalltalk/opensmalltalk-vm] DropPlugin should percent-decode the file URI on Unix (Issue #666)
by MariusDoe 22 Sep '23

22 Sep '23

On Unix, when dropping a file that has spaces or other special characters in its path, `primitiveDropRequestFileName` returns a [percent-encoded](https://en.wikipedia.org/wiki/Percent-encoding) version of the path and `primitiveDropRequestFileHandle` fails. I think the problem is that [`dropRequestFileName`](https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/330d6779ad2ecbce1f07131f53d75cd168165f0b/platforms/unix/plugins/DropPlugin/sqUnixDragDrop.c#L72-L101) [skips the `file:///` prefix of the URI](https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/330d6779ad2ecbc…, but does not percent-decode it. Interestingly, [`uri2string`](https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/330d6779ad2ecbce1f07131f53d75cd168165f0b/platforms/unix/vm-display-X11/sqUnixXdnd.c#L206-L234), which [isn't currently used](https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/330d6779ad2ecb…, [does percent-decoding](https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/33…. `dropRequestFileName` [is used by `primitiveDropRequestFileName`](https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/330d6779ad2ecbce1f07131f53d75cd168165f0b/src/plugins/DropPlugin/DropPlugin.c#L132) and also by [`dropRequestFileHandle`](https://github.com/OpenSmalltalk/opensmalltalk-vm/blob/330d6779ad2ecbce1f07131f53d75cd168165f0b/platforms/unix/plugins/DropPlugin/sqUnixDragDrop.c#L117), which is why `primitiveDropRequestFileHandle` fails. Note: I did not check whether this problem exists on other platforms. -- Reply to this email directly or view it on GitHub: https://github.com/OpenSmalltalk/opensmalltalk-vm/issues/666 You are receiving this because you are subscribed to this thread. Message ID: <OpenSmalltalk/opensmalltalk-vm/issues/666(a)github.com>

1 0

ExtendedClipboardInterface in latest VM build reporting wrong pluginVersion?
by Bernhard Pieber 19 Sep '23

19 Sep '23

Hi, I downloaded the latest macOS VM build from here: https://github.com/OpenSmalltalk/opensmalltalk-vm/suites/14338173951/artifa… It includes a ClipboardExtendedPlugin.bundle with the version number 5.0-202307170225-64bit. The latest released VM includes a ClipboardExtendedPlugin.bundle with a lower version number 5.0-202206021410-64bit. However, when I run the trunk image with both VMs ExtendedClipboardInterface pluginVersion returns the same version number 3166. In ExtendedClipboardMacInterface>>#clipboardText: I found the following text in the comment: "But we can only paste more than one thing at a time with the VMMaker.oscog-eem.3276 version of the plugin, or later." The plugin version is later checked in that method. In a current Cuis image I verified that the plugin in the latest VM build does indeed allow to copy more than one format at a time. This leads me to believe that the version number the latest VM build reports in ExtendedClipboardInterface pluginVersion might be wrong. What do you think? Cheers,Bernhard

1 1

VM Maker: VMMaker.oscog-eem.3338.mcz
by commits＠source.squeak.org 17 Sep '23

17 Sep '23

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.3338.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.3338 Author: eem Time: 16 September 2023, 8:17:48.533178 pm UUID: 1d7f8a94-2a3d-47fa-867b-d6ea3029be14 Ancestors: VMMaker.oscog-LM.3337 Nuke unused methods: getMaxWaitingPriority & generateLowLevelTryLock: Restore some slips in VMMaker.oscog-LM.3337: CogARMv8Compiler still uses DataCacheFlushRequired DataCacheLineLength InstructionCacheFlushRequired InstructionCacheLineLength. =============== Diff against VMMaker.oscog-LM.3337 =============== Item was removed: - ----- Method: CoInterpreterMT>>getMaxWaitingPriority (in category 'process primitive support') ----- - getMaxWaitingPriority - <cmacro: '() GIV(maxWaitingPriority)'> - ^maxWaitingPriority! Item was changed: CogAbstractInstruction subclass: #CogARMv8Compiler instanceVariableNames: '' + classVariableNames: 'AL ArithmeticAdd ArithmeticAddS ArithmeticSub ArithmeticSubS CASAL CArg0Reg CArg1Reg CArg2Reg CArg3Reg CArg4Reg CArg5Reg CArg6Reg CBNZ CBZ CC CCMPNE CLREX CS CSET D0 D1 D10 D11 D12 D13 D14 D15 D16 D17 D18 D19 D2 D20 D21 D22 D23 D24 D25 D26 D27 D28 D29 D3 D30 D31 D4 D5 D6 D7 D8 D9 DC DC_CISW DC_CIVAC DC_CSW DC_CVAC DC_CVAU DC_ISW DC_IVAC DC_ZVA DMB DSB DSB_ALL DSB_ALLSY DSB_ISH DSB_NSH DSB_OSH DSB_READS DSB_SY DSB_WRITES DataCacheFlushRequired DataCacheLineLength DivRRR EQ FP GE GT HI IC IC_IALLU IC_IALLUIS IC_IVAU ISB InstructionCacheFlushRequired InstructionCacheLineLength LDAXR LE LR LS LT LogicalAnd LogicalAndS LogicalOr LogicalXor MI MRS_CTR_EL0 MRS_ID_AA64ISAR0_EL1 MSubRRR MoveAwRR MoveRRAw MulOverflowRRR MulRRR NE NativePopRR NativePushRR PJWPNChange PJWPNClear PJWPNSet PJWPNState PL R0 R1 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R2 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R3 R30 R31 R4 R5 R6 R7 R8 R9 SMULHRRR SP STLR STLXR SXTB SXTH SXTW SXTX UXTB UXTH UX TW UXTX VC VS XZR' - classVariableNames: 'AL ArithmeticAdd ArithmeticAddS ArithmeticSub ArithmeticSubS CASAL CArg0Reg CArg1Reg CArg2Reg CArg3Reg CArg4Reg CArg5Reg CArg6Reg CBNZ CBZ CC CCMPNE CLREX CS CSET D0 D1 D10 D11 D12 D13 D14 D15 D16 D17 D18 D19 D2 D20 D21 D22 D23 D24 D25 D26 D27 D28 D29 D3 D30 D31 D4 D5 D6 D7 D8 D9 DC DC_CISW DC_CIVAC DC_CSW DC_CVAC DC_CVAU DC_ISW DC_IVAC DC_ZVA DMB DSB DSB_ALL DSB_ALLSY DSB_ISH DSB_NSH DSB_OSH DSB_READS DSB_SY DSB_WRITES DivRRR EQ FP GE GT HI IC IC_IALLU IC_IALLUIS IC_IVAU ISB LDAXR LE LR LS LT LogicalAnd LogicalAndS LogicalOr LogicalXor MI MRS_CTR_EL0 MRS_ID_AA64ISAR0_EL1 MSubRRR MoveAwRR MoveRRAw MulOverflowRRR MulRRR NE NativePopRR NativePushRR PJWPNChange PJWPNClear PJWPNSet PJWPNState PL R0 R1 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R2 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R3 R30 R31 R4 R5 R6 R7 R8 R9 SMULHRRR SP STLR STLXR SXTB SXTH SXTW SXTX UXTB UXTH UXTW UXTX VC VS XZR' poolDictionaries: 'ARMv8A64Opcodes' category: 'VMMaker-JIT'! !CogARMv8Compiler commentStamp: 'eem 1/7/2021 23:01' prior: 0! I generate ARMv8 machine code instructions from CogAbstractInstructions with CogRTLOpcodes. Here in "Arm ARM" refers to Arm® Architecture Reference Manual Armv8, for Armv8-A architecture profile https://developer.arm.com/docs/ddi0487/latest/arm-architecture-reference-ma… Some things to know about ARMv8 instructions: Whether 31 in a register field implies the zero register or the SP register(s) depends on the specific instruction. C3.2.1 Load/Store register If a Load instruction specifies writeback and the register being loaded is also the base register, then behavior is CONSTRAINED UNPREDICTABLE and one of the following behaviors must occur: - The instruction is treated as UNDEFINED. - The instruction is treated as a NOP. - The instruction performs the load using the specified addressing mode and the base register becomes UNKNOWN. In addition, if an exception occurs during the execution of such an instruction, the base address might be corrupted so that the instruction cannot be repeated. If a Store instruction performs a writeback and the register that is stored is also the base register, then behavior is CONSTRAINED UNPREDICTABLE and one of the following behaviors must occur: - The instruction is treated as UNDEFINED. - The instruction is treated as a NOP. - The instruction performs the store to the designated register using the specified addressing mode, but the value stored is UNKNOWN.! Item was changed: ----- Method: CogARMv8Compiler>>detectFeaturesOnLinux (in category 'feature detection') ----- detectFeaturesOnLinux "Do a throw-away compilation to read CTR_EL0 and initialize ctrEl0. Some linux kernels trap and synthesize access to ID_AA64ISAR0_EL1, and some do not, so use getauxval(3) to access value(s) derived there-from, i.e. whether the processor has atomic instructions." <option: #__linux__> | startAddress getFeatureReg ctrEL0 | <var: 'getFeatureReg' declareC: 'usqIntptr_t (*getFeatureReg)(void)'> startAddress := cogit methodZoneBase. cogit allocateOpcodes: 4 bytecodes: 0. getFeatureReg := cogit cCoerceSimple: startAddress to: #'usqIntptr_t (*)(void)'. "Return the value of CTR_EL0; that's the control register that defines the vital statistics of the processor's caches." cogit gen: Nop; "do something anodyne so it is easy to distinguish MRS_CTR_EL0 being an illegal instruction rather than the code zone not being executable." gen: MRS_CTR_EL0 operand: ABIResultReg; RetN: 0. cogit outputInstructionsForGeneratedRuntimeAt: startAddress. cogit resetMethodZoneBase: startAddress. cogit ensureExecutableCodeZoneWithin: [ctrEL0 := (self cCode: 'getFeatureReg()' inSmalltalk: [cogit simulateLeafCallOf: startAddress]). "see e.g. CogARMv8Compiler class>>printCTR_EL0:, concretizeCacheControlOp1:CRm:Op2: & http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.100403_0200_00_… DminLine & IminLine are Log2 words; 16 words miniumum" self setDataCacheFlushRequired: (ctrEL0 noMask: 1 << 28). self setDataCacheLineLength: 4 << (ctrEL0 >> 16 bitAnd: 15). self dataCacheLineLength = 0 ifTrue: [self setDataCacheLineLength: 4 << 4]. self setInstructionCacheFlushRequired: (ctrEL0 noMask: 1 << 29). self setInstructionCacheLineLength: 4 << (ctrEL0 bitAnd: 15)]. + self instructionCacheLineLength = 0 ifTrue: + [self setInstructionCacheLineLength: 4 << 4]! - self instructionCacheLineLength = 0 ifTrue: - [self setInstructionCacheLineLength: 4 << 4]. - self cppIf: COGMTVM ifTrue: - [self setHasAtomicInstructions: ((self getauxval: #AT_HWCAP) anyMask: #HWCAP_ATOMICS)]! Item was changed: ----- Method: CogARMv8Compiler>>detectFeaturesOnMacOS (in category 'memory access') ----- detectFeaturesOnMacOS <option: #__APPLE__> <inline: #always> "MacOS does not allow access to ctl_el0, so derive cache information etc from sysctl" "Here are values from sysctl(8), hardwired for now rather than derived through sysctl(3) hw.cacheconfig: 8 1 1 0 0 0 0 0 0 0 (we speculate that the 1's indicate cache flush required) hw.cachelinesize: 128 hw.l1icachesize: 131072 hw.l1dcachesize: 131072 hw.optional.neon: 1 hw.optional.neon_hpfp: 1 hw.optional.neon_fp16: 1 hw.optional.armv8_1_atomics: 1" false ifTrue: "Apple's cache flush code on M1 is simple and effective; we can't easily better it..." [self setDataCacheLineLength: 128. self setDataCacheFlushRequired: true. self setInstructionCacheLineLength: 128. + self setInstructionCacheFlushRequired: true]! - self setInstructionCacheFlushRequired: true]. - self cppIf: COGMTVM ifTrue: - [self setHasAtomicInstructions: true]! Item was changed: ----- Method: CogARMv8Compiler>>detectFeaturesOnRawMachine (in category 'feature detection') ----- detectFeaturesOnRawMachine "Do throw-away compilations to read CTR_EL0 & ID_AA64ISAR0_EL1 and initialize ctrEl0 & idISAR0" <notOption: #__APPLE__> <notOption: #__linux__> + | startAddress getFeatureReg ctrEL0 | - | startAddress getFeatureReg ctrEL0 idISAR0 | <var: 'getFeatureReg' declareC: 'usqIntptr_t (*getFeatureReg)(void)'> startAddress := cogit methodZoneBase. cogit allocateOpcodes: 4 bytecodes: 0. getFeatureReg := cogit cCoerceSimple: startAddress to: #'usqIntptr_t (*)(void)'. "Return the value of CTR_EL0; that's the control register that defines the vital statistics of the processor's caches." cogit gen: Nop; "do something anodyne so it is easy to distinguish MRS_CTR_EL0 being an illegal instruction rather than the code zone not being executable." gen: MRS_CTR_EL0 operand: ABIResultReg; RetN: 0. cogit outputInstructionsForGeneratedRuntimeAt: startAddress. cogit resetMethodZoneBase: startAddress. cogit ensureExecutableCodeZoneWithin: [ctrEL0 := (self cCode: 'getFeatureReg()' inSmalltalk: [cogit simulateLeafCallOf: startAddress]). "see e.g. CogARMv8Compiler class>>printCTR_EL0:, concretizeCacheControlOp1:CRm:Op2: & http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.100403_0200_00_… DminLine & IminLine are Log2 words; 16 words miniumum" self setDataCacheFlushRequired: (ctrEL0 noMask: 1 << 28). self setDataCacheLineLength: 4 << (ctrEL0 >> 16 bitAnd: 15). self dataCacheLineLength = 0 ifTrue: [self setDataCacheLineLength: 4 << 4]. self setInstructionCacheFlushRequired: (ctrEL0 noMask: 1 << 29). self setInstructionCacheLineLength: 4 << (ctrEL0 bitAnd: 15)]. + self instructionCacheLineLength = 0 ifTrue: + [self setInstructionCacheLineLength: 4 << 4]. - self instructionCacheLineLength = 0 ifTrue: - [self setInstructionCacheLineLength: 4 << 4]. cogit zeroOpcodeIndexForNewOpcodes. cogit gen: Nop; "do something anodyne so it is easy to distinguish MRS_ID_AA64ISAR0_EL1 being an illegal instruction rather than the code zone not being executable." gen: MRS_ID_AA64ISAR0_EL1 operand: ABIResultReg; RetN: 0. + cogit outputInstructionsForGeneratedRuntimeAt: startAddress! - cogit outputInstructionsForGeneratedRuntimeAt: startAddress. - self cppIf: COGMTVM ifTrue: - [cogit resetMethodZoneBase: startAddress. - cogit ensureExecutableCodeZoneWithin: - [idISAR0 := (self cCode: 'getFeatureReg()' inSmalltalk: [cogit simulateLeafCallOf: startAddress]). - self setHasAtomicInstructions: (idISAR0 >> 20 bitAnd: 2r1111) = 2r10]]! Item was removed: - ----- Method: CogARMv8Compiler>>generateLowLevelTryLock: (in category 'multi-threading') ----- - generateLowLevelTryLock: vmOwnerLockAddress - "Generate a function that attempts to lock the vmOwnerLock to the argument and answers if it succeeded." - <inline: #always> - | lockValueReg vmOwnerLockAddressReg br statusReg ldaxr | - vmOwnerLockAddress = 0 ifTrue: - [cogit - MoveCq: 1 R: ABIResultReg; - RetN: 0. - ^self]. - - "spiffy 8.1 version using CASAL..." - lockValueReg := CArg1Reg. "Holds the value of lock if unlocked (zero), receives the existing value of the lock" - vmOwnerLockAddressReg := CArg2Reg. - self hasAtomicInstructions ifTrue: - [cogit - MoveCq: 0 R: lockValueReg; - MoveCq: vmOwnerLockAddress R: vmOwnerLockAddressReg; - gen: CASAL operand: lockValueReg operand: CArg0Reg operand: vmOwnerLockAddressReg. - br := cogit gen: CBNZ operand: 0 operand: lockValueReg. - cogit - MoveCq: 1 R: ABIResultReg; - RetN: 0. - br jmpTarget: (cogit CmpR: ABIResultReg R: lockValueReg). - cogit - gen: CSET operand: ABIResultReg operand: EQ; "i.e. if NE to 0, then is it already set to the argument?" - RetN: 0. - ^self]. - - "frumpy 8.0 version using LDAXR/STLXR" - cogit MoveCq: vmOwnerLockAddress R: vmOwnerLockAddressReg. - cogit MoveCq: 0 R: (statusReg := CArg3Reg). "STLXR sets a word status register; clearing the top bits means it's a non-issue" - ldaxr := cogit gen: LDAXR operand: lockValueReg operand: vmOwnerLockAddressReg. - br := cogit gen: CBNZ operand: 0 operand: lockValueReg. - cogit gen: STLXR operand: CArg0Reg operand: vmOwnerLockAddressReg operand: statusReg. - cogit gen: CBNZ operand: ldaxr asUnsignedInteger operand: statusReg. - "Since CArg0Reg is never zero, merely returning answers true" - cogit RetN: 0. - br jmpTarget: (cogit gen: CLREX). - cogit CmpR: ABIResultReg R: lockValueReg. - cogit gen: CSET operand: ABIResultReg operand: EQ. "i.e. if NE to 0, then is it already set to the argument?" - cogit RetN: 0. - ^self! Item was removed: - ----- Method: CogARMv8Compiler>>hasAtomicInstructions (in category 'feature detection') ----- - hasAtomicInstructions - <cmacro: '(ign) hasAtomicInstructions'> - "For want of somewhere to put the variable that doesn't bloat an instance of the receiver..." - ^HasAtomicInstructions! Item was removed: - ----- Method: CogARMv8Compiler>>setHasAtomicInstructions: (in category 'feature detection') ----- - setHasAtomicInstructions: boolean - <cmacro: '(ign,b) hasAtomicInstructions = b'> - "For want of somewhere to put the variable that doesn't bloat an instance of the receiver..." - HasAtomicInstructions := boolean! Item was removed: - ----- Method: CogAbstractInstruction>>generateLowLevelTryLock: (in category 'multi-threading') ----- - generateLowLevelTryLock: vmOwnerLockAddress - self subclassResponsibility! Item was removed: - ----- Method: CogIA32Compiler>>generateLowLevelTryLock: (in category 'multi-threading') ----- - generateLowLevelTryLock: vmOwnerLockAddress - "Generate a function that attempts to lock the vmOwnerLock and answers if it succeeded." - <inline: true> - | valueReg | - vmOwnerLockAddress = 0 ifTrue: - [cogit - MoveCq: 1 R: ABIResultReg; - RetN: 0. - ^self]. - valueReg := cogit availableRegisterOrNoneIn: (ABICallerSavedRegisterMask bitClear: 1 << EAX). - cogit - MoveMw: 4 r: ESP R: valueReg; - MoveCq: 0 R: EAX; - gen: LOCK; - gen: CMPXCHGRAw operand: valueReg operand: vmOwnerLockAddress; - gen: SETE operand: ABIResultReg; "a.k.a. EAX" - RetN: 0! Item was removed: - ----- Method: CogVMSimulator>>getMaxWaitingPriority (in category 'multi-threading simulation switch') ----- - getMaxWaitingPriority - "This method includes or excludes CoInterpreterMT methods as required. - Auto-generated by CogVMSimulator>>ensureMultiThreadingOverridesAreUpToDate" - - ^self perform: #getMaxWaitingPriority - withArguments: {} - inSuperclass: (cogThreadManager ifNil: [CoInterpreterPrimitives] ifNotNil: [CoInterpreterMT])! Item was removed: - ----- Method: CogX64Compiler>>generateLowLevelTryLock: (in category 'multi-threading') ----- - generateLowLevelTryLock: vmOwnerLockAddress - "Generate a function that attempts to lock the vmOwnerLock and answers if it succeeded." - <inline: true> - | vmOwnerLockAddressReg jumpEqual | - vmOwnerLockAddress = 0 ifTrue: - [cogit - MoveCq: 1 R: ABIResultReg; - RetN: 0. - ^self]. - "RAX holds the value of lock if unlocked (zero), receives the existing value of the lock; RAX is implicit in CMPXCHG" - vmOwnerLockAddressReg := CArg1Reg. - cogit - MoveCq: 0 R: RAX; - MoveCq: vmOwnerLockAddress R: vmOwnerLockAddressReg; - gen: LOCK; - gen: CMPXCHGRMr operand: CArg0Reg operand: vmOwnerLockAddressReg. - jumpEqual := cogit JumpZero: 0. - cogit CmpR: CArg0Reg R: RAX. "If not equal to zero is it already equal to the desired value?" - jumpEqual jmpTarget: (cogit gen: SETE operand: ABIResultReg). - cogit RetN: 0! Item was removed: - ----- Method: Cogit>>generateVMOwnerLockFunctions (in category 'initialization') ----- - generateVMOwnerLockFunctions - <inline: true> - self cppIf: COGMTVM ifTrue: - [| startAddress | - self allocateOpcodes: backEnd numLowLevelLockOpcodes bytecodes: 0. - self zeroOpcodeIndex. - startAddress := methodZoneBase. - backEnd generateLowLevelTryLock: coInterpreter vmOwnerAddress. - self outputInstructionsForGeneratedRuntimeAt: startAddress. - self recordGeneratedRunTime: 'ceTryLockVMOwner' address: startAddress. - ceTryLockVMOwner := self cCoerceSimple: startAddress to: #'usqIntptr_t (*)(usqIntptr_t)']!

1 0

VM Maker: VMMaker.oscog-LM.3337.mcz
by commits＠source.squeak.org 17 Sep '23

17 Sep '23

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-LM.3337.mcz ==================== Summary ==================== Name: VMMaker.oscog-LM.3337 Author: LM Time: 14 September 2023, 1:56:57.987202 pm UUID: 337b7bcb-90f0-4329-820b-5a53d8a04249 Ancestors: VMMaker.oscog-mt.3336 First mostly stable version of the Threaded FFI. Most important changes are: 1. Use C11 atomic instructions for the vmOwner. This simplifies the CPXCHG instruction and should make this a lot more resistant to breaking due to compiler optimizations. 2. Fix a critical bug when reentering the threadSchedulingLoop Previously this used the wrong jmp_buf, therefore a thread that tried to return to its threadSchedulingLoop might end up in the threadSchedulingLoop of ANOTHER thread! With these two changes in place, the VM runs mostly stable whilst switching between two threads in the spurreader image. There are still some bugs to fix, especially in the scheduler, as well as synchronizing access to the threads variable. But this is good progress for now. =============== Diff against VMMaker.oscog-mt.3336 =============== Item was added: + Object subclass: #AtomicValue + instanceVariableNames: 'value' + classVariableNames: '' + poolDictionaries: '' + category: 'VMMaker-Multithreading'! + + !AtomicValue commentStamp: 'LM 8/26/2023 15:10' prior: 0! + An AtomicValue is a Smalltalk representation of C's atomic value types. + As atomics are always accessed through their address, we must be able to do the same in Smalltalk. + But as addressOf: doesn't create a real "pointer" in Smalltalk, we cannot just use plain values, but must store them in a wrapper object, which can change the internal representation. + + Instance Variables + value: <Object> + + value + - The actual value of the atomic + ! Item was added: + ----- Method: AtomicValue class>>newFrom: (in category 'as yet unclassified') ----- + newFrom: aValue + + ^ self new + value: aValue; + yourself! Item was added: + ----- Method: AtomicValue>>= (in category 'as yet unclassified') ----- + = aValue + + ^ self value = aValue.! Item was added: + ----- Method: AtomicValue>>compare:exchange: (in category 'atomic operations') ----- + compare: expected exchange: desired + self assert: (expected class = AtomicValue). + ^ self value = expected value + ifTrue: [self value: desired. true] + ifFalse: [expected value: self value. false]! Item was added: + ----- Method: AtomicValue>>value (in category 'accessing') ----- + value + + ^ value! Item was added: + ----- Method: AtomicValue>>value: (in category 'accessing') ----- + value: anObject + + value := anObject.! Item was changed: ----- Method: CoInterpreter>>setImageHeaderFlagsFrom: (in category 'image save/restore') ----- setImageHeaderFlagsFrom: headerFlags "Set the flags that are contained in the 7th long of the image header. This is sent at image load time." imageHeaderFlags := headerFlags. "so as to preserve unrecognised flags." fullScreenFlag := headerFlags bitAnd: 1. imageFloatsBigEndian := (headerFlags noMask: 2) ifTrue: [1] ifFalse: [0]. + "processHasThreadAffinity := headerFlags anyMask: 4. specific to CoInterpreterMT" - "processHasThreadId := headerFlags anyMask: 4. specific to CoInterpreterMT" flagInterpretedMethods := headerFlags anyMask: 8. preemptionYields := headerFlags noMask: 16. "noThreadingOfGUIThread := headerFlags anyMask: 32. specific to CoInterpreterMT" newFinalization := headerFlags anyMask: 64. sendWheelEvents := headerFlags anyMask: 128. primitiveDoMixedArithmetic < 0 ifTrue: "i.e. has it not been set on the command line?" [primitiveDoMixedArithmetic := headerFlags noMask: 256]. "N.B. flag mask 512 is responded to by the FilePlugin & FileAttributesPlugin" upscaleDisplayIfHighDPI < 0 ifTrue: "i.e. has it not been set on the command line?" [upscaleDisplayIfHighDPI := headerFlags noMask: 1024]! Item was changed: CoInterpreterPrimitives subclass: #CoInterpreterMT + instanceVariableNames: 'cogThreadManager checkThreadActivation maxWaitingPriority foreignCallbackPriority deferThreadSwitch disowningVMThread disownCount foreignCallbackProcessSlot activeProcessAffined relinquishing processHasThreadAffinity willNotThreadWarnCount' - instanceVariableNames: 'cogThreadManager checkThreadActivation maxWaitingPriority foreignCallbackPriority deferThreadSwitch disowningVMThread disownCount foreignCallbackProcessSlot activeProcessAffined relinquishing reenterThreadSchedulingLoop willNotThreadWarnCount processHasThreadAffinity' classVariableNames: 'DisownFlagsShift DisownVMForProcessorRelinquish OwnVMForeignThreadFlag PerThreadRumpCStackSize PrimNumberRelinquishProcessor ProcessUnaffinedOnDisown ReturnToThreadSchedulingLoop VMAlreadyOwnedHenceDoNotDisown' poolDictionaries: 'VMThreadingConstants' category: 'VMMaker-Multithreading'! Item was changed: ----- Method: CoInterpreterMT class>>declareCVarsIn: (in category 'translation') ----- declareCVarsIn: aCCodeGenerator self class == thisContext methodClass ifFalse: [^self]. "Don't duplicate decls in subclasses" aCCodeGenerator addHeaderFile:'"sqAtomicOps.h"'. "For THRLOG" aCCodeGenerator vmClass declareInterpreterVersionIn: aCCodeGenerator defaultName: 'Cog MT'. aCCodeGenerator + var: #disowningVMThread type: #'CogVMThread *'.! - var: #disowningVMThread type: #'CogVMThread *'. - aCCodeGenerator var: #reenterThreadSchedulingLoop type: 'jmp_buf'.! Item was changed: ----- Method: CoInterpreterMT>>_longjmp:_: (in category 'simulation') ----- _longjmp: aJumpBuf _: returnValue "Hack simulation of _setjmp/_longjmp, intended to invoke the most minimal setjmp/longjmp pair available on the platform; no saving/restoring signal masks, no stack unwinding, etc. Signal the exception that simulates a longjmp back to the interpreter." <doNotGenerate> + self assert: aJumpBuf class == ReenterThreadSchedulingLoop. - self assert: aJumpBuf == reenterThreadSchedulingLoop. aJumpBuf returnValue: returnValue; signal! Item was changed: ----- Method: CoInterpreterMT>>affinedThreadId: (in category 'process primitive support') ----- affinedThreadId: threadIdField "Answer the threadId of the thread threadIdField is temporarily bound to, or 0 if none." ^(objectMemory isIntegerObject: threadIdField) ifTrue: [(objectMemory integerValueOf: threadIdField) anyMask: 1 << ThreadIdShift - 1] ifFalse: [0]! Item was changed: ----- Method: CoInterpreterMT>>disownVM: (in category 'vm scheduling') ----- disownVM: flags "Release the VM to other threads and answer the current thread's index. Currently valid flags: DisownVMForFFICall - informs the VM that it is entering an FFI call DisownVMForThreading - informs the VM that it is entering code during which threading should be permitted OwnVMForeignThreadFlag - indicates lowest-level entry from a foreign thread - not to be used explicitly by clients - only set by ownVMFromUnidentifiedThread VMAlreadyOwnedHenceDoNotDisown - indicates an ownVM from a callback was made when the vm was still owned. - not to be used explicitly by clients - only set by ownVMFromUnidentifiedThread This is the entry-point for plugins and primitives that wish to release the VM while performing some operation that may potentially block, and for callbacks returning back to some blocking operation. If this thread does not reclaim the VM before- hand then when the next heartbeat occurs the thread manager will schedule a thread to acquire the VM which may start running the VM in place of this thread. N.B. Most of the state needed to resume after preemption is set in preemptDisowningThread." <public> <inline: false> | vmThread result | self assert: (flags >= 0 and: [flags < (1 bitShift: DisownFlagsShift)]). self assert: self successful. cogit recordEventTrace ifTrue: [self recordTrace: TraceDisownVM thing: (objectMemory integerObjectOf: flags) source: 0]. processHasThreadAffinity ifFalse: [willNotThreadWarnCount < 10 ifTrue: [self print: 'warning: VM parameter 48 indicates Process doesn''t have threadId; VM will not thread'; cr. willNotThreadWarnCount := willNotThreadWarnCount + 1]]. vmThread := cogThreadManager currentVMThread. (flags anyMask: VMAlreadyOwnedHenceDoNotDisown) ifTrue: [disowningVMThread := vmThread. vmThread state: CTMUnavailable. ^0]. self assertCStackPointersBelongToCurrentThread. self assertValidNewMethodPropertyFlags. self cCode: '' inSmalltalk: [cogThreadManager saveRegisterStateForCurrentProcess. + cogThreadManager clearRegisterStates.]. - cogThreadManager clearRegisterStates]. (flags anyMask: DisownVMForProcessorRelinquish) ifTrue: [| proc | (proc := objectMemory splObj: foreignCallbackProcessSlot) ~= objectMemory nilObject ifTrue: [foreignCallbackPriority := self quickFetchInteger: PriorityIndex ofObject: proc]. relinquishing := true. self sqLowLevelMFence]. disownCount := disownCount + 1. + + "If we're disowning the VM because there's no active process to run, + there's nothing to preempt later, so don't indicate that there's a disowningVMThread that + needs to be restored later." + self activeProcess ~= objectMemory nilObject + ifTrue: [disowningVMThread := vmThread]. - disowningVMThread := vmThread. - "self cr; cr; print: 'disownVM Csp: '; printHex: vmThread cStackPointer; cr. - (0 to: 16 by: 4) do: - [:offset| - self print: ' *(esp+'; printNum: offset; print: ': '; printHex: (stackPages longAt: cogit processor sp + offset); cr]. - cogit processor printIntegerRegistersOn: Transcript." "OwnVMForeignThreadFlag indicates lowest-level of entry by a foreign thread. If that's where we are then release the vmThread. Otherwise indicate the vmThread is off doing something outside of the VM." (flags anyMask: OwnVMForeignThreadFlag) ifTrue: ["I don't think this is quite right. Josh's use case is creating some foreign thread and then registering it with the VM. That's not the same as binding a process to a foreign thread given that the foreign callback process is about to terminate anyway (it is returning from a callback here). So do we need an additional concept, that of a vmThread being either of the set known to the VM or floating?" self flag: 'issue with registering foreign threads with the VM'. (self isBoundProcess: self activeProcess) ifFalse: [cogThreadManager unregisterVMThread: vmThread]] ifFalse: [vmThread state: CTMUnavailable]. + result := ((vmThread index bitShift: DisownFlagsShift) bitOr: (activeProcessAffined ifTrue: [0] ifFalse: [ProcessUnaffinedOnDisown])) bitOr: flags. cogThreadManager releaseVM. ^result! Item was changed: ----- Method: CoInterpreterMT>>initializeInterpreter: (in category 'initialization') ----- initializeInterpreter: bytesToShift super initializeInterpreter: bytesToShift. foreignCallbackProcessSlot := (objectMemory lengthOf: objectMemory specialObjectsOop) > ForeignCallbackProcess ifTrue: [ForeignCallbackProcess] ifFalse: [NilObject]. - self cCode: '' inSmalltalk: - [reenterThreadSchedulingLoop := ReenterThreadSchedulingLoop new]. ! Item was changed: ----- Method: CoInterpreterMT>>ownerIndexOfThreadId: (in category 'process primitive support') ----- ownerIndexOfThreadId: threadId ^(objectMemory isIntegerObject: threadId) + ifTrue: ["We need a signed shift here (>>>), as otherwise we lose the sign of the threadId." + (objectMemory integerValueOf: threadId) >>> ThreadIdShift] - ifTrue: [(objectMemory integerValueOf: threadId) >> ThreadIdShift] ifFalse: [0]! Item was changed: ----- Method: CoInterpreterMT>>returnToSchedulingLoopAndReleaseVMOrWakeThread:source: (in category 'process primitive support') ----- returnToSchedulingLoopAndReleaseVMOrWakeThread: vmThread source: source <var: #vmThread type: #'CogVMThread *'> <inline: false> + | activeThread | + activeThread := cogThreadManager currentVMThread. self recordThreadSwitchTo: (vmThread ifNotNil: [vmThread index] ifNil: [0]) source: source. vmThread ifNotNil: [cogThreadManager wakeVMThreadFor: vmThread index] ifNil: [cogit disownVM: DisownVMForThreading]. "I am not frightened of flying. Any value will do. I don't mind. Why should I be frightened of flying? There's no reason for it." + self _longjmp: activeThread reenterThreadSchedulingLoop _: 1 ! - self _longjmp: reenterThreadSchedulingLoop _: 1 ! Item was changed: ----- Method: CoInterpreterMT>>threadSchedulingLoop: (in category 'vm scheduling') ----- threadSchedulingLoop: vmThread "Enter a loop attempting to run the VM with the highest priority process and blocking on the thread's OS semaphore when unable to run that process. This version is for simulation only, simulating the longjmp back to the real threadSchedulingLoopImplementation: through exception handling." <cmacro: '(vmThread) threadSchedulingLoopImplementation(vmThread)'> [[self threadSchedulingLoopImplementation: vmThread] on: ReenterThreadSchedulingLoop + do: [:reentry| + self assert: reentry returnValue = 1. + reentry reset. + reentry return: true]] whileTrue! - do: [:ex| - self assert: ex returnValue = 1. - reenterThreadSchedulingLoop reset. - ex return: true]] whileTrue! Item was changed: ----- Method: CoInterpreterMT>>threadSchedulingLoopImplementation: (in category 'vm scheduling') ----- threadSchedulingLoopImplementation: vmThread "Enter a loop attempting to run the VM with the highest priority process and blocking on the thread's OS semaphore when unable to run that process. We will return to this via threadSwitchIfNecessary:from: which is called in the middle of transferTo:from: once the active process has been stored in the scheduler." <var: #vmThread type: #'CogVMThread *'> <inline: false> + self _setjmp: vmThread reenterThreadSchedulingLoop. - self _setjmp: reenterThreadSchedulingLoop. [self assert: vmThread state = CTMAssignableOrInVM. + (cogThreadManager tryLockVMOwnerTo: vmThread index) + ifTrue: + ["Yay, we're the VM owner!!" + "If relinquishing is true, then primitiveRelinquishProcessor has disowned the + VM and only a returning call or callback should take ownership in that case." + relinquishing ifFalse: [self tryToExecuteSmalltalk: vmThread]. + self disownVM: DisownVMForThreading.]. + cogThreadManager waitForWork: vmThread. + true] whileTrue! - (cogThreadManager tryLockVMOwnerTo: vmThread index) ifTrue: - ["If relinquishing is true, then primitiveRelinquishProcessor has disowned the - VM and only a returning call or callback should take ownership in that case." - relinquishing - ifTrue: [cogThreadManager disownVM: DisownVMForThreading] - ifFalse: [self tryToExecuteSmalltalk: vmThread]]. - (cogThreadManager vmOwnerIs: vmThread index) ifFalse: - [cogThreadManager waitForWork: vmThread]. - true] whileTrue! Item was changed: ----- Method: CoInterpreterMT>>threadSwitchIfNecessary:from: (in category 'process primitive support') ----- threadSwitchIfNecessary: newProc from: sourceCode "Invoked from transferTo:from: or primitiveProcessBindToThreadId to switch threads if the new process is bound or affined to some other thread." | newProcOwnerIndex vmThread activeContext | self assert: (cogThreadManager vmOwnerIs: cogThreadManager ioGetThreadLocalThreadIndex). deferThreadSwitch ifTrue: [^self]. cogThreadManager assertValidProcessorStackPointersForIndex: cogThreadManager getVMOwner. "If the current process is unaffined or it is affined to the current thread we're ok to run, but we should yield asap if a higher-priority thread wants the VM." newProcOwnerIndex := self ownerIndexOfProcess: newProc. ((activeProcessAffined := newProcOwnerIndex ~= 0) and: [(cogThreadManager vmOwnerIsCompatibleWith: newProcOwnerIndex) not]) ifFalse: [(self quickFetchInteger: PriorityIndex ofObject: newProc) < maxWaitingPriority ifTrue: [checkThreadActivation := true. self forceInterruptCheck]. ^self]. "The current process is affined to a thread, but not to the current owner. So switch to that owner." self cCode: '' inSmalltalk: [transcript ensureCr; f: 'threadSwitchIfNecessary: %08x from: %s(%d) owner %d -> %d\n' printf: { newProc. TraceSources at: sourceCode. sourceCode. cogThreadManager getVMOwner. newProcOwnerIndex }]. "We at least need to externalize the stack pointers to enable a thread switch..." (objectMemory fetchPointer: SuspendedContextIndex ofObject: newProc) = objectMemory nilObject ifTrue: [self assert: newProc = self activeProcess. self push: instructionPointer. self externalWriteBackHeadFramePointers. false ifTrue: "If the activeProcess doesn't have a context yet, it needs one from which the new thread can resume execution." [activeContext := self ensureFrameIsMarried: framePointer SP: stackPointer. objectMemory storePointer: SuspendedContextIndex ofObject: newProc withValue: activeContext]]. newProcOwnerIndex < 0 ifTrue: [self assert: newProcOwnerIndex negated = cogThreadManager getVMOwner. vmThread := cogThreadManager ensureWillingThread. self deny: vmThread index = cogThreadManager getVMOwner. self assert: (cogThreadManager threadIndex: vmThread index isCompatibleWith: newProcOwnerIndex)] ifFalse: [vmThread := cogThreadManager vmThreadAt: newProcOwnerIndex. vmThread priority: (self quickFetchInteger: PriorityIndex ofObject: newProc). vmThread state = CTMUnavailable ifTrue: [vmThread state: CTMWantingOwnership]]. self returnToSchedulingLoopAndReleaseVMOrWakeThread: vmThread source: CSSwitchIfNeccessary! Item was changed: ----- Method: CoInterpreterMT>>transferTo:from: (in category 'process primitive support') ----- transferTo: newProc from: sourceCode "Record a process to be awoken on the next interpreter cycle. Override to potentially switch threads either if the new process is bound to another thread, or if there is no runnable process but there is a waiting thread. Note that the abort on no runnable process has beeen moved here from wakeHighestPriority." | sched oldProc activeContext | <inline: false> statProcessSwitch := statProcessSwitch + 1. self push: instructionPointer. self externalWriteBackHeadFramePointers. self assertValidExecutionPointe: instructionPointer r: framePointer s: stackPointer. "ensureMethodIsCogged: in makeBaseFrameFor: in externalSetStackPageAndPointersForSuspendedContextOfProcess: below may do a code compaction. Nil instructionPointer to avoid it getting pushed twice." instructionPointer := 0. sched := self schedulerPointer. oldProc := objectMemory fetchPointer: ActiveProcessIndex ofObject: sched. self recordContextSwitchFrom: oldProc in: sourceCode. activeContext := self ensureFrameIsMarried: framePointer SP: stackPointer + objectMemory wordSize. objectMemory storePointer: SuspendedContextIndex ofObject: oldProc withValue: activeContext. newProc ifNil: ["Two possibilities. One, there is at least one thread waiting to own the VM in which case it should be activated. Two, there are no processes to run and so abort." + cogThreadManager willingVMThread ifNotNil: - self willingVMThread ifNotNil: [:vmThread| vmThread state = CTMWantingOwnership ifTrue: [self returnToSchedulingLoopAndReleaseVMOrWakeThread: vmThread source: sourceCode]]. self error: 'scheduler could not find a runnable process']. "Switch to the new process" objectMemory storePointer: ActiveProcessIndex ofObject: sched withValue: newProc; storePointerUnchecked: MyListIndex ofObject: newProc withValue: objectMemory nilObject. self externalSetStackPageAndPointersForSuspendedContextOfProcess: newProc. "Finally thread switch if required" self threadSwitchIfNecessary: newProc from: sourceCode! Item was changed: ----- Method: CoInterpreterMT>>tryToExecuteSmalltalk: (in category 'vm scheduling') ----- tryToExecuteSmalltalk: vmThread "Attempt to run the current process, if it exists, on the given vmThread." <var: #vmThread type: #'CogVMThread *'> | dvmt activeProc ownerIndex | <var: #dvmt type: #'CogVMThread *'> self assert: (cogThreadManager vmOwnerIs: vmThread index). self assert: cogThreadManager ioGetThreadLocalThreadIndex = vmThread index. dvmt := disowningVMThread. disowningVMThread ifNil: [activeProc := self activeProcess] ifNotNil: [self preemptDisowningThread. activeProc := self wakeHighestPriority. activeProc ifNil: [activeProc := objectMemory nilObject] ifNotNil: [objectMemory storePointerUnchecked: MyListIndex ofObject: activeProc withValue: objectMemory nilObject]. objectMemory storePointer: ActiveProcessIndex ofObject: self schedulerPointer withValue: activeProc]. + + activeProc = objectMemory nilObject ifTrue:[^nil]. + - activeProc = objectMemory nilObject ifTrue: - [cogThreadManager disownVM: DisownVMForThreading. - ^nil]. ownerIndex := self ownerIndexOfProcess: activeProc. (ownerIndex = 0 or: [cogThreadManager vmOwnerIsCompatibleWith: ownerIndex]) ifTrue: [self assert: (objectMemory fetchPointer: MyListIndex ofObject: self activeProcess) = objectMemory nilObject. (objectMemory fetchPointer: SuspendedContextIndex ofObject: activeProc) ~= objectMemory nilObject ifTrue: [self externalSetStackPageAndPointersForSuspendedContextOfProcess: activeProc]. instructionPointer = cogit ceReturnToInterpreterPC ifTrue: [self deny: (self isMachineCodeFrame: framePointer). instructionPointer := self iframeSavedIP: framePointer]. self enterSmalltalkExecutive. "When we return here we should have already given up the VM and so we cannot touch any interpreter state." "NOTREACHED"]. cogThreadManager wakeVMThreadFor: ownerIndex! Item was changed: CogAbstractInstruction subclass: #CogARMv8Compiler instanceVariableNames: '' + classVariableNames: 'AL ArithmeticAdd ArithmeticAddS ArithmeticSub ArithmeticSubS CASAL CArg0Reg CArg1Reg CArg2Reg CArg3Reg CArg4Reg CArg5Reg CArg6Reg CBNZ CBZ CC CCMPNE CLREX CS CSET D0 D1 D10 D11 D12 D13 D14 D15 D16 D17 D18 D19 D2 D20 D21 D22 D23 D24 D25 D26 D27 D28 D29 D3 D30 D31 D4 D5 D6 D7 D8 D9 DC DC_CISW DC_CIVAC DC_CSW DC_CVAC DC_CVAU DC_ISW DC_IVAC DC_ZVA DMB DSB DSB_ALL DSB_ALLSY DSB_ISH DSB_NSH DSB_OSH DSB_READS DSB_SY DSB_WRITES DivRRR EQ FP GE GT HI IC IC_IALLU IC_IALLUIS IC_IVAU ISB LDAXR LE LR LS LT LogicalAnd LogicalAndS LogicalOr LogicalXor MI MRS_CTR_EL0 MRS_ID_AA64ISAR0_EL1 MSubRRR MoveAwRR MoveRRAw MulOverflowRRR MulRRR NE NativePopRR NativePushRR PJWPNChange PJWPNClear PJWPNSet PJWPNState PL R0 R1 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R2 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R3 R30 R31 R4 R5 R6 R7 R8 R9 SMULHRRR SP STLR STLXR SXTB SXTH SXTW SXTX UXTB UXTH UXTW UXTX VC VS XZR' - classVariableNames: 'AL ArithmeticAdd ArithmeticAddS ArithmeticSub ArithmeticSubS CASAL CArg0Reg CArg1Reg CArg2Reg CArg3Reg CArg4Reg CArg5Reg CArg6Reg CBNZ CBZ CC CCMPNE CLREX CS CSET D0 D1 D10 D11 D12 D13 D14 D15 D16 D17 D18 D19 D2 D20 D21 D22 D23 D24 D25 D26 D27 D28 D29 D3 D30 D31 D4 D5 D6 D7 D8 D9 DC DC_CISW DC_CIVAC DC_CSW DC_CVAC DC_CVAU DC_ISW DC_IVAC DC_ZVA DMB DSB DSB_ALL DSB_ALLSY DSB_ISH DSB_NSH DSB_OSH DSB_READS DSB_SY DSB_WRITES DataCacheFlushRequired DataCacheLineLength DivRRR EQ FP GE GT HI HasAtomicInstructions IC IC_IALLU IC_IALLUIS IC_IVAU ISB InstructionCacheFlushRequired InstructionCacheLineLength LDAXR LE LR LS LT LogicalAnd LogicalAndS LogicalOr LogicalXor MI MRS_CTR_EL0 MRS_ID_AA64ISAR0_EL1 MSubRRR MoveAwRR MoveRRAw MulOverflowRRR MulRRR NE NativePopRR NativePushRR PJWPNChange PJWPNClear PJWPNSet PJWPNState PL R0 R1 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R2 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R3 R30 R31 R4 R5 R6 R7 R8 R9 SMULHRRR SP STLR STLXR SXTB SXTH SXTW SXTX UXTB UXTH UXTW UXTX VC VS XZR' poolDictionaries: 'ARMv8A64Opcodes' category: 'VMMaker-JIT'! !CogARMv8Compiler commentStamp: 'eem 1/7/2021 23:01' prior: 0! I generate ARMv8 machine code instructions from CogAbstractInstructions with CogRTLOpcodes. Here in "Arm ARM" refers to Arm® Architecture Reference Manual Armv8, for Armv8-A architecture profile https://developer.arm.com/docs/ddi0487/latest/arm-architecture-reference-ma… Some things to know about ARMv8 instructions: Whether 31 in a register field implies the zero register or the SP register(s) depends on the specific instruction. C3.2.1 Load/Store register If a Load instruction specifies writeback and the register being loaded is also the base register, then behavior is CONSTRAINED UNPREDICTABLE and one of the following behaviors must occur: - The instruction is treated as UNDEFINED. - The instruction is treated as a NOP. - The instruction performs the load using the specified addressing mode and the base register becomes UNKNOWN. In addition, if an exception occurs during the execution of such an instruction, the base address might be corrupted so that the instruction cannot be repeated. If a Store instruction performs a writeback and the register that is stored is also the base register, then behavior is CONSTRAINED UNPREDICTABLE and one of the following behaviors must occur: - The instruction is treated as UNDEFINED. - The instruction is treated as a NOP. - The instruction performs the store to the designated register using the specified addressing mode, but the value stored is UNKNOWN.! Item was changed: ----- Method: CogSistaMethodSurrogate32>>counters: (in category 'accessing generated') ----- counters: aValue | index delta | index := address + 20 + baseHeaderSize. (delta := cogit getCodeToDataDelta) > 0 ifTrue: [self assert: (cogit addressIsInCodeZone: address - delta). objectMemory long32At: index - delta + put: aValue]. - put: ((aValue ifNotNil: [aValue asUnsignedInteger] ifNil: [0]))]. ^objectMemory long32At: index + put: aValue! - put: ((aValue ifNotNil: [aValue asUnsignedInteger] ifNil: [0]))! Item was changed: ----- Method: CogSistaMethodSurrogate64>>counters: (in category 'accessing generated') ----- counters: aValue | index delta | index := address + 32 + baseHeaderSize. (delta := cogit getCodeToDataDelta) > 0 ifTrue: [self assert: (cogit addressIsInCodeZone: address - delta). objectMemory long64At: index - delta + put: aValue]. - put: ((aValue ifNotNil: [aValue asUnsignedInteger] ifNil: [0]))]. ^objectMemory long64At: index + put: aValue! - put: ((aValue ifNotNil: [aValue asUnsignedInteger] ifNil: [0]))! Item was changed: ----- Method: CogThreadManager class>>declareCVarsIn: (in category 'translation') ----- declareCVarsIn: cCodeGen cCodeGen removeVariable: 'coInterpreter'; removeVariable: 'cogit'; removeVariable: 'threadLocalStorage'; removeVariable: 'processorOwner'; removeVariable: 'registerStates'. cCodeGen var: #threads type: #'CogVMThread **'; + var: #vmOSThread type: #sqOSThread; + var: #vmOwner type: #'volatile atomic_int'. + cCodeGen addHeaderFile: '<stdatomic.h>'! - var: #vmOSThread type: #sqOSThread! Item was changed: ----- Method: CogThreadManager>>acquireVMFor: (in category 'public api') ----- acquireVMFor: threadIndex "Attempt to acquire the VM, eventually blocking until it becomes available. Spin until the maxWaitingPriority has been updated if it is lower than this thread's priority." <returnTypeC: #'CogVMThread *'> | vmThread | <var: #vmThread type: #'CogVMThread *'> self assert: threadIndex = self ioGetThreadLocalThreadIndex. vmThread := self vmThreadAt: threadIndex. self assert: (vmThread state = CTMUnavailable or: [vmThread state = CTMWantingOwnership]). + (self tryLockVMOwnerTo: threadIndex) + ifTrue: [vmThread state: CTMAssignableOrInVM] + ifFalse: + [vmThread state: CTMWantingOwnership. + [(self vmOwnerIs: threadIndex) + or: [self tryLockVMOwnerTo: threadIndex]] whileFalse: + [vmThread priority ifNotNil: + [coInterpreter waitingPriorityIsAtLeast: vmThread priority]. + (self vmOwnerIs: threadIndex) ifFalse: + [self ioWaitOnOSSemaphore: (self addressOf: vmThread osSemaphore)]]]. - (self tryLockVMOwnerTo: threadIndex) ifFalse: - [vmThread state: CTMWantingOwnership. - [(self vmOwnerIs: threadIndex) - or: [self tryLockVMOwnerTo: threadIndex]] whileFalse: - [vmThread priority ifNotNil: - [coInterpreter waitingPriorityIsAtLeast: vmThread priority]. - (self vmOwnerIs: threadIndex) ifFalse: - [self ioWaitOnOSSemaphore: (self addressOf: vmThread osSemaphore)]]]. coInterpreter assertProcessorStackPointersBelongToCurrentThread. vmOSThread := vmThread osThread. vmThread state: CTMAssignableOrInVM. ^vmThread! Item was added: + ----- Method: CogThreadManager>>doTryLockVMOwnerTo: (in category 'simulation') ----- + doTryLockVMOwnerTo: threadIndex + "In the simulation, this is being called by #simulateTryLockVMOwnerTo:, in C this method will just be called directly. + Returns true if the vmOwner has been successfully set to the given thread index." + <inline: #always> + <var: #expected type: #int> + | expected | + expected := self cCode: 0 inSmalltalk: [AtomicValue newFrom: 0]. + ^ (self atomic: (self addressOf: vmOwner) + _compare: (self addressOf: expected) + _exchange_strong: threadIndex) + or: ["We may already be vmOwner. The current vmOwner will be stored in expected" expected = threadIndex]! Item was changed: ----- Method: CogThreadManager>>ensureRunningVMThread: (in category 'public api') ----- ensureRunningVMThread: vmIsRelinquishing "Called from checkVMOwnershipFromHeartbeat if the VM is unowned. Hence we are in the heartbeat thread. The race is against that thread owning the VM and against foreign callbacks." <returnTypeC: #void> <var: #vmThread type: #'CogVMThread *'> self willingVMThread ifNotNil: [:vmThread| "If the VM is relinquishing the processor then only schedule a thread if it has work to do." (vmIsRelinquishing and: [vmThread state ~= CTMWantingOwnership]) ifTrue: [^self]. + self assert: ((vmThread state = CTMAssignableOrInVM + or: [vmThread state = CTMInitializing]) + or: [vmThread state = CTMWantingOwnership]). (self tryLockVMOwnerTo: vmThread index) ifFalse: "someone beat us to it..." [^self]. vmOSThread := vmThread osThread. "release the thread from its blocking loop" self ioSignalOSSemaphore: (self addressOf: vmThread osSemaphore). self ioTransferTimeslice. "self cCode: [coInterpreter print: 'ERVT signalled '; printNum: vmThread index; cr]." ^self]. "If the VM is relinquishing the processor then only schedule a thread if it has work to do (willingVMThread not nil above). If we have failed to allocate thread storage before there is no point continuing to try to do so. By this time we should have quite a few threads in the pool." (vmIsRelinquishing or: [memoryIsScarce]) ifTrue: [^self]. self unusedThreadInfo ifNotNil: [:vmThread| (self tryLockVMOwnerTo: vmThread index) ifTrue: [(self startThreadForThreadInfo: vmThread) ifFalse: [self releaseVM]]]! Item was changed: ----- Method: CogThreadManager>>getVMOwner (in category 'public api') ----- getVMOwner + <inline: true> + ^self atomic_load: (self addressOf: vmOwner)! - self sqLowLevelMFence. - ^vmOwner! Item was changed: ----- Method: CogThreadManager>>growThreadInfosToAtLeast: (in category 'thread set') ----- growThreadInfosToAtLeast: index "Grow the thread infos to at least index in numThreadsIncrement quanta." | newThreads newNumThreads | <var: #newThreads type: #'CogVMThread **'> <inline: false> memoryIsScarce ifTrue: [^false]. newNumThreads := index + numThreadsIncrement - 1 // numThreadsIncrement * numThreadsIncrement. newNumThreads >= self maxNumThreads ifTrue: [^false]. "Since 0 is not a valid index we allocate one extra CogVMThread and use 1-relative indices." newThreads := self cCode: 'realloc(GIV(threads), (newNumThreads + 1) * sizeof(CogVMThread *))' inSmalltalk: [(Array new: newNumThreads) replaceFrom: 1 to: numThreads with: threads startingAt: 1]. (newThreads notNil and: [self populate: newThreads from: numThreads + 1 to: newNumThreads]) ifFalse: + [ + "TODO: This cannot free 'newThreads', as that's going to mean 'threads' is freed as well." + self abort. + self free: newThreads. - [self free: newThreads. memoryIsScarce := true. ^false]. threads := newThreads. numThreads := newNumThreads. ^true! Item was changed: ----- Method: CogThreadManager>>initialize (in category 'initialize-release') ----- initialize + numThreads := numThreadsIncrement := 0. + self cCode: [self atomic_store: (self addressOf: vmOwner) _: 0] + inSmalltalk: [vmOwner := AtomicValue newFrom: 0]. - vmOwner := numThreads := numThreadsIncrement := 0. memoryIsScarce := false. "N.B. Do not initialize threadLocalStorage; leave this to ioInitThreadLocalThreadIndices". registerStates := IdentityDictionary new! Item was changed: ----- Method: CogThreadManager>>loadOrInitializeRegisterStateFor: (in category 'simulation') ----- loadOrInitializeRegisterStateFor: threadIndex <doNotGenerate> + |fakeThreadIndex processor| + "The heartbeat thread will lock the VM to -1, so generate a fake processor data for this." + fakeThreadIndex := threadIndex == -1 ifTrue: [self maxNumThreads] ifFalse: [threadIndex]. - |processor| processor := cogit processor. processor setRegisterState: (registerStates at: threadIndex ifAbsentPut: + [self initializeProcessor: processor forThreadIndex: fakeThreadIndex. - [self initializeProcessor: processor forThreadIndex: threadIndex. processor registerState]).! Item was changed: ----- Method: CogThreadManager>>populate:from:to: (in category 'thread set') ----- populate: vmThreadPointers from: start to: finish "Populate vmThreadPointers with vmThreads over the given range." <var: #vmThreadPointers type: #'CogVMThread **'> | nThreads vmThreads | <var: #vmThreads type: #'CogVMThread *'> <var: #vmThread type: #'CogVMThread *'> <inline: true> nThreads := finish - start + 1. vmThreads := self cCode: [self calloc: nThreads _: (self sizeof: CogVMThread)] inSmalltalk: [CArrayAccessor on: ((1 to: nThreads) collect: [:ign| CogVMThread new])]. vmThreads ifNil: [^false]. "Since 0 is not a valid index, in C we allocate one extra CogVMThread and use 1-relative indices." self cCode: [start = 1 ifTrue: [vmThreadPointers at: 0 put: nil]] inSmalltalk: []. start to: finish do: [:i| | vmThread | vmThread := self addressOf: (vmThreads at: i - start). (self ioNewOSSemaphore: (self addressOf: vmThread osSemaphore put: [:sem| vmThread osSemaphore: sem])) ~= 0 ifTrue: [start to: i - 1 do: [:j| vmThread := self addressOf: (vmThreads at: j - start). self ioDestroyOSSemaphore: (self addressOf: vmThread osSemaphore)]. self free: vmThreads. ^false]. vmThreadPointers at: i put: vmThread. vmThread awolProcLength: AWOLProcessesIncrement. + vmThread index: i. + self cCode: [] inSmalltalk: [vmThread reenterThreadSchedulingLoop: ReenterThreadSchedulingLoop new]]. - vmThread index: i]. ^true! Item was changed: ----- Method: CogThreadManager>>releaseVM (in category 'public api') ----- releaseVM <inline: #always> self setVMOwner: 0! Item was changed: ----- Method: CogThreadManager>>setVMOwner: (in category 'public api') ----- setVMOwner: indexOrZero "An ugly accessor used in only three cases: 1. by ownVMFromUnidentifiedThread when the VM is first locked to the thread id of the unidentified thread, and then, once identified, to the thread's index. 2. by wakeVMThreadFor: used by the two-level scheduler to switch threads when a Smalltalk process switch occurs to a process affined to another thread. 3. to release the VM (set the owner to zero)" <inline: #always> + self assert: (self getVMOwner ~= 0 and: [self getVMOwner ~= indexOrZero]). - self assert: (vmOwner ~= 0 and: [vmOwner ~= indexOrZero]). self cCode: '' inSmalltalk: [coInterpreter transcript ensureCr; f: 'setVMOwner: %d -> %d (%s)\n' + printf: { self getVMOwner. indexOrZero. thisContext home sender selector }]. - printf: { vmOwner. indexOrZero. thisContext home sender selector }]. + "TODO: We could make this a `release` ordering, which may perform better on ARM." + self atomic_store: (self addressOf: vmOwner) _: indexOrZero! - "With the assignment followed by a LowLevelMFence this is equivalent to a - Fetch-Assign with an C++ Memory ordering of Squentially-Consistent. - TODO: We could make this a `release` ordering, which may perform better on ARM." - vmOwner := indexOrZero. - self sqLowLevelMFence! Item was added: + ----- Method: CogThreadManager>>simulateTryLockVMOwnerTo: (in category 'simulation') ----- + simulateTryLockVMOwnerTo: threadIndex + "In the real VM this is a direct call of #tryLockVMOwnerTo:. + In the simulation this is where register state is restored, simulating a thread switch. + State is stored in saveRegisterStateForCurrentProcess (sent by disownVM:, ioWaitOnOSSemaphore: + and ioTransferTimeslice). The code here and in saveRegisterStateForCurrentProcess allow us to + avoid the expensive and complex MultiProcessor hack. + + The idea here is to save the register state around the invocation of tryLockVMOwnerTo:, and set + the register state to that for the owner, changing the state if ownership has changed, restoring + it if ownership has not changed." + <doNotGenerate> + self deny: threadIndex = 0. + ^cogit withProcessorHaltedDo: + [| previousOwner currentOwner processor result | + processor := cogit processor. + "After switching, the 'current' owner will be the 'previous' owner. + Though the value will be the same, let's still introduce a second variable that we + can use after the switch to make it more clear what's going on." + previousOwner := currentOwner := self getVMOwner. + + "If we currently have a VM owner, the register state should be + valid for that owner, otherwise it should be empty." + currentOwner ~= 0 + ifTrue: [self assertValidStackPointersInState: processor registerState forIndex: currentOwner] + ifFalse: [self assertEmptyRegisterStates: processor registerState]. + + result := self doTryLockVMOwnerTo: threadIndex. + self assert: result = (threadIndex = self getVMOwner). + + result + ifTrue: ["If we did actually change owners, assert that previously the processor was emtpy." + previousOwner ~= self getVMOwner + ifTrue: [self assertEmptyRegisterStates: processor registerState. + self loadOrInitializeRegisterStateFor: threadIndex]]. + + coInterpreter transcript + ensureCr; + f: (result ifTrue: ['tryLockVMOwner %d -> %d (%s) ok\n'] ifFalse: ['tryLockVMOwner %d -> %d (%s) FAILED\n']) + printf: { previousOwner. threadIndex. thisContext home sender selector }. + self assertValidProcessorStackPointersForIndex: self getVMOwner. + result]! Item was changed: ----- Method: CogThreadManager>>startThreadForThreadInfo: (in category 'scheduling') ----- startThreadForThreadInfo: vmThread <var: #vmThread type: #'CogVMThread *'> <inline: false> self assert: vmThread state isNil. vmThread state: CTMInitializing. "self cCode: '' inSmalltalk: [coInterpreter transcript cr; nextPutAll: 'starting VM thread '; print: vmThread index; flush. (thisContext home stackOfSize: 10) do: [:ctxt| coInterpreter transcript cr; print: ctxt; flush]]." + (self ioNewOS: (self cCoerce: #startVMThread: to: 'void (*)(void*)') Thread: vmThread) = 0 ifTrue: - (self ioNewOS: #startVMThread: Thread: vmThread) = 0 ifTrue: [self ioTransferTimeslice. ^true]. memoryIsScarce := true. "self cCode: [coInterpreter print: 'ERVT failed to spawn so memory is scarce'; cr]" ^false! Item was changed: ----- Method: CogThreadManager>>startThreadSubsystem (in category 'public api') ----- startThreadSubsystem "Initialize the threading subsystem, aborting if there is an error." | vmThread | <inline: false> self assert: threads = nil. vmOSThread := self ioCurrentOSThread. numThreadsIncrement := (self ioNumProcessors max: 2) min: 16. (self growThreadInfosToAtLeast: numThreadsIncrement * 2) ifFalse: [self error: 'no memory to start thread system']. + self atomic_store: (self addressOf: vmOwner) _: 1. + vmThread := threads at: self getVMOwner. - vmThread := threads at: (vmOwner := 1). vmThread state: CTMInitializing. self registerVMThread: vmThread. vmThread state: CTMAssignableOrInVM! Item was changed: ----- Method: CogThreadManager>>tryLockVMOwnerTo: (in category 'simulation') ----- tryLockVMOwnerTo: threadIndex + <api> - "In the real VM this is a direct call of Cogit>>#tryLockVMOwnerTo:/ceTryLockVMOwner. - In the simulation this is where register state is restored, simulating a thread switch. - State is stored in saveRegisterStateForCurrentProcess (sent by disownVM:, ioWaitOnOSSemaphore: - and ioTransferTimeslice). The code here and in saveRegisterStateForCurrentProcess allow us to - avoid the expensive and complex MultiProcessor hack. - - The idea here is to save the register state around the invocation of tryLockVMOwnerTo:, and set - the register state to that for the owner, changing the state if ownership has changed, restoring - it if ownership has not changed." - <doNotGenerate> self deny: threadIndex = 0. + + ^ self cCode: [self doTryLockVMOwnerTo: threadIndex] + inSmalltalk: [self simulateTryLockVMOwnerTo: threadIndex]! - ^cogit withProcessorHaltedDo: - [| previousOwner currentOwner processor result priorState | - processor := cogit processor. - "After switching, the 'current' owner will be the 'previous' owner. - Though the value will be the same, let's still introduce a second variable that we - can use after the switch to make it more clear what's going on." - previousOwner := currentOwner := vmOwner. - - priorState := processor registerState. - "If we currently have a VM owner, the register state should be - valid for that owner, otherwise it should be empty." - vmOwner ~= 0 - ifTrue: [self assertValidStackPointersInState: priorState forIndex: vmOwner] - ifFalse: [self assertEmptyRegisterStates: priorState]. - - vmOwner ~= threadIndex ifTrue: - ["There can be two cases here: - 1. There's currently a VM owner, and the processor has a non-empty state. - 2. There is currently no VM owner and the processor has an empty state. - In both cases, we need to restore our own register state into the processor, - as cogit>>#tryLockVMOwnerTo: call will use the processor, so the processor - cannot be empty and we also don't want the processor modify the current - owners state." - self loadOrInitializeRegisterStateFor: threadIndex]. - - result := cogit tryLockVMOwnerTo: threadIndex. - self assert: result = (threadIndex = vmOwner). - - result - ifTrue: ["If we did actually change owners, assert that previously the processor was emtpy." - previousOwner ~= vmOwner ifTrue: [self assertEmptyRegisterStates: priorState]] - ifFalse: [processor setRegisterState: priorState.]. - - coInterpreter transcript - ensureCr; - f: (result ifTrue: ['tryLockVMOwner %d -> %d (%s) ok\n'] ifFalse: ['tryLockVMOwner %d -> %d (%s) FAILED\n']) - printf: { previousOwner. threadIndex. thisContext home sender selector }. - self assertValidProcessorStackPointersForIndex: vmOwner. - result]! Item was changed: ----- Method: CogThreadManager>>vmIsOwned (in category 'public api-testing') ----- vmIsOwned "Answer if the vm is owned" <inline: true> + ^ self getVMOwner ~= 0! - self sqLowLevelMFence. - ^vmOwner > 0! Item was changed: ----- Method: CogThreadManager>>vmOwnerAddress (in category 'Cogit lock implementation') ----- vmOwnerAddress <api> "NB. For the JIT only, so it can generate the lock & unlock functions." <returnTypeC: #usqInt> + self error: 'Deprecated!! Replaced by proper atomic functions'. ^self cCode: [(self addressOf: vmOwner) asUnsignedInteger] inSmalltalk: [cogit simulatedReadWriteVariableAddress: #vmOwnerFromMachineCode in: self]! Item was changed: ----- Method: CogThreadManager>>vmOwnerFromMachineCode (in category 'Cogit lock implementation') ----- vmOwnerFromMachineCode <doNotGenerate> + self error: 'Deprecated!! Replaced by proper atomic C functions'. ^vmOwner! Item was changed: ----- Method: CogThreadManager>>vmOwnerFromMachineCode: (in category 'Cogit lock implementation') ----- vmOwnerFromMachineCode: aValue <doNotGenerate> + self error: 'Deprecated!! Replaced by proper atomic C functions'. self assert: (aValue between: 0 and: numThreads). vmOwner := aValue! Item was changed: ----- Method: CogThreadManager>>vmOwnerIs: (in category 'public api-testing') ----- vmOwnerIs: index "Test if the vmOwner is index." <inline: true> + ^self getVMOwner = index! - self sqLowLevelMFence. - ^vmOwner = index! Item was changed: ----- Method: CogThreadManager>>vmOwnerIsCompatibleWith: (in category 'public api-testing') ----- vmOwnerIsCompatibleWith: processThreadId "Test if the vmOwner is index." <inline: true> + ^self threadIndex: self getVMOwner isCompatibleWith: processThreadId! - self sqLowLevelMFence. - ^self threadIndex: vmOwner isCompatibleWith: processThreadId! Item was changed: ----- Method: CogThreadManager>>waitForWork: (in category 'public api') ----- waitForWork: vmThread "Wait for work." <var: #vmThread type: #'CogVMThread *'> <returnTypeC: #void> + vmThread state: CTMAssignableOrInVM. - self assert: vmThread state = CTMAssignableOrInVM. self deny: (self vmOwnerIs: vmThread index). self ioWaitOnOSSemaphore: (self addressOf: vmThread osSemaphore)! Item was changed: ----- Method: CogThreadManager>>wakeVMThreadFor: (in category 'public api') ----- wakeVMThreadFor: index "Transfer the VM to the thread with index. Called from a thread that finds the highest priority runnable process is bound to the thread with index index." <returnTypeC: #void> | vmThread | self assert: (self vmIsOwned and: [(self vmOwnerIs: index) not]). self assert: (index between: 1 and: numThreads). vmThread := threads at: index. "Instead of going through a #disownVM: call, directly set the new VM owner. This has the advantage of avoiding a race for the different threads to become the new VM owner. In Simulation, this means we need to simulate a thread-switch." + self cCode: [] inSmalltalk: [ + self saveRegisterStateForCurrentProcess. - self cCode: [] inSmalltalk: - [self saveRegisterStateForCurrentProcess. self loadOrInitializeRegisterStateFor: index]. self setVMOwner: index. vmThread state ifNil: [self startThreadForThreadInfo: vmThread] ifNotNil: + [self assert: ((vmThread state = CTMWantingOwnership + or: [vmThread state = CTMAssignableOrInVM]) + or: [vmThread state = CTMInitializing]). - [self assert: (vmThread state = CTMWantingOwnership - or: [vmThread state = CTMAssignableOrInVM]). self ioSignalOSSemaphore: (self addressOf: vmThread osSemaphore)]. self ioTransferTimeslice! Item was changed: VMStructType subclass: #CogVMThread + instanceVariableNames: 'index state priority osSemaphore osThread newMethodOrNull argumentCount inMachineCode cStackPointer cFramePointer awolProcIndex awolProcLength awolProcesses reenterThreadSchedulingLoop' - instanceVariableNames: 'index state priority osSemaphore osThread newMethodOrNull argumentCount inMachineCode cStackPointer cFramePointer awolProcIndex awolProcLength awolProcesses' classVariableNames: '' poolDictionaries: 'VMThreadingConstants' category: 'VMMaker-Multithreading'! !CogVMThread commentStamp: '<historical>' prior: 0! Instances of this class represent control blocks for native threads that cooperatively schedule the VM. See the class comment of CogThreadManager for full documentation. N.B. awolProcesses must be the last inst var.! Item was changed: ----- Method: CogVMThread class>>instVarNamesAndTypesForTranslationDo: (in category 'translation') ----- instVarNamesAndTypesForTranslationDo: aBinaryBlock "enumerate aBinaryBlock with the names and C type strings for the inst vars to include in a CogVMThread struct." self allInstVarNames do: [:ivn| aBinaryBlock value: ivn value: (ivn caseOf: { ['awolProcesses'] -> [{#sqInt. '[', CogThreadManager awolProcessesIncrement printString, ']'}]. ['cStackPointer'] -> [#usqIntptr_t]. ['cFramePointer'] -> [#usqIntptr_t]. ['osSemaphore'] -> ['sqOSSemaphore']. + ['osThread'] -> ['sqOSThread']. + ['reenterThreadSchedulingLoop'] -> ['jmp_buf'] } - ['osThread'] -> ['sqOSThread'] } otherwise: [#sqInt])]! Item was added: + ----- Method: CogVMThread>>reenterThreadSchedulingLoop (in category 'accessing') ----- + reenterThreadSchedulingLoop + <inline: #always> + ^ reenterThreadSchedulingLoop! Item was added: + ----- Method: CogVMThread>>reenterThreadSchedulingLoop: (in category 'accessing') ----- + reenterThreadSchedulingLoop: aReenterThreadSchedulingLoop + <doNotGenerate> + reenterThreadSchedulingLoop := aReenterThreadSchedulingLoop! Item was changed: ----- Method: Cogit>>initializeCodeZoneFrom:upTo: (in category 'initialization') ----- initializeCodeZoneFrom: startAddress upTo: endAddress <api> self initializeBackend. self sqMakeMemoryExecutableFrom: startAddress To: endAddress CodeToDataDelta: (self cppIf: #DUAL_MAPPED_CODE_ZONE ifTrue: [self addressOf: codeToDataDelta put: [:v| codeToDataDelta := v]] ifFalse: [nil]). codeBase := methodZoneBase := startAddress. backEnd stopsFrom: startAddress to: endAddress - 1. self cCode: '' inSmalltalk: [self initializeProcessor. backEnd stopsFrom: objectMemory memoryOffset "first word may not exist in the simulator's memory" to: guardPageSize - 1. backEnd has64BitPerformanceCounter ifTrue: [self initializeSimulationIOHighResClockForProfiling]]. methodZone manageFrom: methodZoneBase to: endAddress. self assertValidDualZone. backEnd detectFeatures. self maybeGenerateCacheFlush. + "self generateVMOwnerLockFunctions." - self generateVMOwnerLockFunctions. self genGetLeafCallStackPointers. self generateStackPointerCapture. self generateTrampolines. self computeEntryOffsets. self computeFullBlockEntryOffsets. self generateClosedPICPrototype. self alignMethodZoneBase. "None of the above is executed beyond ceCheckFeatures, so a bulk flush now is the leanest thing to do." backEnd flushICacheFrom: startAddress to: methodZoneBase asUnsignedInteger. self maybeFlushWritableZoneFrom: startAddress to: methodZoneBase asUnsignedInteger. "Repeat so that now the methodZone ignores the generated run-time." methodZone manageFrom: methodZoneBase to: endAddress. "N.B. this is assumed to be the last thing done in initialization; see Cogit>>initialized. This is done only to compute openPICSize; the generated code is discarded." self generateOpenPICPrototype! Item was removed: - ----- Method: Cogit>>tryLockVMOwnerTo: (in category 'multi-threading') ----- - tryLockVMOwnerTo: value - <api> - "ceTryLockVMOwner does an atomic compare-and-swap of the vmOwner - variable with zero and the argument, setting vmOwner to value if it was - zero. It answers if the lock was zero and hence was acquired. - - See CogThreadManager>>#tryLockVMOwnerTo: for the simulation of - processor thread switching which surrounds this method." - <cmacro: '(value) ceTryLockVMOwner(value)'> - | breakPCWasTrue | - "(thisContext findContextSuchThat: [:ctxt| ctxt selector == #primitiveRelinquishProcessor]) ifNil: - [self halt]." - (breakPCWasTrue := breakPC == true) ifTrue: - [breakPC := nil]. - processor abiMarshalArg0: value in: objectMemory memory. - ^[ | result instructions | - lastNInstructions removeAll. - result := self simulateLeafCallOf: ceTryLockVMOwner. - instructions := lastNInstructions copy. - self assert: (result ~= 0) = (coInterpreter threadManager getVMOwner = value). - result ~= 0] ensure: - [processor abiUnmarshal: 1. - breakPCWasTrue ifTrue: - [breakPC := true]]! Item was changed: ----- Method: StackInterpreter>>setImageHeaderFlagsFrom: (in category 'image save/restore') ----- setImageHeaderFlagsFrom: headerFlags "Set the flags that are contained in the 7th long of the image header." imageHeaderFlags := headerFlags. "so as to preserve unrecognised flags." fullScreenFlag := headerFlags bitAnd: 1. imageFloatsBigEndian := (headerFlags noMask: 2) ifTrue: [1] ifFalse: [0]. + "processHasThreadAffinity := headerFlags anyMask: 4. specific to CoInterpreterMT" - "processHasThreadId := headerFlags anyMask: 4. specific to CoInterpreterMT" "flagInterpretedMethods := headerFlags anyMask: 8. specific to CoInterpreter" preemptionYields := headerFlags noMask: 16. "noThreadingOfGUIThread := headerFlags anyMask: 32. specific to CoInterpreterMT" newFinalization := headerFlags anyMask: 64. sendWheelEvents := headerFlags anyMask: 128. primitiveDoMixedArithmetic < 0 ifTrue: "i.e. has it not been set on the command line?" [primitiveDoMixedArithmetic := headerFlags noMask: 256]. "N.B. flag mask 512 is responded to by the FilePlugin & FileAttributesPlugin" upscaleDisplayIfHighDPI < 0 ifTrue: "i.e. has it not been set on the command line?" [upscaleDisplayIfHighDPI := headerFlags noMask: 1024]! Item was added: + ----- Method: VMClass>>atomic:_compare:_exchange_strong: (in category 'C atomics simulation') ----- + atomic: anAtomicValue _compare: expected _exchange_strong: desired + "Simulator implementation of the C11 implementation of atomic instructions. + See: https://en.cppreference.com/w/c/atomic/atomic_compare_exchange" + <doNotGenerate> + self assert: (anAtomicValue class = AtomicValue). + ^ anAtomicValue compare: expected exchange: desired.! Item was added: + ----- Method: VMClass>>atomic_load: (in category 'C atomics simulation') ----- + atomic_load: anAtomicValue + "Simulator implementation of the C11 implementation of atomic instructions. + See: https://en.cppreference.com/w/c/atomic/atomic_load" + <doNotGenerate> + self assert: (anAtomicValue class = AtomicValue). + ^ anAtomicValue value! Item was added: + ----- Method: VMClass>>atomic_store:_: (in category 'C atomics simulation') ----- + atomic_store: anAtomicValue _: aValue + "Simulator implementation of the C11 atomic instructions. + See: https://en.cppreference.com/w/c/atomic/atomic_store" + <doNotGenerate> + self assert: (anAtomicValue class = AtomicValue). + anAtomicValue value: aValue!

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

Vm-dev September 2023