hg/stx-libbasic: comparison Process.st

equal deleted inserted replaced

-:e0e720fce465
+:a680abc90e84
 !
 documentation
 "
 WARNING:
-	the offsets of the instance variables lookupActivations and lookupDisabled are known in the VM
+the offsets of the instance variables lookupActivations and lookupDisabled are known in the VM
-	do not remove them, and do not insert/remove instance variables before them
+do not remove them, and do not insert/remove instance variables before them
 Instances of Process represent lightweight smalltalk processes
 (i.e. threads). These all run in a shared smalltalk/X address space,
 and can thus access and communicate via any objects.
 Do not confuse these with (heavy-weight) unix processes, which are
 Leaving the processes startBlock has the same effct as a soft-terminate
 (i.e. there is no need to send an explicit terminate).
 Notice:
-	in Smalltalk/X, processes are gone, when an image is restarted;
+in Smalltalk/X, processes are gone, when an image is restarted;
-	this means, that you have to take care of process re-creation yourself.
+this means, that you have to take care of process re-creation yourself.
-	Usually, this is done by depending on ObjectMemory, recreating the
+Usually, this is done by depending on ObjectMemory, recreating the
-	process(es) when the #returnFromSnapshot-change notifiction arrives.
+process(es) when the #returnFromSnapshot-change notifiction arrives.
-	All views (actually windowGroups) recreate their window process
+All views (actually windowGroups) recreate their window process
-	on image-restart. You have to do so manually for your own processes.
+on image-restart. You have to do so manually for your own processes.
 A later version will allow specification of automatic restart, but
 that's not yet implemented. However, even when implemented, restartable processes
 will be recreated to restart from the beginning. It will not be possible to
 automatically continue a processes execution where it left off.
 this has not been implemented, since the machines stack layout is highly machine/compiler
 dependent, thus leading to much bigger porting effort of ST/X (which conflicts
 with ST/X's design goal of being highly portable).
 Process synchronization:
-	Synchronization with cooperating processes is supported as usual,
+Synchronization with cooperating processes is supported as usual,
-	via Semaphores (see Semaphore, Delay, SharedQueue etc.)
+via Semaphores (see Semaphore, Delay, SharedQueue etc.)
-	With uncooperative processes, only synchronization on suspend
+With uncooperative processes, only synchronization on suspend
-	and termination is possible:
+and termination is possible:
-	  any other process can wait for a process to suspend or terminate.
+any other process can wait for a process to suspend or terminate.
-	  This waiting is implemented by using suspendSemaphore and exitBlocks
+This waiting is implemented by using suspendSemaphore and exitBlocks
-	  (where an exitSemaphore is signalled).
+(where an exitSemaphore is signalled).
-	  See waitUntilSuspended / waitUntilTerminated.
+See waitUntilSuspended / waitUntilTerminated.
+Implementation note:
+for historic and compatibility reasons, Process is a subclass of Link,
+which means, that instances are directly usable as nodes in a linkedList.
+However, this also means, that processes can only be elements of a single LinkedList.
+This is somewhat dangerous, as unknowledgable programmers may unwillingly break the
+scheduler, by placing a process onto another linked list.
+Therefore, we plan to change this in the future.
 Process states:
-	#dead           process has (been) terminated;
+#dead           process has (been) terminated;
-			the process instance has no underlting
+the process instance has no underlting
-			thread.
+thread.
-	#run            the process is willing to run,
+#run            the process is willing to run,
-			but not active (i.e. another higher prio
+but not active (i.e. another higher prio
-			process is currently executing)
+process is currently executing)
-	#active         the process is the current process
+#active         the process is the current process
-			(there is only one)
+(there is only one)
-	#ioWait         waiting on some io-related semaphore
+#ioWait         waiting on some io-related semaphore
-			(typically in #readWait / #writeWait)
+(typically in #readWait / #writeWait)
-	#eventWait      waiting on some GUI event
+#eventWait      waiting on some GUI event
-	#timeWait       waiting on a timer-related semaphore
+#timeWait       waiting on a timer-related semaphore
-	#wait           waiting on some (other) semaphore
+#wait           waiting on some (other) semaphore
-	#suspended      stopped from execution; however, an interrupt
+#suspended      stopped from execution; however, an interrupt
-			will return it into the run state.
+will return it into the run state.
-	#stopped        stopped from execution; an interrupt will
+#stopped        stopped from execution; an interrupt will
-			NOT return it into the run state (for debugging)
+NOT return it into the run state (for debugging)
-	#debug          debugger sitting on top of the processes
+#debug          debugger sitting on top of the processes
-			stack.
+stack.
 Win32 only:
-	#osWait         waiting on an OS-API call to finish.
+#osWait         waiting on an OS-API call to finish.
-			can be interrupted, terminated and aborted
+can be interrupted, terminated and aborted
-			(i.e. the usual context actions are is possible).
+(i.e. the usual context actions are is possible).
-	#halted         thread was caught while in a blocking API call
+#halted         thread was caught while in a blocking API call
-			or primitive endless loop and has been halted by
+or primitive endless loop and has been halted by
-			the scheduler.
+the scheduler.
-			Can only be resumed or hard-terminated - abort
+Can only be resumed or hard-terminated - abort
-			or soft terminate or unwind actions are not possible.
+or soft terminate or unwind actions are not possible.
-			(due to win32 limitations)
+(due to win32 limitations)
 [Instance variables:]
-	id                     <SmallInteger>   a unique process-id
+id                     <SmallInteger>   a unique process-id
-	creatorId              <SmallInteger>   the id of the process that
+creatorId              <SmallInteger>   the id of the process that
-						created me (useful for debugging
+created me (useful for debugging
-						or monitoring).
+or monitoring).
-	processGroupId                          usually the id of the creator,
+processGroupId                          usually the id of the creator,
-						unless the process detached from
+unless the process detached from
-						the group and became a groupLeader.
+the group and became a groupLeader.
-						Groups can be easily terminated
+Groups can be easily terminated
-						as a whole.
+as a whole.
-						Group leaders have a groupId of nil.
+Group leaders have a groupId of nil.
-						A groupId of 0 (zero) marks a system
+A groupId of 0 (zero) marks a system
-						process; these do not prevent a standAlone
+process; these do not prevent a standAlone
-						app from exiting.
+app from exiting.
-	prio                   <SmallInteger>   the processes priority
+prio                   <SmallInteger>   the processes priority
-	priorityRange          <Interval>       the processes dynamic priority range
+priorityRange          <Interval>       the processes dynamic priority range
-						(or nil)
+(or nil)
-	state                  <Symbol>         the processes state
+state                  <Symbol>         the processes state
-						(for process-monitor)
+(for process-monitor)
-	startBlock             <Block>          the startup-block (the one that forked)
+startBlock             <Block>          the startup-block (the one that forked)
-	name                   <String-or-nil>  the processes name (if any)
+name                   <String-or-nil>  the processes name (if any)
-						(for process-monitor)
+(for process-monitor)
-	suspendSemaphore       <Semaphore>      triggered when suspend (if nonNil)
+suspendSemaphore       <Semaphore>      triggered when suspend (if nonNil)
-	restartable            <Boolean>        is restartable; if true, the process
+restartable            <Boolean>        is restartable; if true, the process
-						will be restarted when an image is
+will be restarted when an image is
-						restarted. Otherwise, it remains dead.
+restarted. Otherwise, it remains dead.
-						Running processes cannot be continued
+Running processes cannot be continued
-						at the point where leftOff after an
+at the point where leftOff after an
-						image-restart.
+image-restart.
-	interruptActions       <Collection>     interrupt actions as defined by interruptWith:,
+interruptActions       <Collection>     interrupt actions as defined by interruptWith:,
-						performed at interrupt time
+performed at interrupt time
-	exitActions            <Collection of Block>
+exitActions            <Collection of Block>
-						additional cleanup actions to perform
+additional cleanup actions to perform
-						on termination (if nonEmpty)
+on termination (if nonEmpty)
-	emergencySignalHandler <Block>          can be used for per-process
+emergencySignalHandler <Block>          can be used for per-process
-						emergency signal handling
+emergency signal handling
-	interruptsDisabled     <Boolean>        flag if interrupts (as installed
+interruptsDisabled     <Boolean>        flag if interrupts (as installed
-						via #interruptWith:) are currently
+via #interruptWith:) are currently
-						disabled. (i.e. on-hold).
+disabled. (i.e. on-hold).
-						Interrupts will be delivered when
+Interrupts will be delivered when
-						reenabled.
+reenabled.
-	exceptionHandlerSet    <ExceptionhandlerSet>
+exceptionHandlerSet    <ExceptionhandlerSet>
-						Handled by any process; allows for
+Handled by any process; allows for
-						exceptionHandlers and query-answerers to
+exceptionHandlers and query-answerers to
-						be added/removed dynamically.
+be added/removed dynamically.
 [Class variables:]
-	TerminateSignal         <Signal>        signal used to terminate processes
+TerminateSignal         <Signal>        signal used to terminate processes
-						(should not be caught - or at least
+(should not be caught - or at least
-						 rejected in handlers).
+rejected in handlers).
-						If caught and proceeded, a process
+If caught and proceeded, a process
-						cannot be terminated via #terminate.
+cannot be terminated via #terminate.
-						For hardTermination (in case of emergency),
+For hardTermination (in case of emergency),
-						send it a #erminateNoSignal message.
+send it a #erminateNoSignal message.
-	RestartSignal           <Signal>        signal used to restart a process.
+RestartSignal           <Signal>        signal used to restart a process.
-						Can be caught in additional handler(s),
+Can be caught in additional handler(s),
-						to perform all kind of re-initialization.
+to perform all kind of re-initialization.
-						However, these handlers should reject,
+However, these handlers should reject,
-						for the restart to be really performed.
+for the restart to be really performed.
 [see also:]
-	ProcessorScheduler
+ProcessorScheduler
-	Block
+Block
-	Sempahore SemaphoreSet Delay SharedQueue
+Sempahore SemaphoreSet Delay SharedQueue
-	WindowGroup
+WindowGroup
-	(``Working with processes'': programming/processes.html)
+(``Working with processes'': programming/processes.html)
 [author:]
-	Claus Gittinger
+Claus Gittinger
 "
 !
 examples
 ^ self interruptWith:aBlock
 "Created: 15.11.1996 / 11:41:06 / cg"
 ! !
 !Process methodsFor:'accessing'!
 beGUIProcess
 "mark the receiver as a gui process.
 "Modified: 28.10.1996 / 20:42:00 / cg"
 "Created: 28.10.1996 / 20:44:07 / cg"
 ! !
 !Process methodsFor:'thread local storage'!
 environment
 "return the dictionary holding thread local variables, or nil if there are none"

branch	jv
changeset 20078	a680abc90e84
parent 19863	513bd7237fe7
parent 19969	654d2e1a2dc4
child 20081	2961b4289773