[Vm-dev] VM Maker: VMMaker.oscog.seperateMarking-WoC.3292.mcz

commits at source.squeak.org commits at source.squeak.org
Sat Jan 7 12:00:48 UTC 2023


Tom Braun uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog.seperateMarking-WoC.3292.mcz

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

Name: VMMaker.oscog.seperateMarking-WoC.3292
Author: WoC
Time: 7 January 2023, 1:00:24.455682 pm
UUID: e1ddd04f-168d-478a-9e00-685345e32f11
Ancestors: VMMaker.oscog.seperateMarking-WoC.3291

- free partially compacted segments until the point they were compacted (use swizzle to store this info)
- update currentSegmentsBridge at the start of every sweep and compact pass, because the bridge size could have changed when a segment directly behind the current segment was removed

=============== Diff against VMMaker.oscog.seperateMarking-WoC.3291 ===============

Item was changed:
  ----- Method: Spur64BitMemoryManager>>initSegmentBridgeWithBytes:at: (in category 'object enumeration') -----
  initSegmentBridgeWithBytes: numBytes at: address
  	<var: #numBytes type: #usqLong>
  	| numSlots |
  	"Must have room for a double header or a short object with the forwarding slot (16 bytes either way)."
  	self assert: (numBytes \\ self allocationUnit = 0
  				 and: [numBytes >= (self baseHeaderSize + self baseHeaderSize)]).
  	numSlots := numBytes - self baseHeaderSize - self baseHeaderSize >> self shiftForWord.
+ 	
+ 	numSlots < 2
- 	numSlots = 0
  		ifTrue: "short bridge for adjacent segments"
  			[self longAt: address
+ 					put:  (numSlots + 1) << self numSlotsFullShift  "(0+1 = 1 => 16 byte bridged; 1+1 = 2 => 24 byte bridged )"
+ 						+ (1 << self pinnedBitShift)
- 					put:    (1 << self pinnedBitShift)
  						+ (1 << self markedBitFullShift)
  						+ (self wordIndexableFormat << self formatShift)
  						+ self segmentBridgePun]
  		ifFalse: "long bridge"
  			[self longAt: address
  					put: self numSlotsMask << self numSlotsFullShift + numSlots;
  				longAt: address + self baseHeaderSize
  					put: (self numSlotsMask << self numSlotsFullShift)
  						+ (1 << self pinnedBitShift)
  						+ (1 << self markedBitFullShift)
  						+ (self wordIndexableFormat << self formatShift)
  						+ self segmentBridgePun]!

Item was changed:
  ----- Method: SpurIncrementalCompactingSweeper>>compactSegment:freeStart:segIndex: (in category 'incremental compact') -----
  compactSegment: segInfo freeStart: initialFreeStart segIndex: segIndex
  	<var: 'segInfo' type: #'SpurSegmentInfo *'>
  
  	| fillStart |
  	fillStart := initialFreeStart.
  	
  	self deny: segIndex = 0. "Cannot compact seg 0"
  	manager segmentManager
  		allEntitiesInSegment: segInfo
  		exceptTheLastBridgeDo:
  			[:entity |
  			(manager isFreeObject: entity)
  				ifTrue: 
  					[manager detachFreeObject: entity.
  					 "To avoid confusing too much Spur (especially the leak/free checks), we mark the free chunk as a word object."
  					 manager set: entity classIndexTo: manager wordSizeClassIndexPun formatTo: manager wordIndexableFormat]
  				ifFalse: 
  					[ (manager isMarked: entity)
  						ifTrue: [manager makeWhite: entity.
  							"During the mutator runs new forwarding references can be created. Ignore them as they get resolved with the other 
  							forwarders in this segment in the next marking pass"
  								(manager isForwarded: entity) 
  									ifFalse:[| bytesToCopy |
  										"Copy the object in segmentToFill and replace it by a forwarder."
  										bytesToCopy := manager bytesInBody: entity. 
  										
  										(self oop: fillStart + bytesToCopy isLessThan: (segmentToFill segLimit - manager bridgeSize))
  											ifFalse: ["somebody allocated a new object we did not knew about at the moment of planning :( -> it does not fit anymore and we cannot free the whole segment. Make sure to unmark the segment as beeing compacted as it would be completetly freed otherwise!!"
+ 												coInterpreter cr; print: 'segments if full. Abort compacting of:  '; printHex: segInfo segStart ; tab; flush.
- 												coInterpreter cr; print: 'segments if full. Abort compacting of:  '; printHex: segmentToFill segStart ; tab; flush.
  												self unmarkSegmentAsBeingCompacted: (manager segInfoAt: currentSegmentsIndex).
+ 												self 
+ 													unmarkSegment: (manager segInfoAt: currentSegmentsIndex) 
+ 													asBeingCompactedAndSaveEndOfCompactionAddress: entity.
  												
  												"we need to sweep the rest of the segment. As the segment is not marked to be compacted anymore sweepOrCompactFromCurrentObject will decide to sweep it. We want to start sweeping from the current entity, therefore setting currentObject to it and
  												we have to protect it from beeing freed (with marking it) as it was marked previously and after us unmarking it here would
  												get collected incorrectly"
  												manager setIsMarkedOf: entity to: true.
  												currentObject := entity.
  
  												^ fillStart].
  
  										self migrate: entity sized: bytesToCopy to: fillStart.
  
  										fillStart := fillStart + bytesToCopy.
  										self assert: (self oop: fillStart isLessThan: (segmentToFill segLimit - manager bridgeSize))]]
  						ifFalse: [
  							(manager isRemembered: entity)
  								ifTrue: 
  									[self assert: (manager isFreeObject: entity) not.
  									 scavenger forgetObject: entity].
  						
  							"To avoid confusing too much Spur (especially the leak/free checks), we don't make the dead object a free chunk, but make it
  							a non pointer object to avoid the leak checker to try to follow the pointers of the dead object. 
  							Should we abort compacting this segment the object will get kept alife for one gc cycle" 
  							manager set: entity classIndexTo: manager wordSizeClassIndexPun formatTo: manager wordIndexableFormat]]].
  
  	"we want to advance to the next segment from the bridge"
  	currentObject := currentSegmentsBridge.
  	^ fillStart!

Item was changed:
  ----- Method: SpurIncrementalCompactingSweeper>>freePastSegmentsAndSetSegmentToFill (in category 'public') -----
  freePastSegmentsAndSetSegmentToFill	
  	
  	"The first segment being claimed met becomes the segmentToFill. The others are just freed."
  	<var: 'segInfo' type: #'SpurSegmentInfo *'>
  	0 to: manager numSegments - 1 do:
  		[:i| | segInfo |
  		 segInfo := manager segInfoAt: i.
+ 		(self wasSegmentsCompactionAborted: segInfo)
+ 			ifTrue: [ | freeUntil chunkBytes |
+ 				freeUntil := manager startOfObject: (self getEndOfCompaction: segInfo).
+ 				chunkBytes := freeUntil - segInfo segStart.
+ 				
+ 				"maybe we could not even move one object out of the segment. Make sure we do not produce an invalid free chunk"
+ 				chunkBytes > 0
+ 					ifTrue: [coInterpreter
+ 								cr; print: 'partially freeing segment from: '; printHex: segInfo segStart;
+ 								print: ' to: '; printHex: freeUntil ;tab; flush.
+ 							
+ 								manager 
+ 									addFreeChunkWithBytes: chunkBytes 
+ 									at: segInfo segStart]].
+ 		 
+ 		(self isSegmentBeingCompacted: segInfo) ifTrue: 
- 		 (self isSegmentBeingCompacted: segInfo) ifTrue: 
  			[ | freeChunk chunkBytes |
  			self assert: (manager segmentManager allObjectsAreForwardedInSegment: segInfo includingFreeSpace: false).
  			self assert: (manager noElementOfFreeSpaceIsInSegment: segInfo).
  			
  			coInterpreter
  				cr; print: 'freeing segment from: '; printHex: segInfo segStart;
  				print: ' to: '; printHex: segInfo segStart + segInfo segSize ;tab; flush.
  				
  			chunkBytes := segInfo segSize - manager bridgeSize.
  			freeChunk := manager 
  				addFreeChunkWithBytes: chunkBytes 
  				at: segInfo segStart.
  				
  			self unmarkSegmentAsBeingCompacted: segInfo.
  				
  			 segmentToFill ifNil:
  				[manager detachFreeObject: freeChunk.
  				 segmentToFill := segInfo]]]!

Item was added:
+ ----- Method: SpurIncrementalCompactingSweeper>>getEndOfCompaction: (in category 'segment access') -----
+ getEndOfCompaction: segInfo
+ 
+ 	self assert: (self wasSegmentsCompactionAborted: segInfo).
+ 	^ segInfo swizzle!

Item was changed:
  ----- Method: SpurIncrementalCompactingSweeper>>incrementalSweepAndCompact (in category 'public') -----
  incrementalSweepAndCompact
  
  	scStartTime := coInterpreter ioUTCMicrosecondsNow.
  	self initIfNecessary.
  	
  	"should in between sweeper calls segments be removed the index would not be correct anymore. Reset it here so we can be sure it is correct"
  	currentSegmentsIndex := manager segmentManager segmentIndexContainingObj: currentObject.
+ 	"if the bridge between segments was small before and the segment directly after the current one was removed the position of the bridge moved. Update 
+ 	the current position to avoid this case"
+ 	currentSegmentsBridge := manager segmentManager bridgeAt: currentSegmentsIndex.
  	
  	self assert: manager validObjectColors.
  	
  	self doincrementalSweepAndCompact
  		ifTrue: [self finishSweepAndCompact.
  			^ true].
  		
  	coInterpreter cr; print: 'current position: '; printHex: currentObject; tab; flush.
  		
  	^ false!

Item was changed:
  ----- Method: SpurIncrementalCompactingSweeper>>isSegmentAtIndexBeingCompacted: (in category 'testing') -----
  isSegmentAtIndexBeingCompacted: segIndex
  
+ 	^ self isSegmentBeingCompacted: (manager segInfoAt: segIndex) !
- 	"Swizzle is abused to note a segment as being compacted. 1 means yes, 0 no"
- 	^ (manager segInfoAt: segIndex) swizzle = 1!

Item was changed:
  ----- Method: SpurIncrementalCompactingSweeper>>isSegmentBeingCompacted: (in category 'testing') -----
  isSegmentBeingCompacted: segInfo 
  
  	<var: 'segInfo' type: #'SpurSegmentInfo *'>
+ 	"Swizzle is abused to note a segment as being compacted. 
+ 		swizzle = 0 -> not compacted
+ 		swizzle = 1 -> compacted 
+ 		swizzle > 7 -> aborted compaction; swizzle is set to the objOop of the object after the compacted part"
- 	"Swizzle is abused to note a segment as being compacted. 1 means yes, 0 no"
  	^ segInfo swizzle = 1!

Item was changed:
  ----- Method: SpurIncrementalCompactingSweeper>>markSegmentAsBeingCompacted: (in category 'segment access') -----
  markSegmentAsBeingCompacted: segInfo 
  	<var: 'segInfo' type: #'SpurSegmentInfo *'>
+ 	"Swizzle is abused to note a segment as being compacted. 
+ 		swizzle = 0 -> not compacted
+ 		swizzle = 1 -> compacted 
+ 		swizzle > 7 -> aborted compaction; swizzle is set to the objOop of the object after the compacted part"
- 	"Swizzle is abused to note a segment as being compacted. 1 means yes, 0 no"
  	self assert: (manager numSegments > 1 and: [segInfo ~= (self addressOf: (manager segmentManager segments at: 0))]).
  	segInfo swizzle: 1!

Item was added:
+ ----- Method: SpurIncrementalCompactingSweeper>>unmarkSegment:asBeingCompactedAndSaveEndOfCompactionAddress: (in category 'segment access') -----
+ unmarkSegment: segInfo asBeingCompactedAndSaveEndOfCompactionAddress: address
+ 	
+ 	<var: 'segInfo' type: #'SpurSegmentInfo *'>
+ 	"Swizzle is abused to note a segment as being compacted. 
+ 		swizzle = 0 -> not compacted
+ 		swizzle = 1 -> compacted 
+ 		swizzle > 7 -> aborted compaction; swizzle is set to the objOop of the object after the compacted part"
+ 	self assert: (address bitAnd: 7) = 0.
+ 	segInfo swizzle: address!

Item was changed:
  ----- Method: SpurIncrementalCompactingSweeper>>unmarkSegmentAsBeingCompacted: (in category 'segment access') -----
  unmarkSegmentAsBeingCompacted: segInfo 
  	
  	<var: 'segInfo' type: #'SpurSegmentInfo *'>
+ 	"Swizzle is abused to note a segment as being compacted. 
+ 		swizzle = 0 -> not compacted
+ 		swizzle = 1 -> compacted 
+ 		swizzle > 7 -> aborted compaction; swizzle is set to the objOop of the object after the compacted part"
- 	"Swizzle is abused to note a segment as being compacted. 1 means yes, 0 no"
  	segInfo swizzle: 0!

Item was added:
+ ----- Method: SpurIncrementalCompactingSweeper>>wasSegmentsCompactionAborted: (in category 'testing') -----
+ wasSegmentsCompactionAborted: segInfo 
+ 
+ 	<var: 'segInfo' type: #'SpurSegmentInfo *'>
+ 	"Swizzle is abused to note a segment as being compacted. 
+ 		swizzle = 0 -> not compacted
+ 		swizzle = 1 -> compacted 
+ 		swizzle > 7 -> aborted compaction; swizzle is set to the objOop of the object after the compacted part"
+ 	^ segInfo swizzle > 7!

Item was removed:
- ----- Method: SpurIncrementalMarker>>pushOnMarkingStack: (in category 'marking-stack') -----
- pushOnMarkingStack: objOop
- 
- 	manager push: objOop onObjStack: manager markStack!



More information about the Vm-dev mailing list