From 1ab31109111f16ff0dcbbbc984c25eecbcd5581d Mon Sep 17 00:00:00 2001 From: jordanmontt Date: Mon, 9 Oct 2023 16:00:59 +0200 Subject: [PATCH 1/3] Add class that test some edge cases of the ephemerons algorithm --- .../VMSpurEphemeronsAlgorithmTest.class.st | 336 ++++++++++++++++++ 1 file changed, 336 insertions(+) create mode 100644 smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st diff --git a/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st b/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st new file mode 100644 index 0000000000..6bc5300168 --- /dev/null +++ b/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st @@ -0,0 +1,336 @@ +Class { + #name : #VMSpurEphemeronsAlgorithmTest, + #superclass : #VMSpurInitializedOldSpaceTest, + #instVars : [ + 'ephemeronObjectOopOne', + 'ephemeronObjectOopTwo', + 'nonEphemeronObjectOopOne', + 'nonEphemeronObjectOopTwo' + ], + #category : #'VMMakerTests-MemoryTests' +} + +{ #category : #helper } +VMSpurEphemeronsAlgorithmTest >> addKeysToEphemerons [ + + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopTwo +] + +{ #category : #helper } +VMSpurEphemeronsAlgorithmTest >> keepEphemeronsInVMVariables [ + "Force ephemerons to not be collected by putting them in special variables" + + self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable2: ephemeronObjectOopTwo +] + +{ #category : #helper } +VMSpurEphemeronsAlgorithmTest >> newEphemeronObjectOldSpace [ + "In pharo Ephemerons have 3 slots" + + ^ self newOldSpaceObjectWithSlots: 3 + format: memory ephemeronFormat + classIndex: (memory ensureBehaviorHash: ourEphemeronClass) +] + +{ #category : #running } +VMSpurEphemeronsAlgorithmTest >> setUp [ + + super setUp. + memory initializeMournQueue. + self createEphemeronClass +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsOldObjectsOld [ + + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 1. + nonEphemeronObjectOopTwo := self newOldSpaceObjectWithSlots: 0. + "Make object 1 reference object 2" + memory storePointer: 0 ofObject: nonEphemeronObjectOopOne withValue: nonEphemeronObjectOopTwo. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory fullGC. + + "ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo." + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsOldObjectsOldInverse [ + + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. + nonEphemeronObjectOopTwo := self newOldSpaceObjectWithSlots: 1. + "Make object 2 reference object 1" + memory storePointer: 0 ofObject: nonEphemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory fullGC. + + "ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo." + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsOldObjectsYoung [ + + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newObjectWithSlots: 1. + nonEphemeronObjectOopTwo := self newZeroSizedObject. + "Make object 1 reference object 2" + memory storePointer: 0 ofObject: nonEphemeronObjectOopOne withValue: nonEphemeronObjectOopTwo. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory doScavenge:1 "Tenured by age". + memory fullGC. + + "ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo." + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsOldObjectsYoungInverse [ + + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newZeroSizedObject. + nonEphemeronObjectOopTwo := self newObjectWithSlots: 1. + "Make object 2 reference object 1" + memory storePointer: 0 ofObject: nonEphemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory doScavenge:1 "Tenured by age". + memory fullGC. + + "ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo." + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - ephemerons with same key' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKey [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newZeroSizedObject. + + memory storePointer: 2 ofObject: ephemeronObjectOopOne withValue: ephemeronObjectOopTwo. + + "Both ephemerons share the same key" + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. + + "Collect ephemeron 1, ephemeron 2 is in the old space" + memory doScavenge: 1. + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - ephemerons with same key' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyFlushNewSpace [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newZeroSizedObject. + + memory storePointer: 2 ofObject: ephemeronObjectOopOne withValue: ephemeronObjectOopTwo. + + "Both ephemerons share the same key" + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. + + "Collect ephemeron 1, ephemeron 2 is in the old space" + memory flushNewSpace. + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - ephemerons with same key' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyFlushNewSpaceNoRefenceBetweenEphemerons [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newZeroSizedObject. + + "Both ephemerons share the same key" + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. + + "Collect both non ephemeron objects" + memory flushNewSpace. + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - ephemerons with same key' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNoRefenceBetweenEphemerons [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newZeroSizedObject. + + "Both ephemerons share the same key" + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. + + "Collect ephemeron 1, ephemeron 2 is in the old space" + memory doScavenge: 1. + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsYoungObjectsOld [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 1. + nonEphemeronObjectOopTwo := self newOldSpaceObjectWithSlots: 0. + "Make object 1 reference object 2" + memory storePointer: 0 ofObject: nonEphemeronObjectOopOne withValue: nonEphemeronObjectOopTwo. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory doScavenge:1 "Tenured by age". + memory fullGC. + + ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo. + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsYoungObjectsOldInverse [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. + nonEphemeronObjectOopTwo := self newOldSpaceObjectWithSlots: 1. + "Make object 2 reference object 1" + memory storePointer: 0 ofObject: nonEphemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory doScavenge:1 "Tenured by age". + memory fullGC. + + ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo. + + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. + self assert: memory dequeueMourner equals: ephemeronObjectOopOne +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsYoungObjectsYoung [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newObjectWithSlots: 1. + nonEphemeronObjectOopTwo := self newZeroSizedObject. + "Make object 1 reference object 2" + memory storePointer: 0 ofObject: nonEphemeronObjectOopOne withValue: nonEphemeronObjectOopTwo. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory doScavenge: 1. "TenureByAge" + + ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo. + + self assert: memory dequeueMourner equals: ephemeronObjectOopOne. + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo +] + +{ #category : #'tests - finalization - algorithm' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsYoungObjectsYoungInverse [ + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newZeroSizedObject. + nonEphemeronObjectOopTwo := self newObjectWithSlots: 1. + "Make object 2 reference object 1" + memory storePointer: 0 ofObject: nonEphemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. + + self addKeysToEphemerons. + self keepEphemeronsInVMVariables. + + "Collect both non ephemeron objects" + memory doScavenge: 1. "TenureByAge" + + ephemeronObjectOopOne := memory remapObj: ephemeronObjectOopOne. + ephemeronObjectOopTwo := memory remapObj: ephemeronObjectOopTwo. + + self assert: memory dequeueMourner equals: ephemeronObjectOopOne. + self assert: memory dequeueMourner equals: ephemeronObjectOopTwo +] From c9eb905d6725e47c16aae79a742ab90fb2ebc9f5 Mon Sep 17 00:00:00 2001 From: jordanmontt Date: Thu, 26 Oct 2023 11:34:17 +0200 Subject: [PATCH 2/3] Added more tests exposing when the algorithm fails --- .../VMSpurEphemeronsAlgorithmTest.class.st | 89 ++++++++++++------- 1 file changed, 57 insertions(+), 32 deletions(-) diff --git a/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st b/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st index 6bc5300168..4ef25b734b 100644 --- a/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st +++ b/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st @@ -142,14 +142,12 @@ VMSpurEphemeronsAlgorithmTest >> testEphemeronsOldObjectsYoungInverse [ ] { #category : #'tests - ephemerons with same key' } -VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKey [ +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNewSpace [ ephemeronObjectOopOne := self newEphemeronObject. - ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObject. nonEphemeronObjectOopOne := self newZeroSizedObject. - memory storePointer: 2 ofObject: ephemeronObjectOopOne withValue: ephemeronObjectOopTwo. - "Both ephemerons share the same key" memory storePointer: 0 ofObject: ephemeronObjectOopOne @@ -158,24 +156,23 @@ VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKey [ ofObject: ephemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. - self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable2: ephemeronObjectOopTwo. - "Collect ephemeron 1, ephemeron 2 is in the old space" + "Collect ephemerons" memory doScavenge: 1. - self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. - self assert: memory dequeueMourner equals: ephemeronObjectOopOne + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - ephemerons with same key' } -VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyFlushNewSpace [ +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNewSpaceFlush [ ephemeronObjectOopOne := self newEphemeronObject. - ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObject. nonEphemeronObjectOopOne := self newZeroSizedObject. - memory storePointer: 2 ofObject: ephemeronObjectOopOne withValue: ephemeronObjectOopTwo. - "Both ephemerons share the same key" memory storePointer: 0 ofObject: ephemeronObjectOopOne @@ -184,21 +181,22 @@ VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyFlushNewSpace [ ofObject: ephemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. - self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable2: ephemeronObjectOopTwo. - "Collect ephemeron 1, ephemeron 2 is in the old space" + "Collect both non ephemeron objects" memory flushNewSpace. - self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. - self assert: memory dequeueMourner equals: ephemeronObjectOopOne + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - ephemerons with same key' } -VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyFlushNewSpaceNoRefenceBetweenEphemerons [ +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNewSpaceOldSpace [ ephemeronObjectOopOne := self newEphemeronObject. - ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. - nonEphemeronObjectOopOne := self newZeroSizedObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. "Both ephemerons share the same key" memory storePointer: 0 @@ -208,19 +206,45 @@ VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyFlushNewSpaceNoRefence ofObject: ephemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. - self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable2: ephemeronObjectOopTwo. - "Collect both non ephemeron objects" - memory flushNewSpace. + "Collect ephemerons" + memory fullGC. + + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) +] + +{ #category : #'tests - ephemerons with same key' } +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyOldSpace [ - self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. - self assert: memory dequeueMourner equals: ephemeronObjectOopOne + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. + + "Both ephemerons share the same key" + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable2: ephemeronObjectOopTwo. + + "Collect ephemerons" + memory fullGC. + + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - ephemerons with same key' } -VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNoRefenceBetweenEphemerons [ +VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyOldSpaceNewSpace [ - ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. nonEphemeronObjectOopOne := self newZeroSizedObject. @@ -232,13 +256,14 @@ VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNoRefenceBetweenEpheme ofObject: ephemeronObjectOopTwo withValue: nonEphemeronObjectOopOne. - self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable1: ephemeronObjectOopOne. + self keepObjectInVMVariable2: ephemeronObjectOopTwo. - "Collect ephemeron 1, ephemeron 2 is in the old space" - memory doScavenge: 1. - - self assert: memory dequeueMourner equals: ephemeronObjectOopTwo. - self assert: memory dequeueMourner equals: ephemeronObjectOopOne + "Collect ephemerons" + memory fullGC. + + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - finalization - algorithm' } From ba5d1c414cdae8bd1755de9df8266f66915365ed Mon Sep 17 00:00:00 2001 From: jordanmontt Date: Thu, 26 Oct 2023 11:40:35 +0200 Subject: [PATCH 3/3] Code reformatting --- .../VMSpurEphemeronsAlgorithmTest.class.st | 172 +++++++++--------- 1 file changed, 86 insertions(+), 86 deletions(-) diff --git a/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st b/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st index 4ef25b734b..400872c055 100644 --- a/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st +++ b/smalltalksrc/VMMakerTests/VMSpurEphemeronsAlgorithmTest.class.st @@ -143,127 +143,127 @@ VMSpurEphemeronsAlgorithmTest >> testEphemeronsOldObjectsYoungInverse [ { #category : #'tests - ephemerons with same key' } VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNewSpace [ - - ephemeronObjectOopOne := self newEphemeronObject. - ephemeronObjectOopTwo := self newEphemeronObject. - nonEphemeronObjectOopOne := self newZeroSizedObject. + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newZeroSizedObject. "Both ephemerons share the same key" - memory storePointer: 0 - ofObject: ephemeronObjectOopOne - withValue: nonEphemeronObjectOopOne. - memory storePointer: 0 - ofObject: ephemeronObjectOopTwo - withValue: nonEphemeronObjectOopOne. - - self keepObjectInVMVariable1: ephemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. self keepObjectInVMVariable2: ephemeronObjectOopTwo. - - "Collect ephemerons" - memory doScavenge: 1. - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) + "Collect ephemerons" + memory doScavenge: 1. + + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - ephemerons with same key' } VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNewSpaceFlush [ - - ephemeronObjectOopOne := self newEphemeronObject. - ephemeronObjectOopTwo := self newEphemeronObject. - nonEphemeronObjectOopOne := self newZeroSizedObject. + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newZeroSizedObject. "Both ephemerons share the same key" - memory storePointer: 0 - ofObject: ephemeronObjectOopOne - withValue: nonEphemeronObjectOopOne. - memory storePointer: 0 - ofObject: ephemeronObjectOopTwo - withValue: nonEphemeronObjectOopOne. - - self keepObjectInVMVariable1: ephemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. self keepObjectInVMVariable2: ephemeronObjectOopTwo. - - "Collect both non ephemeron objects" - memory flushNewSpace. - - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) + + "Collect both non ephemeron objects" + memory flushNewSpace. + + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - ephemerons with same key' } VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyNewSpaceOldSpace [ - - ephemeronObjectOopOne := self newEphemeronObject. - ephemeronObjectOopTwo := self newEphemeronObject. - nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. + + ephemeronObjectOopOne := self newEphemeronObject. + ephemeronObjectOopTwo := self newEphemeronObject. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. "Both ephemerons share the same key" - memory storePointer: 0 - ofObject: ephemeronObjectOopOne - withValue: nonEphemeronObjectOopOne. - memory storePointer: 0 - ofObject: ephemeronObjectOopTwo - withValue: nonEphemeronObjectOopOne. - - self keepObjectInVMVariable1: ephemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. self keepObjectInVMVariable2: ephemeronObjectOopTwo. - - "Collect ephemerons" - memory fullGC. - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) + "Collect ephemerons" + memory fullGC. + + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - ephemerons with same key' } VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyOldSpace [ - - ephemeronObjectOopOne := self newEphemeronObjectOldSpace. - ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. - nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. + + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newOldSpaceObjectWithSlots: 0. "Both ephemerons share the same key" - memory storePointer: 0 - ofObject: ephemeronObjectOopOne - withValue: nonEphemeronObjectOopOne. - memory storePointer: 0 - ofObject: ephemeronObjectOopTwo - withValue: nonEphemeronObjectOopOne. - - self keepObjectInVMVariable1: ephemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. self keepObjectInVMVariable2: ephemeronObjectOopTwo. - - "Collect ephemerons" - memory fullGC. - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) + "Collect ephemerons" + memory fullGC. + + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - ephemerons with same key' } VMSpurEphemeronsAlgorithmTest >> testEphemeronsWithSameKeyOldSpaceNewSpace [ - - ephemeronObjectOopOne := self newEphemeronObjectOldSpace. - ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. - nonEphemeronObjectOopOne := self newZeroSizedObject. + + ephemeronObjectOopOne := self newEphemeronObjectOldSpace. + ephemeronObjectOopTwo := self newEphemeronObjectOldSpace. + nonEphemeronObjectOopOne := self newZeroSizedObject. "Both ephemerons share the same key" - memory storePointer: 0 - ofObject: ephemeronObjectOopOne - withValue: nonEphemeronObjectOopOne. - memory storePointer: 0 - ofObject: ephemeronObjectOopTwo - withValue: nonEphemeronObjectOopOne. - - self keepObjectInVMVariable1: ephemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopOne + withValue: nonEphemeronObjectOopOne. + memory storePointer: 0 + ofObject: ephemeronObjectOopTwo + withValue: nonEphemeronObjectOopOne. + + self keepObjectInVMVariable1: ephemeronObjectOopOne. self keepObjectInVMVariable2: ephemeronObjectOopTwo. - - "Collect ephemerons" - memory fullGC. - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner). - self assert: ( { ephemeronObjectOopOne . ephemeronObjectOopTwo } includes: memory dequeueMourner) + "Collect ephemerons" + memory fullGC. + + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner). + self assert: ({ ephemeronObjectOopOne. ephemeronObjectOopTwo } includes: memory dequeueMourner) ] { #category : #'tests - finalization - algorithm' }