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

[commits at source.squeak.org]

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

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

Name: VMMaker.oscog-eem.1046
Author: eem
Time: 6 February 2015, 11:05:41.709 am
UUID: b7e289ed-2b6a-43c7-a1d0-82fdaf8538bb
Ancestors: VMMaker.oscog-eem.1045

Spur:
Scavenging ephemerons should update the ephemeron's
key with the scavenged key.

Add an assert to remapObj:.

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

Item was changed:
  ----- Method: SpurGenerationScavenger>>fireEphemeronsInRememberedSet (in category 'weakness and ephemerality') -----
  fireEphemeronsInRememberedSet
  	"There are ephemerons to be fired in the remembered set.
  	 Fire them and scavenge their keys.  Leave it to scavengeLoop
  	 to remove any scavenged ephemerons that no longer have
  	 new referents."
  	| i |
  	self assert: self noUnfiredEphemeronsAtEndOfRememberedSet.
  
  	i := 0.
  	[i < numRememberedEphemerons] whileTrue:
  		[ | ephemeron |
  		 ephemeron := rememberedSet at: i.
  		 self assert: (manager isEphemeron: ephemeron).
  		 self assert: (self isScavengeSurvivor: (manager keyOfEphemeron: ephemeron)) not.
  		 coInterpreter fireEphemeron: ephemeron.
+ 		 manager
+ 			storePointerUnchecked: 0
+ 			ofObject: ephemeron
+ 			withValue: (self copyAndForward: (manager keyOfEphemeron: ephemeron)).
- 		 self copyAndForward: (manager keyOfEphemeron: ephemeron).
  		 (self scavengeReferentsOf: ephemeron)
  			ifTrue: "keep in set"
  				[i := i + 1]
  			ifFalse:
  				[manager setIsRememberedOf: ephemeron to: false.
  				"remove from set by overwriting with next-to-be scanned"
  				 numRememberedEphemerons := numRememberedEphemerons - 1.
  				 previousRememberedSetSize := previousRememberedSetSize - 1.
  				 rememberedSetSize := rememberedSetSize - 1.
  				 "First overwrite with last firable ephemeron (could be a noop if this is the last one).
  				  Then overwrite last firable entry with next unscanned rememberedSet entry (could also be a noop).
  				  Then overwrite next unscanned entry with last unscanned rememberedSet entry (could also be a noop)."
  				 rememberedSet
  					at: i
  						put: (rememberedSet at: numRememberedEphemerons);
  					at: numRememberedEphemerons
  						put: (rememberedSet at: previousRememberedSetSize);
  					at: previousRememberedSetSize
  						put: (rememberedSet at: rememberedSetSize)]].
  
  	"no more firable ephemerons in this cycle.
  	 scavengeRememberedSetStartingAt: may find new ones."
  	numRememberedEphemerons := 0!

Item was changed:
  ----- Method: SpurGenerationScavenger>>fireEphemeronsOnEphemeronList (in category 'weakness and ephemerality') -----
  fireEphemeronsOnEphemeronList
  	"There are ephemerons to be fired in the remembered set.
  	 Fire them and scavenge their keys.  Be careful since copyAndForward:
  	 can remember ephemerons (ephemerons pointing to ephemerons)."
  	| ephemeron ephemeronCorpse |
  	ephemeronList ifNil:
  		[^self].
  	ephemeronCorpse := self firstCorpse: ephemeronList.
  	"Reset the list head so that new ephemerons will get added
  	 to a new list, not concatenated on the one we are scanning."
  	ephemeronList := nil.
  	[ephemeronCorpse notNil] whileTrue:
  		[self assert: (manager isForwarded: ephemeronCorpse).
  		 ephemeron := manager followForwarded: ephemeronCorpse.
  		 self assert: (self isScavengeSurvivor: (manager keyOfEphemeron: ephemeron)) not.
  		 coInterpreter fireEphemeron: ephemeron.
+ 		 manager
+ 			storePointerUnchecked: 0
+ 			ofObject: ephemeron
+ 			withValue: (self copyAndForward: (manager keyOfEphemeron: ephemeron)).
- 		 self copyAndForward: (manager keyOfEphemeron: ephemeron).
  		 self cCoerceSimple: (self scavengeReferentsOf: ephemeron) to: #void.
  		 ephemeronCorpse := self nextCorpseOrNil: ephemeronCorpse]!

Item was changed:
  ----- Method: SpurMemoryManager>>remapObj: (in category 'gc - scavenging') -----
  remapObj: objOop
  	"Scavenge or simply follow objOop.  Answer the new location of objOop.
  	 The send should have been guarded by a send of shouldRemapOop:.
  	 The method is called remapObj: for compatibility with ObjectMemory."
  	<api>
  	<inline: false>
  	| resolvedObj |
  	self assert: (self shouldRemapOop: objOop).
  	(self isForwarded: objOop)
  		ifTrue:
  			[resolvedObj := self followForwarded: objOop.
  			(self isInFutureSpace: resolvedObj) ifTrue: "already scavenged"
  				[^resolvedObj]]
  		ifFalse:
+ 			[self deny: (self isInFutureSpace: resolvedObj).
+ 			 resolvedObj := objOop].
- 			[resolvedObj := objOop].
  	(scavengeInProgress
  	 and: [self isReallyYoung: resolvedObj]) ifTrue: "a becommed or compacted object whose target is in old space, or a CogMethod."
  		[^scavenger copyAndForward: resolvedObj].
  	^resolvedObj!