[Vm-dev] VM Maker: VMMaker.oscog-eem.768.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.768.mcz

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

Name: VMMaker.oscog-eem.768
Author: eem
Time: 11 June 2014, 2:03:40.157 pm
UUID: 9b465bed-0f83-48f0-baae-9fd7212183c1
Ancestors: VMMaker.oscog-eem.767

checkTraversableSortedFreeList needs to be called through
assert; it is expensive.

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

Item was changed:
  ----- Method: SpurMemoryManager>>checkTraversableSortedFreeList (in category 'simulation only') -----
  checkTraversableSortedFreeList
  	| prevFree freeChunk next |
  	<api>
  	<inline: false>
  	prevFree := 0.
  	freeChunk := firstFreeChunk.
  	self allOldSpaceEntitiesDo:
  		[:o| | objOop |
  		(self isFreeObject: o) ifTrue:
  			[self assert: o = freeChunk.
  			 next := self nextInSortedFreeListLink: freeChunk given: prevFree.
  			 "coInterpreter transcript cr; print: freeChunk; tab; print: o; tab; print: prevFree; nextPutAll: '<->'; print: next; flush."
  			 objOop := freeChunk.
  			 [(objOop := self objectAfter: objOop) < next] whileTrue:
  				[self assert: (self isFreeObject: objOop) not].
  			 prevFree := freeChunk.
  			 freeChunk := next]].
  	self assert: prevFree = lastFreeChunk.
+ 	self assert: freeChunk = 0.
+ 	^true!
- 	self assert: freeChunk = 0!

Item was changed:
  ----- Method: SpurMemoryManager>>freeUnmarkedObjectsAndSortAndCoalesceFreeSpaceForPigCompact (in category 'gc - global') -----
  freeUnmarkedObjectsAndSortAndCoalesceFreeSpaceForPigCompact
  	"Sweep all of old space, freeing unmarked objects, coalescing free chunks, and sorting free space.
  
  	 Doubly-link the free chunks in address order through the freeChunkNextIndex field using the
  	 xor trick to use only one field, see e.g.
  		The Art of Computer Programming, Vol 1, D.E. Knuth, 3rd Ed, Sec 2.2.4 `Circular Lists', exercise. 18
  		http://en.wikipedia.org/wiki/XOR_linked_list.
  	 Record the lowest free object in firstFreeChunk and the highest in lastFreeChunk.
  
  	 Let the segmentManager mark which segments contain pinned objects via notePinned:."
  
  	| prevPrevFree prevFree |
  	<inline: false>
  	self checkFreeSpace.
  	scavenger forgetUnmarkedRememberedObjects.
  	self doScavenge: MarkOnTenure.
  	segmentManager prepareForGlobalSweep."for notePinned:"
  	"throw away the list heads, including the tree."
  	self resetFreeListHeads.
  	firstFreeChunk := prevPrevFree := prevFree := 0.
  	self allOldSpaceEntitiesForCoalescingFrom: self firstObject do:
  		[:o|
  		 self assert: (firstFreeChunk = 0 or: [self isFreeObject: firstFreeChunk]).
  		 (self isMarked: o)
  			ifTrue: "forwarders should have been followed in markAndTrace:"
  				[self assert: (self isForwarded: o) not.
  				 self setIsMarkedOf: o to: false. "this will unmark bridges. undo the damage in notePinned:"
  				 (self isPinned: o) ifTrue:
  					[segmentManager notePinned: o]]
  			ifFalse: "unmarked; two cases, an unreachable object or a free chunk."
  				[| here |
  				 self assert: (self isRemembered: o) not. "scavenger should have cleared this above"
  				 here := self coallesceFreeChunk: o.
  				 self setObjectFree: here.
  				 self inSortedFreeListLink: prevFree to: here given: prevPrevFree.
  				 prevPrevFree := prevFree.
  				 prevFree := here]].
  	prevFree ~= firstFreeChunk ifTrue:
  		[self storePointer: self freeChunkNextIndex
  			ofFreeChunk: prevFree
  			withValue: prevPrevFree].
  	lastFreeChunk := prevFree.
  	self inSortedFreeListLink: lastFreeChunk to: 0 given: prevPrevFree.
+ 	self assert: self checkTraversableSortedFreeList!
- 	self checkTraversableSortedFreeList!

Item was changed:
  ----- Method: SpurMemoryManager>>pigCompact (in category 'compaction') -----
  pigCompact
  	"Traverse the sorted free list, moving objects from the high-end of
  	 memory to the free objects in the low end of memory.  Return when
  	 the address at which objects are being copiecd to meets the address
  	 from which objects are being copied from."
  	self cCode: '' inSmalltalk: [coInterpreter transcript nextPutAll: 'pig compacting...'; flush].
  	self sortedFreeListPairwiseReverseDo:
  		[:low :high| | scanAddress |
  		 self cCode: '' inSmalltalk: [coInterpreter transcript nextPut: $.; flush].
  		 scanAddress := self addressAfter: low.
  		 [self oop: scanAddress isLessThan: high] whileTrue:
  			[scanAddress := self moveARunOfObjectsStartingAt: scanAddress upTo: high.
  			 scanAddress = 0 ifTrue:
  				[^self]]].
+ 	self assert: self checkTraversableSortedFreeList!
- 	self cCode: [] inSmalltalk: [self checkTraversableSortedFreeList]!

Item was changed:
  ----- Method: SpurMemoryManager>>rebuildFreeListsForPigCompact (in category 'compaction') -----
  rebuildFreeListsForPigCompact
  	"Rebuild the free lists from the doubly-linked free list."
  	<inline: false>
+ 	self assert: self checkTraversableSortedFreeList.
- 	self checkTraversableSortedFreeList.
  	totalFreeOldSpace := 0.
  	self sortedFreeListDo:
  		[:freeObj| | start bytes |
  		 bytes := (self bytesInObject: freeObj).
  		 start := self startOfObject: freeObj.
  		 self addFreeChunkWithBytes: bytes at: start].
  	self checkFreeSpace!

Item was changed:
  ----- Method: SpurMemoryManager>>sweepToCoallesceFreeSpaceForPigCompactFrom: (in category 'compaction') -----
  sweepToCoallesceFreeSpaceForPigCompactFrom: lowestForwarder
  	"Coallesce free chunks and forwarders, maintaining the doubly-linked free list."
  	| lowest firstOfFreeRun startOfFreeRun endOfFreeRun prevPrevFree prevFree |
  	lowest := (lowestForwarder = 0 ifTrue: [endOfMemory] ifFalse: [lowestForwarder])
  				min: (firstFreeChunk = 0 ifTrue: [endOfMemory] ifFalse: [firstFreeChunk]).
  	firstOfFreeRun := prevPrevFree := prevFree := 0.
  	self allOldSpaceEntitiesFrom: lowest do:
  		[:o|
  		((self isFreeObject: o) or: [self isForwarded: o])
  			ifTrue:
  				[firstOfFreeRun = 0 ifTrue:
  					[self setObjectFree: o.
  					 firstOfFreeRun := o.
  					 startOfFreeRun := self startOfObject: o].
  				 endOfFreeRun := o]
  			ifFalse:
  				[firstOfFreeRun ~= 0 ifTrue:
  					[| bytes |
  					 bytes := (self addressAfter: endOfFreeRun) - startOfFreeRun.
  					 firstOfFreeRun := self initFreeChunkWithBytes: bytes at: startOfFreeRun.
  					 self inSortedFreeListLink: prevFree to: firstOfFreeRun given: prevPrevFree.
  					 prevPrevFree := prevFree.
  					 prevFree := firstOfFreeRun.
  					 firstOfFreeRun := 0]]].
  	firstOfFreeRun ~= 0 ifTrue:
  		[| bytes |
  		 bytes := (self addressAfter: endOfFreeRun) - startOfFreeRun.
  		 firstOfFreeRun := self initFreeChunkWithBytes: bytes at: startOfFreeRun.
  		 self inSortedFreeListLink: prevFree to: firstOfFreeRun given: prevPrevFree.
  		 prevPrevFree := prevFree.
  		 prevFree := firstOfFreeRun.
  		 firstOfFreeRun := 0].
  	prevFree ~= firstFreeChunk ifTrue:
  		[self storePointer: self freeChunkNextIndex
  			ofFreeChunk: prevFree
  			withValue: prevPrevFree].
  	lastFreeChunk := prevFree.
  	self inSortedFreeListLink: lastFreeChunk to: 0 given: prevPrevFree.
+ 	self assert: self checkTraversableSortedFreeList!
- 	self checkTraversableSortedFreeList!