crash.log

THERE_BE_DRAGONS_HERE
Error: Not enough space for external objects, set a larger size at startup!
27 July 2017 11:12:59.327785 pm

VM: Win32 - IX86 - 6.2 - CoInterpreter VMMaker.oscog-eem.1855 uuid: d8e4a3c2-a3bf-4adc-b224-8012903a1ef4 May  4 2016
StackToRegisterMappingCogit VMMaker.oscog-eem.1855 uuid: d8e4a3c2-a3bf-4adc-b224-8012903a1ef4 May  4 2016
https://github.com/pharo-project/pharo-vm.git Commit: b8ec25a570d7539653e1d793e97609adb509aaed Date: 2016-05-04 11:14:22 +0200 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #589

Image: Pharo5.0 [Latest update: #50772]

VirtualMachine(Object)>>error:
	Receiver: a VirtualMachine
	Arguments and temporary variables: 
		aString: 	'Not enough space for external objects, set a larger size at startup!'...etc...
	Receiver's instance variables: 
a VirtualMachine

VirtualMachine>>maxExternalSemaphores:
	Receiver: a VirtualMachine
	Arguments and temporary variables: 
		aSize: 	260
	Receiver's instance variables: 
a VirtualMachine

ExternalSemaphoreTable class>>freedSlotsIn:ratherThanIncreaseSizeTo:
	Receiver: ExternalSemaphoreTable
	Arguments and temporary variables: 
		externalObjects: 	an Array(a Semaphore(a Process in InputEventFetcher>>waitForIn...etc...
		newSize: 	260
		maxSize: 	256
		needToGrow: 	false
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#ExternalSemaphoreTable
		classPool: 	a Dictionary(#ProtectAdd->a Semaphore() #ProtectRemove->a Semaphore(...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'System-Support'
		traitComposition: 	{}
		localSelectors: 	nil


ExternalSemaphoreTable class>>collectionBasedOn:withRoomFor:
	Receiver: ExternalSemaphoreTable
	Arguments and temporary variables: 
		externalObjects: 	an Array(a Semaphore(a Process in InputEventFetcher>>waitForIn...etc...
		anObject: 	a Semaphore()
		newObjects: 	nil
		newSize: 	260
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#ExternalSemaphoreTable
		classPool: 	a Dictionary(#ProtectAdd->a Semaphore() #ProtectRemove->a Semaphore(...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'System-Support'
		traitComposition: 	{}
		localSelectors: 	nil


ExternalSemaphoreTable class>>privateRegisterExternalObject:
	Receiver: ExternalSemaphoreTable
	Arguments and temporary variables: 
		anObject: 	a Semaphore()
		objects: 	an Array(a Semaphore(a Process in InputEventFetcher>>waitForInput) a S...etc...
		firstEmptyIndex: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#ExternalSemaphoreTable
		classPool: 	a Dictionary(#ProtectAdd->a Semaphore() #ProtectRemove->a Semaphore(...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'System-Support'
		traitComposition: 	{}
		localSelectors: 	nil


[ self privateRegisterExternalObject: anObject ] in ExternalSemaphoreTable class>>registerExternalObject:
	Receiver: ExternalSemaphoreTable
	Arguments and temporary variables: 
		anObject: 	a Semaphore()
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#ExternalSemaphoreTable
		classPool: 	a Dictionary(#ProtectAdd->a Semaphore() #ProtectRemove->a Semaphore(...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'System-Support'
		traitComposition: 	{}
		localSelectors: 	nil


[ caught := true.
self wait.
blockValue := mutuallyExcludedBlock value ] in Semaphore>>critical:
	Receiver: a Semaphore()
	Arguments and temporary variables: 
		mutuallyExcludedBlock: 	[ self privateRegisterExternalObject: anObject ]
		caught: 	true
		blockValue: 	nil
	Receiver's instance variables: 
		firstLink: 	nil
		lastLink: 	nil
		excessSignals: 	0


BlockClosure>>ensure:
	Receiver: [ caught := true.
self wait.
blockValue := mutuallyExcludedBlock value ]
	Arguments and temporary variables: 
		aBlock: 	[ caught
	ifTrue: [ self signal ] ]
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	Semaphore>>critical:
		startpc: 	42
		numArgs: 	0


Semaphore>>critical:
	Receiver: a Semaphore()
	Arguments and temporary variables: 
		caught: 	true
		blockValue: 	nil
		mutuallyExcludedBlock: 	[ self privateRegisterExternalObject: anObject ]
	Receiver's instance variables: 
		firstLink: 	nil
		lastLink: 	nil
		excessSignals: 	0


ExternalSemaphoreTable class>>registerExternalObject:
	Receiver: ExternalSemaphoreTable
	Arguments and temporary variables: 
		anObject: 	a Semaphore()
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#ExternalSemaphoreTable
		classPool: 	a Dictionary(#ProtectAdd->a Semaphore() #ProtectRemove->a Semaphore(...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'System-Support'
		traitComposition: 	{}
		localSelectors: 	nil


SmalltalkImage>>registerExternalObject:
	Receiver: Smalltalk
	Arguments and temporary variables: 
		anObject: 	a Semaphore()
	Receiver's instance variables: 
		globals: 	a SystemDictionary(lots of globals)
		deferredStartupActions: 	an OrderedCollection()
		specialObjectsArray: 	an Array(nil false true #Processor->Processor Bitmap Small...etc...
		session: 	an Object
		vm: 	a VirtualMachine


Socket>>acceptFrom:
	Receiver: a Socket[destroyed]
	Arguments and temporary variables: 
		aSocket: 	a Socket[connected]
		semaIndex: 	240
		readSemaIndex: 	nil
		writeSemaIndex: 	nil
	Receiver's instance variables: 
		semaphore: 	a Semaphore()
		socketHandle: 	nil
		readSemaphore: 	a Semaphore()
		writeSemaphore: 	a Semaphore()


[ super new acceptFrom: aSocket ] in Socket class>>acceptFrom:
	Receiver: Socket
	Arguments and temporary variables: 
		aSocket: 	a Socket[connected]
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(size 129)
		format: 	65540
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#Socket
		classPool: 	a Dictionary(#Connected->2 #DeadServer->'update.squeakfoundation.org...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Network-Kernel'
		traitComposition: 	{}
		localSelectors: 	nil


BlockClosure>>repeatWithGCIf:
	Receiver: [ super new acceptFrom: aSocket ]
	Arguments and temporary variables: 
		testBlock: 	[ :sock | sock isValid not ]
		ans: 	nil
	Receiver's instance variables: 
		outerContext: 	Socket class>>acceptFrom:
		startpc: 	38
		numArgs: 	0


Socket class>>acceptFrom:
	Receiver: Socket
	Arguments and temporary variables: 
		aSocket: 	a Socket[connected]
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(size 129)
		format: 	65540
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#Socket
		classPool: 	a Dictionary(#Connected->2 #DeadServer->'update.squeakfoundation.org...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Network-Kernel'
		traitComposition: 	{}
		localSelectors: 	nil


Socket>>accept
	Receiver: a Socket[connected]
	Arguments and temporary variables: 

	Receiver's instance variables: 
		semaphore: 	a Semaphore()
		socketHandle: 	#[232 87 205 9 0 0 0 0 240 137 159 0]
		readSemaphore: 	a Semaphore()
		writeSemaphore: 	a Semaphore()


Socket>>waitForAcceptFor:
	Receiver: a Socket[connected]
	Arguments and temporary variables: 
		timeout: 	300
	Receiver's instance variables: 
		semaphore: 	a Semaphore()
		socketHandle: 	#[232 87 205 9 0 0 0 0 240 137 159 0]
		readSemaphore: 	a Semaphore()
		writeSemaphore: 	a Semaphore()


ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>serveConnectionsOn:
	Receiver: a ZnManagingMultiThreadedServer(running 80)
	Arguments and temporary variables: 
		listeningSocket: 	a Socket[connected]
		stream: 	nil
		socket: 	nil
	Receiver's instance variables: 
		options: 	a Dictionary(#delegate->a ZnSeasideStaticServerAdaptorDelegate #maximu...etc...
		sessionManager: 	nil
		process: 	a Process in nil
		serverSocket: 	a Socket[connected]
		logLevel: 	3
		lock: 	a Mutex
		connections: 	an OrderedCollection(a ZdcSocketStream a ZdcSocketStream a ZdcSock...etc...


[ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: block and destroy socket"
self serveConnectionsOn: serverSocket ] in [ [ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: block and destroy socket"
self serveConnectionsOn: serverSocket ] repeat ] in ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>listenLoop
	Receiver: a ZnManagingMultiThreadedServer(running 80)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		options: 	a Dictionary(#delegate->a ZnSeasideStaticServerAdaptorDelegate #maximu...etc...
		sessionManager: 	nil
		process: 	a Process in nil
		serverSocket: 	a Socket[connected]
		logLevel: 	3
		lock: 	a Mutex
		connections: 	an OrderedCollection(a ZdcSocketStream a ZdcSocketStream a ZdcSock...etc...


BlockClosure>>repeat
	Receiver: [ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: bloc...etc...
	Arguments and temporary variables: 

	Receiver's instance variables: 
		outerContext: 	[ [ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will...etc...
		startpc: 	56
		numArgs: 	0


[ [ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: block and destroy socket"
self serveConnectionsOn: serverSocket ] repeat ] in ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>listenLoop
	Receiver: a ZnManagingMultiThreadedServer(running 80)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		options: 	a Dictionary(#delegate->a ZnSeasideStaticServerAdaptorDelegate #maximu...etc...
		sessionManager: 	nil
		process: 	a Process in nil
		serverSocket: 	a Socket[connected]
		logLevel: 	3
		lock: 	a Mutex
		connections: 	an OrderedCollection(a ZdcSocketStream a ZdcSocketStream a ZdcSock...etc...


BlockClosure>>ifCurtailed:
	Receiver: [ [ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: bl...etc...
	Arguments and temporary variables: 
		aBlock: 	[ self releaseServerSocket ]
		complete: 	nil
		result: 	nil
	Receiver's instance variables: 
		outerContext: 	ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>listenLoop
		startpc: 	52
		numArgs: 	0


ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>listenLoop
	Receiver: a ZnManagingMultiThreadedServer(running 80)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		options: 	a Dictionary(#delegate->a ZnSeasideStaticServerAdaptorDelegate #maximu...etc...
		sessionManager: 	nil
		process: 	a Process in nil
		serverSocket: 	a Socket[connected]
		logLevel: 	3
		lock: 	a Mutex
		connections: 	an OrderedCollection(a ZdcSocketStream a ZdcSocketStream a ZdcSock...etc...


[ self listenLoop ] in [ [ self listenLoop ] repeat ] in ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
	Receiver: a ZnManagingMultiThreadedServer(running 80)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		options: 	a Dictionary(#delegate->a ZnSeasideStaticServerAdaptorDelegate #maximu...etc...
		sessionManager: 	nil
		process: 	a Process in nil
		serverSocket: 	a Socket[connected]
		logLevel: 	3
		lock: 	a Mutex
		connections: 	an OrderedCollection(a ZdcSocketStream a ZdcSocketStream a ZdcSock...etc...


BlockClosure>>repeat
	Receiver: [ self listenLoop ]
	Arguments and temporary variables: 

	Receiver's instance variables: 
		outerContext: 	[ [ self listenLoop ] repeat ] in ZnManagingMultiThreadedServer(Z...etc...
		startpc: 	81
		numArgs: 	0


[ [ self listenLoop ] repeat ] in ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
	Receiver: a ZnManagingMultiThreadedServer(running 80)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		options: 	a Dictionary(#delegate->a ZnSeasideStaticServerAdaptorDelegate #maximu...etc...
		sessionManager: 	nil
		process: 	a Process in nil
		serverSocket: 	a Socket[connected]
		logLevel: 	3
		lock: 	a Mutex
		connections: 	an OrderedCollection(a ZdcSocketStream a ZdcSocketStream a ZdcSock...etc...


[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
	Receiver: [ [ self listenLoop ] repeat ]
	Arguments and temporary variables: 

	Receiver's instance variables: 
		outerContext: 	ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
		startpc: 	77
		numArgs: 	0



--- The full stack ---
VirtualMachine(Object)>>error:
VirtualMachine>>maxExternalSemaphores:
ExternalSemaphoreTable class>>freedSlotsIn:ratherThanIncreaseSizeTo:
ExternalSemaphoreTable class>>collectionBasedOn:withRoomFor:
ExternalSemaphoreTable class>>privateRegisterExternalObject:
[ self privateRegisterExternalObject: anObject ] in ExternalSemaphoreTable class>>registerExternalObject:
[ caught := true.
self wait.
blockValue := mutuallyExcludedBlock value ] in Semaphore>>critical:
BlockClosure>>ensure:
Semaphore>>critical:
ExternalSemaphoreTable class>>registerExternalObject:
SmalltalkImage>>registerExternalObject:
Socket>>acceptFrom:
[ super new acceptFrom: aSocket ] in Socket class>>acceptFrom:
BlockClosure>>repeatWithGCIf:
Socket class>>acceptFrom:
Socket>>accept
Socket>>waitForAcceptFor:
ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>serveConnectionsOn:
[ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: block and destroy socket"
self serveConnectionsOn: serverSocket ] in [ [ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: block and destroy socket"
self serveConnectionsOn: serverSocket ] repeat ] in ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>listenLoop
BlockClosure>>repeat
[ [ serverSocket isValid
	ifFalse:
		[ ^ self listenLoop ].
"will trigger #ifCurtailed: block and destroy socket"
self serveConnectionsOn: serverSocket ] repeat ] in ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>listenLoop
BlockClosure>>ifCurtailed:
ZnManagingMultiThreadedServer(ZnMultiThreadedServer)>>listenLoop
[ self listenLoop ] in [ [ self listenLoop ] repeat ] in ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
BlockClosure>>repeat
[ [ self listenLoop ] repeat ] in ZnManagingMultiThreadedServer(ZnSingleThreadedServer)>>start
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
-------------------------------------------------------------------------------