[Vm-dev] VM Maker: VMMaker.oscog-eem.1623.mcz

commits at source.squeak.org commits at source.squeak.org
Sat Jan 9 06:58:13 UTC 2016 

Eliot Miranda uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1623.mcz

==================== Summary ====================

Name: VMMaker.oscog-eem.1623
Author: eem
Time: 8 January 2016, 10:56:32.739189 pm
UUID: 796c33c7-b025-4e0c-bd4e-1d3fa3d71f22
Ancestors: VMMaker.oscog-eem.1622

Fix a bug with out-of-place two-way become, which got the hash copy the wrong way round.  By default, the hash stays with the reference in two-way become.

Fix what appears to be a compiler bug with in-place two-way-become by treating the headers to be swapped so that remembered flags are swapped and hash bits are swapped if required.

=============== Diff against VMMaker.oscog-eem.1622 ===============

Item was removed:
- ----- Method: Spur64BitMemoryManager>>identityHashFullWordMask (in category 'header access') -----
- identityHashFullWordMask
- 	^16r3fffff00000000!

Item was added:
+ ----- Method: SpurMemoryManager>>cleverSwapHeaders:and:copyHashFlag: (in category 'become implementation') -----
+ cleverSwapHeaders: obj1 and: obj2 copyHashFlag: copyHashFlag
+ 	"swap headers, but swapping headers swaps remembered bits and hashes;
+ 	 remembered bits must be unswapped and hashes may be unswapped if
+ 	 copyHash is false."
+ 	"This variant doesn't tickle a compiler bug in gcc and clang.  See naiveSwapHeaders:and:copyHashFlag:"
+ 	<inline: true>
+ 	| header1 header2 remembered1 remembered2 |
+ 	header1 := self long64At: obj1.
+ 	header2 := self long64At: obj2.
+ 	remembered1 := header1 bitAnd: 1 << self rememberedBitShift.
+ 	remembered2 := header2 bitAnd: 1 << self rememberedBitShift.
+ 	remembered1 ~= remembered2 ifTrue:
+ 		[header1 := header1 - remembered1 + remembered2.
+ 		 header2 := header2 - remembered2 + remembered1].
+ 	"swapping headers swaps hash; if not copyHashFlag then unswap hash"
+ 	copyHashFlag ifFalse:
+ 		[| hash1 hash2 |
+ 		 hash1 := header1 bitAnd: self identityHashFullWordMask.
+ 		 hash2 := header2 bitAnd: self identityHashFullWordMask.
+ 		 hash1 ~= hash2 ifTrue:
+ 			[header1 := header1 - hash1 + hash2.
+ 			 header2 := header2 - hash2 + hash1]].
+ 	self long64At: obj1 put: header2.
+ 	self long64At: obj2 put: header1!

Item was added:
+ ----- Method: SpurMemoryManager>>identityHashFullWordMask (in category 'header access') -----
+ identityHashFullWordMask
+ 	^16r3fffff00000000!

Item was changed:
  ----- Method: SpurMemoryManager>>inPlaceBecome:and:copyHashFlag: (in category 'become implementation') -----
  inPlaceBecome: obj1 and: obj2 copyHashFlag: copyHashFlag
+ 	<inline: #never> "in an effort to fix a compiler bug with two-way become post r3427"
  	"Do become in place by swapping object contents."
+ 	| o1HasYoung o2HasYoung fmt |
- 	| headerTemp temp1 temp2 o1HasYoung o2HasYoung fmt |
  	self assert: (self numSlotsOf: obj1) = (self numSlotsOf: obj2).
  	self assert: ((self rawHashBitsOf: obj1) = 0
  				 or: [(self classOrNilAtIndex: (self rawHashBitsOf: obj1)) ~= obj1]).
  	self assert: ((self rawHashBitsOf: obj2) = 0
  				 or: [(self classOrNilAtIndex: (self rawHashBitsOf: obj2)) ~= obj2]).
+ 	"swap headers, but swapping headers swaps remembered bits and hashes;
+ 	 remembered bits must be unswapped and hashes may be unswapped if
+ 	 copyHash is false."
+ 	false
+ 		ifTrue: [self naiveSwapHeaders: obj1 and: obj2 copyHashFlag: copyHashFlag]
+ 		ifFalse: [self cleverSwapHeaders: obj1 and: obj2 copyHashFlag: copyHashFlag].
- 	"swap headers, but swapping headers swaps remembered bits;
- 	 these need to be unswapped."
- 	temp1 := self isRemembered: obj1.
- 	temp2 := self isRemembered: obj2.
- 	headerTemp := self long64At: obj1.
- 	self long64At: obj1 put: (self long64At: obj2).
- 	self long64At: obj2 put: headerTemp.
- 	self setIsRememberedOf: obj1 to: temp1.
- 	self setIsRememberedOf: obj2 to: temp2.
- 	"swapping headers swaps hash; if !!copyHashFlag undo hash copy"
- 	copyHashFlag ifFalse:
- 		[temp1 := self rawHashBitsOf: obj1.
- 		 self setHashBitsOf: obj1 to: (self rawHashBitsOf: obj2).
- 		 self setHashBitsOf: obj2 to: temp1].
  	o1HasYoung := o2HasYoung := false.
  	0 to: (self numSlotsOf: obj1) - 1 do:
+ 		[:i| | temp1 temp2 |
- 		[:i|
  		temp1 := self fetchPointer: i ofObject: obj1.
  		temp2 := self fetchPointer: i ofObject: obj2.
+ 		self storePointerUnchecked: i ofObject: obj1 withValue: temp2.
+ 		self storePointerUnchecked: i ofObject: obj2 withValue: temp1.
- 		self storePointerUnchecked: i
- 			ofObject: obj1
- 			withValue: temp2.
- 		self storePointerUnchecked: i
- 			ofObject: obj2
- 			withValue: temp1.
  		(self isYoung: temp2) ifTrue:
  			[o1HasYoung := true].
  		(self isYoung: temp1) ifTrue:
  			[o2HasYoung := true]].
+ 	(o1HasYoung and: [self isOldObject: obj1]) ifTrue:
- 	(self isOldObject: obj1) ifTrue:
  		[fmt := self formatOf: obj1.
+ 		 (self isPureBitsFormat: fmt) ifFalse:
- 		 (o1HasYoung and: [(self isPureBitsFormat: fmt) not]) ifTrue:
  			[self possibleRootStoreInto: obj1]].
+ 	(o2HasYoung and: [self isOldObject: obj2]) ifTrue:
- 	(self isOldObject: obj2) ifTrue:
  		[fmt := self formatOf: obj2.
+ 		 (self isPureBitsFormat: fmt) ifFalse:
- 		 (o2HasYoung and: [(self isPureBitsFormat: fmt) not]) ifTrue:
  			[self possibleRootStoreInto: obj2]]!

Item was added:
+ ----- Method: SpurMemoryManager>>naiveSwapHeaders:and:copyHashFlag: (in category 'become implementation') -----
+ naiveSwapHeaders: obj1 and: obj2 copyHashFlag: copyHashFlag
+ 	"swap headers, but swapping headers swaps remembered bits and hashes;
+ 	 remembered bits must be unswapped and hashes may be unswapped if
+ 	 copyHash is false."
+ 	"This variant tickles a compiler bug in gcc and clang. See cleverSwapHeaders:and:copyHashFlag:"
+ 	<inline: true>
+ 	| headerTemp remembered1 remembered2 hashTemp |
+ 	remembered1 := self isRemembered: obj1.
+ 	remembered2 := self isRemembered: obj2.
+ 	headerTemp := self long64At: obj1.
+ 	self long64At: obj1 put: (self long64At: obj2).
+ 	self long64At: obj2 put: headerTemp.
+ 	self setIsRememberedOf: obj1 to: remembered1.
+ 	self setIsRememberedOf: obj2 to: remembered2.
+ 	"swapping headers swaps hash; if !!copyHashFlag undo hash copy"
+ 	copyHashFlag ifFalse:
+ 		[hashTemp := self rawHashBitsOf: obj1.
+ 		 self setHashBitsOf: obj1 to: (self rawHashBitsOf: obj2).
+ 		 self setHashBitsOf: obj2 to: hashTemp]!

Item was changed:
  ----- Method: SpurMemoryManager>>outOfPlaceBecome:and:copyHashFlag: (in category 'become implementation') -----
  outOfPlaceBecome: obj1 and: obj2 copyHashFlag: copyHashFlag
+ 	<inline: #never> "in an effort to fix a compiler bug with two-way become post r3427"
  	"Allocate two new objects, n1 & n2.  Copy the contents appropriately. Convert
  	 obj1 and obj2 into forwarding objects pointing to n2 and n1 respectively"
  	| clone1 clone2 |
  	clone1 := (self isContextNonImm: obj1)
  				ifTrue: [coInterpreter cloneContext: obj1]
  				ifFalse: [self clone: obj1].
  	clone2 := (self isContextNonImm: obj2)
  				ifTrue: [coInterpreter cloneContext: obj2]
  				ifFalse: [self clone: obj2].
  	copyHashFlag
  		ifTrue:
- 			[self setHashBitsOf: clone1 to: (self rawHashBitsOf: obj2).
- 			 self setHashBitsOf: clone2 to: (self rawHashBitsOf: obj1)]
- 		ifFalse:
  			[self setHashBitsOf: clone1 to: (self rawHashBitsOf: obj1).
+ 			 self setHashBitsOf: clone2 to: (self rawHashBitsOf: obj2)]
+ 		ifFalse:
+ 			[self setHashBitsOf: clone1 to: (self rawHashBitsOf: obj2).
+ 			 self setHashBitsOf: clone2 to: (self rawHashBitsOf: obj1)].
- 			 self setHashBitsOf: clone2 to: (self rawHashBitsOf: obj2)].
  	self
  		forward: obj1 to: clone2;
  		forward: obj2 to: clone1.
  	((self isYoungObject: obj1) ~= (self isYoungObject: clone2)
  	 or: [(self isYoungObject: obj2) ~= (self isYoungObject: clone1)]) ifTrue:
  		[becomeEffectsFlags := becomeEffectsFlags bitOr: OldBecameNewFlag]!

More information about the Vm-dev mailing list