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

commits at source.squeak.org commits at source.squeak.org
Fri Nov 1 05:16:20 UTC 2013 

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

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

Name: VMMaker.oscog-eem.489
Author: eem
Time: 31 October 2013, 9:55:43.597 pm
UUID: 46b91af3-49f9-4110-8271-4ca4c04bd0b6
Ancestors: VMMaker.oscog-eem.488

Remember to follow forwarders in obj stacks in
eliminateAndFreeForwarders.

Change ensureRoomOnObjStackAt: to only set the mark bit on a new
page, as old pages should already be marked.

Remove the unused accessors for markStack and ephemeronQueue.

Add an invalidObjStackPage inst var and a beefy assert to
storePointer:ofObjStack:withValue: for debugging.
Check mark state in isValidObjStackPage:myIndex:

Collect obj stack GC into markAndTraceObjStacks,
followForwardedObjStacks & validObjStacks.

Rename updateRootOfObjStack: to updateRootOfObjStackAt: &
updateRootOfObjStack:with: to updateRootOfObjStackAt:with:
for consistency/comprehensibility.

GC seems to run...

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

Item was changed:
  CogClass subclass: #SpurMemoryManager
(excessive size, no diff calculated)

Item was changed:
  ----- Method: SpurMemoryManager>>eliminateAndFreeForwarders (in category 'gc - global') -----
  eliminateAndFreeForwarders
  	"As the final phase of global garbage collect, sweep
  	 the heap to follow forwarders, then free forwarders"
  	| lowestForwarded firstForwarded lastForwarded |
  	self assert: (self isForwarded: nilObj) not.
  	self assert: (self isForwarded: falseObj) not.
  	self assert: (self isForwarded: trueObj) not.
  	self assert: (self isForwarded: hiddenRootsObj) not.
  	(self isForwarded: specialObjectsOop) ifTrue:
  		[specialObjectsOop := self followForwarded: specialObjectsOop].
+ 	self followForwardedObjStacks.
  	scavenger followRememberedForwardersAndForgetFreeObjects.
  	self doScavenge: TenureByAge.
  	lowestForwarded := 0.
  	"sweep, following forwarders in all live objects, and finding the first forwarder."
  	self allOldSpaceObjectsDo:
  		[:o|
  		(self isForwarded: o)
  			ifTrue:
  				[lowestForwarded = 0 ifTrue:
  					[lowestForwarded := o]]
  			ifFalse:
  				[0 to: (self numPointerSlotsOf: o) - 1 do:
  					[:i| | f |
  					f := self fetchPointer: i ofObject: o.
  					(self isOopForwarded: f) ifTrue:
  						[f := self followForwarded: f.
  						 self assert: ((self isImmediate: f) or: [self isYoung: f]) not.
  						 self storePointerUnchecked: i ofObject: o withValue: f]]]].
  	firstForwarded := lastForwarded := 0.
  	"sweep from lowest forwarder, coalescing runs of forwarders."
  	self allOldSpaceObjectsFrom: lowestForwarded do:
  		[:o|
  		(self isForwarded: o)
  			ifTrue:
  				[firstForwarded = 0 ifTrue:
  					[firstForwarded := o].
  				 lastForwarded := o]
  			ifFalse:
  				[firstForwarded ~= 0 ifTrue:
  					[| start bytes |
  					 start := self startOfObject: firstForwarded.
  					 bytes := (self addressAfter: lastForwarded) - start.
  					 self addFreeChunkWithBytes: bytes at: start].
  				 firstForwarded := 0]].
  	firstForwarded ~= 0 ifTrue:
  		[| start bytes |
  		 start := self startOfObject: firstForwarded.
  		 bytes := (self addressAfter: lastForwarded) - start.
  		 self addFreeChunkWithBytes: bytes at: start].!

Item was changed:
  ----- Method: SpurMemoryManager>>ensureRoomOnObjStackAt: (in category 'obj stacks') -----
  ensureRoomOnObjStackAt: objStackRootIndex
  	"An obj stack is a stack of objects stored in a hidden root slot, such as
  	 the markStack or the ephemeronQueue.  It is a linked list of segments,
  	 with the hot end at the head of the list.  It is a word object.  The stack
  	 pointer is in ObjStackTopx and 0 means empty.  The list goes through
  	 ObjStackNextx. We don't want to shrink objStacks, since they're used
  	 in GC and its good to keep their memory around.  So unused pages
  	 created by popping emptying pages are kept on the ObjStackFreex list."
  	| stackOrNil freeOrNewPage |
  	stackOrNil := self fetchPointer: objStackRootIndex ofObject: hiddenRootsObj.
  	(stackOrNil = nilObj
  	 or: [(self fetchPointer: ObjStackTopx ofObject: stackOrNil) >= ObjStackLimit]) ifTrue:
  		[freeOrNewPage := stackOrNil = nilObj
  								ifTrue: [0]
  								ifFalse: [self fetchPointer: ObjStackFreex ofObject: stackOrNil].
  		 freeOrNewPage ~= 0
  			ifTrue: "the free page list is always on the new page."
+ 				[self storePointer: ObjStackFreex ofObjStack: stackOrNil withValue: 0.
+ 				 self assert: (marking not or: [self isMarked: freeOrNewPage])]
- 				[self storePointer: ObjStackFreex ofObjStack: stackOrNil withValue: 0]
  			ifFalse:
  				[freeOrNewPage := self allocateSlotsInOldSpace: ObjStackPageSlots
  										format: self wordIndexableFormat
  										classIndex: self wordSizeClassIndexPun.
  				 freeOrNewPage ifNil: [self error: 'no memory to allocate or extend obj stack'].
+ 				 self storePointer: ObjStackFreex ofObjStack: freeOrNewPage withValue: 0..
+ 				 marking ifTrue: [self setIsMarkedOf: freeOrNewPage to: true]].
+ 		 self storePointer: ObjStackMyx ofObjStack: freeOrNewPage withValue: objStackRootIndex;
+ 			  storePointer: ObjStackNextx ofObjStack: freeOrNewPage withValue: (stackOrNil = nilObj ifTrue: [0] ifFalse: [stackOrNil]);
+ 			  storePointer: ObjStackTopx ofObjStack: freeOrNewPage withValue: 0;
+ 			  storePointer: objStackRootIndex ofObject: hiddenRootsObj withValue: freeOrNewPage.
+ 		 self assert: (self isValidObjStackAt: objStackRootIndex).
+ 		 "Added a new page; now update and answer the relevant cached first page."
+ 		 ^self updateRootOfObjStackAt: objStackRootIndex with: freeOrNewPage].
- 				 self storePointer: ObjStackFreex ofObjStack: freeOrNewPage withValue: 0].
- 		marking ifTrue: [self setIsMarkedOf: freeOrNewPage to: true].
- 		self storePointer: ObjStackMyx ofObjStack: freeOrNewPage withValue: objStackRootIndex;
- 			storePointer: ObjStackNextx ofObjStack: freeOrNewPage withValue: (stackOrNil = nilObj ifTrue: [0] ifFalse: [stackOrNil]);
- 			storePointer: ObjStackTopx ofObjStack: freeOrNewPage withValue: 0;
- 			storePointer: objStackRootIndex ofObject: hiddenRootsObj withValue: freeOrNewPage.
- 		self assert: (self isValidObjStackAt: objStackRootIndex).
- 		"Added a new page; now update and answer the relevant cached first page."
- 		^self updateRootOfObjStack: objStackRootIndex with: freeOrNewPage].
  	self assert: (self isValidObjStackAt: objStackRootIndex).
  	^stackOrNil!

Item was removed:
- ----- Method: SpurMemoryManager>>ephemeronQueue (in category 'gc - global') -----
- ephemeronQueue
- 	^self fetchPointer: EphemeronQueueRootIndex ofObject: hiddenRootsObj!

Item was removed:
- ----- Method: SpurMemoryManager>>ephemeronQueue: (in category 'gc - global') -----
- ephemeronQueue: anObject
- 	self storePointer: EphemeronQueueRootIndex ofObject: hiddenRootsObj withValue: anObject!

Item was added:
+ ----- Method: SpurMemoryManager>>followForwardedInObjStack:atIndex: (in category 'obj stacks') -----
+ followForwardedInObjStack: objStack atIndex: objStackRootIndex
+ 	"Post-compact, follow forwarders in an obj stack."
+ 	| firstPage stackOrNil index field |
+ 	objStack = nilObj ifTrue:
+ 		[^objStack].
+ 	stackOrNil := objStack.
+ 	(self isForwarded: stackOrNil) ifTrue:
+ 		[stackOrNil := self followForwarded: stackOrNil.
+ 		 self updateRootOfObjStackAt: objStackRootIndex with: stackOrNil].
+ 	firstPage := stackOrNil.
+ 	[self assert: (self numSlotsOfAny: stackOrNil) = ObjStackPageSlots.
+ 	 self assert: (self fetchPointer: ObjStackMyx ofObject: stackOrNil) = objStackRootIndex.
+ 	 "There are four fixed slots in an obj stack, and a Topx of 0 indicates empty, so
+ 	   if there were 5 slots in an oop stack, full would be 2, and the last 0-rel index is 4.
+ 	   Hence the last index is topx + fixed slots - 1, or topx + ObjStackNextx"
+ 	 index := (self fetchPointer: ObjStackTopx ofObject: stackOrNil) + ObjStackNextx.
+ 	 "follow forwarded fields including ObjStackNextx and leave field containing the next link."
+ 	 [field := self fetchPointer: index ofObject: stackOrNil.
+ 	  (field ~= 0 and: [(self isNonImmediate: field) and: [self isForwarded: field]]) ifTrue:
+ 		[field := self followForwarded: field.
+ 		 self storePointer: index ofObjStack: stackOrNil withValue: field].
+ 	  (index := index - 1) > ObjStackFreex] whileTrue.
+ 	  self assert: field = (self fetchPointer: ObjStackNextx ofObject: stackOrNil).
+ 	 (stackOrNil := field) ~= 0] whileTrue.
+ 	[stackOrNil := self fetchPointer: ObjStackFreex ofObject: firstPage.
+ 	 stackOrNil ~= 0] whileTrue:
+ 		[(self isForwarded: stackOrNil) ifTrue:
+ 			[stackOrNil := self followForwarded: stackOrNil.
+ 			 self storePointer: ObjStackFreex ofObjStack: firstPage withValue: stackOrNil].
+ 		 firstPage := stackOrNil].
+ 	self assert: (self isValidObjStackAt: objStackRootIndex)!

Item was added:
+ ----- Method: SpurMemoryManager>>followForwardedObjStacks (in category 'compaction') -----
+ followForwardedObjStacks
+ 	"Compaction will move objStack pages as well as ordinary objects.
+ 	 So they need their slots followed."
+ 	self followForwardedInObjStack: markStack atIndex: MarkStackRootIndex.
+ 	self followForwardedInObjStack: weaklingStack atIndex: WeaklingStackRootIndex.
+ 	self followForwardedInObjStack: ephemeronQueue atIndex: EphemeronQueueRootIndex!

Item was changed:
  ----- Method: SpurMemoryManager>>globalGarbageCollect (in category 'gc - global') -----
  globalGarbageCollect
  	self runLeakCheckerForFullGC: true.
+ 	self assert: self validObjStacks.
  	self markObjects.
  	self nilUnmarkedWeaklingSlots.
  	self freeUnmarkedObjectsAndSortAndCoalesceFreeSpace.
  	self bestFitCompact.
  	self eliminateAndFreeForwarders.
+ 	self assert: self validObjStacks.
  	self runLeakCheckerForFullGC: true!

Item was changed:
  ----- Method: SpurMemoryManager>>isValidObjStack: (in category 'obj stacks') -----
  isValidObjStack: objStack
  	"Answer if the obj stack at objStackRootIndex is valid."
  	((self addressCouldBeObj: objStack)
  	 and: [(self numSlotsOfAny: objStack) = ObjStackPageSlots]) ifFalse:
  		[objStackInvalidBecause := 'first page not obj or wrong size'.
+ 		 invalidObjStackPage := objStack.
  		 ^false].
  	^self isValidObjStackPage: objStack
  		myIndex: (self fetchPointer: ObjStackMyx ofObject: objStack)
  		firstPage: true!

Item was changed:
  ----- Method: SpurMemoryManager>>isValidObjStackPage:myIndex: (in category 'obj stacks') -----
  isValidObjStackPage: objStackPage myIndex: myx
  	"Just check the page itself."
  	<inline: false>
  	(self classIndexOf: objStackPage) = self wordSizeClassIndexPun ifFalse:
  		[objStackInvalidBecause := 'wong class index'.
+ 		 invalidObjStackPage := objStackPage.
  		 ^false].
  	(self formatOf: objStackPage) = self wordIndexableFormat ifFalse:
  		[objStackInvalidBecause := 'wong format'.
+ 		 invalidObjStackPage := objStackPage.
  		 ^false].
  	(self numSlotsOfAny: objStackPage) = ObjStackPageSlots ifFalse:
  		[objStackInvalidBecause := 'wong num slots'.
+ 		 invalidObjStackPage := objStackPage.
  		 ^false].
  	myx = (self fetchPointer: ObjStackMyx ofObject: objStackPage) ifFalse:
  		[objStackInvalidBecause := 'wong myx'.
+ 		 invalidObjStackPage := objStackPage.
  		 ^false].
+ 	(marking and: [(self isMarked: objStackPage) not]) ifTrue:
+ 		[objStackInvalidBecause := 'marking but page is unmarked'.
+ 		 invalidObjStackPage := objStackPage.
+ 		 ^false].
  	^true!

Item was changed:
  ----- Method: SpurMemoryManager>>isValidObjStackPage:myIndex:firstPage: (in category 'obj stacks') -----
  isValidObjStackPage: objStackPage myIndex: myx firstPage: isFirstPage
  	"Answer if the obj stack at stackRootIndex is valid."
  	| freeOrNextPage index |
  	<inline: false>
  	(self isValidObjStackPage: objStackPage myIndex: myx) ifFalse:
  		[^false].
  	freeOrNextPage := self fetchPointer: ObjStackFreex ofObject: objStackPage.
  	[freeOrNextPage ~= 0] whileTrue:
  		[isFirstPage ifFalse:
  			[objStackInvalidBecause := 'free page on other than first page'.
+ 			 invalidObjStackPage := objStackPage.
  			 ^false].
  		 (self isValidObjStackPage: freeOrNextPage myIndex: myx) ifFalse:
  			[objStackInvalidBecause := self str: objStackInvalidBecause cat: ', on next page'.
  			^false].
  		 freeOrNextPage := self fetchPointer: ObjStackFreex ofObject: freeOrNextPage].
  	isFirstPage ifTrue:
  		[(myx between: self classTableRootSlots and: self classTableRootSlots + self hiddenRootSlots - 1) ifFalse:
  			[objStackInvalidBecause := 'myx out of range'.
+ 			 invalidObjStackPage := objStackPage.
  			 ^false].
  		 (self fetchPointer: myx ofObject: hiddenRootsObj) = objStackPage ifFalse:
  			[objStackInvalidBecause := 'firstPage is not root'.
+ 			 invalidObjStackPage := objStackPage.
  			 ^false]].
  	index := self fetchPointer: ObjStackTopx ofObject: objStackPage.
  	(index between: 0 and: ObjStackLimit) ifFalse:
  		[objStackInvalidBecause := 'bad topx'.
+ 		 invalidObjStackPage := objStackPage.
  		 ^false].
  	freeOrNextPage := self fetchPointer: ObjStackNextx ofObject: objStackPage.
  	^freeOrNextPage = 0
  	  or: [self isValidObjStackPage: freeOrNextPage myIndex: myx firstPage: false]!

Item was changed:
  ----- Method: SpurMemoryManager>>markAccessibleObjects (in category 'gc - global') -----
  markAccessibleObjects
  	self assert: self validClassTableRootPages.
  	self assert: segmentManager allBridgesMarked.
  	marking := true.
  	self cCode: [] "for debugging markAndTrace: set (MarkStackRecord := OrderedCollection new)"
  		inSmalltalk: [MarkStackRecord ifNotNil: [MarkStackRecord resetTo: 1]].
+ 	self markAndTraceObjStacks.
- 	self markAndTraceObjStack: self markStack andContents: false.
  	self assert: self validClassTableRootPages.
- 	self markAndTraceObjStack: self ephemeronQueue andContents: true.
- 	self assert: self validClassTableRootPages.
  	coInterpreter markAndTraceInterpreterOops: true.
  	self markAndTrace: self freeListsObj.
  	self markAndTrace: hiddenRootsObj.
  	self markAndTrace: self specialObjectsOop.
+ 	self assert: self validObjStacks.
  	self markWeaklingsAndMarkAndFireEphemerons.
+ 	self assert: self validObjStacks.
  	marking := false!

Item was changed:
  ----- Method: SpurMemoryManager>>markAndTraceObjStack:andContents: (in category 'obj stacks') -----
  markAndTraceObjStack: stackOrNil andContents: markAndTraceContents
  	"An obj stack is a stack of objects stored in a hidden root slot, such
  	 as the markStack or the ephemeronQueue.  It is a linked list of
  	 segments, with the hot end at the head of the list.  It is a word object.
  	 The stack pointer is in ObjStackTopx and 0 means empty."
  	<inline: false>
  	| index field |
  	stackOrNil = nilObj ifTrue:
  		[^self].
+ 	self setIsMarkedOf: stackOrNil to: true.
  	self assert: (self numSlotsOfAny: stackOrNil) = ObjStackPageSlots.
  	field := self fetchPointer: ObjStackNextx ofObject: stackOrNil.
  	field ~= 0 ifTrue:
  		[self markAndTraceObjStack: field andContents: markAndTraceContents].
  	field := stackOrNil.
  	[field := self fetchPointer: ObjStackFreex ofObject: stackOrNil.
  	 field ~= 0] whileTrue:
  		[self setIsMarkedOf: field to: true].
  	markAndTraceContents ifFalse:
  		[^self].
  	"There are four fixed slots in an obj stack, and a Topx of 0 indicates empty, so
  	  if there were 6 slots in an oop stack, full would be 2, and the last 0-rel index is 5."
  	index := (self fetchPointer: ObjStackTopx ofObject: stackOrNil) + ObjStackNextx.
  	[index >= ObjStackFixedSlots] whileTrue:
  		[field := self fetchPointer: index ofObject: stackOrNil.
  		 (self isImmediate: field) ifFalse:
  			[self markAndTrace: field].
  		 index := index - 1]!

Item was added:
+ ----- Method: SpurMemoryManager>>markAndTraceObjStacks (in category 'obj stacks') -----
+ markAndTraceObjStacks
+ 	self markAndTraceObjStack: markStack andContents: false.
+ 	self markAndTraceObjStack: weaklingStack andContents: false.
+ 	self markAndTraceObjStack: ephemeronQueue andContents: true!

Item was removed:
- ----- Method: SpurMemoryManager>>markStack (in category 'gc - global') -----
- markStack
- 	^self fetchPointer: MarkStackRootIndex ofObject: hiddenRootsObj!

Item was removed:
- ----- Method: SpurMemoryManager>>markStack: (in category 'gc - global') -----
- markStack: anObject
- 	self storePointer: MarkStackRootIndex ofObject: hiddenRootsObj withValue: anObject!

Item was changed:
  ----- Method: SpurMemoryManager>>noCheckPush:onObjStack: (in category 'obj stacks') -----
  noCheckPush: objOop onObjStack: objStack
  	"Push an element on an objStack.  Split from push:onObjStack: for testing."
  	| topx |
  	self assert: (self isValidObjStack: objStack).
  	self cCode: [] "for debugging markAndTrace: set (MarkStackRecord := OrderedCollection new)"
  		inSmalltalk:
+ 			[(self fetchPointer: ObjStackMyx ofObject: objStack) = MarkStackRootIndex ifTrue:
- 			[objStack = markStack ifTrue:
  				[MarkStackRecord ifNotNil: [MarkStackRecord addLast: {#push. objOop}]]].
  	topx := self fetchPointer: ObjStackTopx ofObject: objStack.
  	topx >= ObjStackLimit
  		ifTrue:
  			[self noCheckPush: objOop
  				onObjStack: (self ensureRoomOnObjStackAt: (self fetchPointer: ObjStackMyx ofObject: objStack))]
  		ifFalse:
  			[self storePointer: ObjStackFixedSlots + topx ofObjStack: objStack withValue: objOop.
  			 self storePointer: ObjStackTopx ofObjStack: objStack withValue: topx + 1].
  	^objOop!

Item was changed:
  ----- Method: SpurMemoryManager>>popObjStack: (in category 'obj stacks') -----
  popObjStack: objStack
  	| topx top nextPage myx |
  	self assert: (self isValidObjStack: objStack).
  	topx := self fetchPointer: ObjStackTopx ofObject: objStack.
  	topx = 0 ifTrue:
  		[self assert: (self fetchPointer: ObjStackNextx ofObject: objStack) = 0.
  		 self cCode: [] "for debugging markAndTrace: set (MarkStackRecord := OrderedCollection new)"
  			inSmalltalk:
+ 				[(self fetchPointer: ObjStackMyx ofObject: objStack) = MarkStackRootIndex ifTrue:
+ 					[MarkStackRecord ifNotNil:
+ 						[MarkStackRecord addLast: {#EMPTY. nil}]]].
- 				[MarkStackRecord ifNotNil:
- 					[MarkStackRecord addLast: {#EMPTY. nil}]].
  		^nil].
  	topx := topx - 1.
  	top := self fetchPointer: topx + ObjStackFixedSlots ofObject: objStack.
  	self cCode: [] "for debugging markAndTrace: set (MarkStackRecord := OrderedCollection new)"
  		inSmalltalk:
+ 			[(self fetchPointer: ObjStackMyx ofObject: objStack) = MarkStackRootIndex ifTrue:
+ 				[MarkStackRecord ifNotNil:
+ 					[(MarkStackRecord last first = #push and: [MarkStackRecord last last = top])
+ 						ifTrue: [MarkStackRecord removeLast]
+ 						ifFalse: [MarkStackRecord addLast: {#pop. top}]]]].
- 			[MarkStackRecord ifNotNil:
- 				[(MarkStackRecord last first = #push and: [MarkStackRecord last last = top])
- 					ifTrue: [MarkStackRecord removeLast]
- 					ifFalse: [MarkStackRecord addLast: {#pop. top}]]].
  	self storePointer: ObjStackTopx ofObject: objStack withValue: topx.
  	(topx = 0
  	 and: [(nextPage := self fetchPointer: ObjStackNextx ofObject: objStack) ~= 0]) ifTrue:
  		[self storePointer: ObjStackFreex ofObjStack: nextPage withValue: objStack.
  		 self storePointer: ObjStackNextx ofObjStack: objStack withValue: 0.
  		 myx := self fetchPointer: ObjStackMyx ofObject: objStack.
+ 		 self updateRootOfObjStackAt: myx with: nextPage].
- 		 self updateRootOfObjStack: myx with: nextPage].
  	^top!

Item was changed:
  ----- Method: SpurMemoryManager>>storePointer:ofObjStack:withValue: (in category 'object access') -----
+ storePointer: fieldIndex ofObjStack: objStackPage withValue: thang
+ 	self assert: (self formatOf: objStackPage) = self wordIndexableFormat.
+ 	self cCode: []
+ 		inSmalltalk:
+ 			[fieldIndex caseOf: {
+ 				[ObjStackTopx]		->	[self assert: (thang between: 0 and: ObjStackLimit)].
+ 				[ObjStackMyx]		->	[self assert: (thang between: MarkStackRootIndex and: EphemeronQueueRootIndex)].
+ 				[ObjStackFreex]	->	[self assert: (thang = 0
+ 														or: [(self addressCouldBeObj: thang)
+ 															and: [(self numSlotsOfAny: thang) = ObjStackPageSlots
+ 															and: [(self formatOf: thang) = self wordIndexableFormat]]])].
+ 				[ObjStackNextx]	->	[self assert: (thang = 0
+ 														or: [(self addressCouldBeObj: thang)
+ 															and: [(self numSlotsOfAny: thang) = ObjStackPageSlots
+ 															and: [(self formatOf: thang) = self wordIndexableFormat]]])]. }
+ 				otherwise: []].
- storePointer: fieldIndex ofObjStack: objOop withValue: valuePointer
- 	self assert: (self formatOf: objOop) = self wordIndexableFormat.
  	^self
+ 		longAt: objStackPage + self baseHeaderSize + (fieldIndex << self shiftForWord)
+ 		put: thang!
- 		longAt: objOop + self baseHeaderSize + (fieldIndex << self shiftForWord)
- 		put: valuePointer!

Item was removed:
- ----- Method: SpurMemoryManager>>updateRootOfObjStack:with: (in category 'obj stacks') -----
- updateRootOfObjStack: objStackRootIndex with: newRootPage
- 	self storePointer: objStackRootIndex
- 		ofObject: hiddenRootsObj
- 		withValue: newRootPage.
- 	objStackRootIndex caseOf: {
- 		[MarkStackRootIndex]			->	[markStack := newRootPage].
- 		[WeaklingStackRootIndex]		->	[weaklingStack := newRootPage].
- 		[EphemeronQueueRootIndex]	->	[ephemeronQueue := newRootPage] }.
- 	self assert: (self isValidObjStack: newRootPage).
- 	^newRootPage!

Item was added:
+ ----- Method: SpurMemoryManager>>updateRootOfObjStackAt:with: (in category 'obj stacks') -----
+ updateRootOfObjStackAt: objStackRootIndex with: newRootPage
+ 	self storePointer: objStackRootIndex
+ 		ofObject: hiddenRootsObj
+ 		withValue: newRootPage.
+ 	objStackRootIndex caseOf: {
+ 		[MarkStackRootIndex]			->	[markStack := newRootPage].
+ 		[WeaklingStackRootIndex]		->	[weaklingStack := newRootPage].
+ 		[EphemeronQueueRootIndex]	->	[ephemeronQueue := newRootPage] }.
+ 	self assert: (self isValidObjStack: newRootPage).
+ 	^newRootPage!

Item was added:
+ ----- Method: SpurMemoryManager>>validObjStacks (in category 'obj stacks') -----
+ validObjStacks
+ 	^(markStack = nilObj or: [self isValidObjStack: markStack])
+ 	  and: [(weaklingStack = nilObj or: [self isValidObjStack: weaklingStack])
+ 	  and: [ephemeronQueue = nilObj or: [self isValidObjStack: ephemeronQueue]]]!

More information about the Vm-dev mailing list