Processes

Smalltalk allows multiple lightweight processes (also called threads or tasks) to execute pseudo concurrently. These run within the same address space (inside a single heavy weight operating system process) and can communicate via shared objects. Process scheduling is priority driven, with preemptive time slicing (multitasking) within each priority level. Scheduling is implemented fully in Smalltalk (i.e. all algorithms are open and can be changed if there is a need to do so).

Each process has its own automatically growing stack which is protected against overflow. No stack size definition is needed at process creation time - the system will allocate additional stack memory in reasonable small increments. The algorithm is a so called "segmented spaghetti stack", consisiting of chains of stack segments. Stack overflow is signalled as an exception and can be cought (see ``Exceptions and Signals'') and handled gracefully. It is even possible to restart or continue with more stack space after such an exception.

Also, multiple processes can be debugged simulatiously (using the symbolic Debugger) - even while executing concurrently. This means, that other processes continue to execute while other processes may be debugged.

The windowing interface makes use of processes, by executing each toplevel view's application in a separate process (the so called "Windowgroup Process". This means, that other windows are not locked up by one window being debugged or busy (which would be the case in pure event driven systems).

The interesting classes are:

• Process - represents a Smalltalk process (thread)
• ProcessorScheduler - the scheduler
• Semaphore and RecursionLock - for mutual access and process synchronization
• Delay - for timing operations
• OSProcess - represents a process of the pperating system (executed program)

Process

• creation:

      aBlock fork
  
  
      aBlock forkNamed:aString
  
  
      aBlock forkAt:priority
  
  
      aBlock newProcess
  
  
  

• accessing:

      aProcess priority
  
  
      aProcess state
  
  
      aProcess id
  
  
      aProcess name
  
  
  

• scheduler control:

      aProcess priority:newPriority
  
  
      aProcess priorityRange:priorityInterval
  
  
      aProcess suspend
  
  
      aProcess resume
  
  
      aProcess terminate
  
  
      aProcess interruptWith:aBlock
  

Details are found in the "Process class documentation".

ProcessorScheduler

The basic scheduling is preemptive priority based. Preemptive means that a process may be suspended and resumed at any time as determined by the runnable state of higher priority processes. No cooperation (explicit yield) is required to be programmed into the code to give up control.

Time slicing (multi tasking) is done by a high-prio timeslicer process, which assigns time slots within a priority group in a round robin fashion. Thus, other processes within that priority group are able to make progress, even if a single process performs a long running operation.

Typical messages sent to Processor:

• queries:

      Processor activeProcess
  
  
      Processor activePriority
  
  
      Processor userSchedulingPriority
  
  
      Processor userBackgroundPriority
  

• scheduling:

      Processor terminateActive
  
  
      Processor yield
  
  
      Processor suspend:aProcess
  
  
      Processor resume:aProcess
  

More details are found in the "ProcessorScheduler class documentation".

Semaphore and RecursionLock

Notice that a critical region semaphore may be only only entered once, even if the aquiring process already owns it. This may lead to deadlocks or difficult coding style if your code is recursive or is entering the critical region in multiple places. For that, a so called RecursionLock is provided. This behaves like a Semaphore, except for the re-entering situation. It allows for the one process which already owns the lock, to reenter a critical region.

Typical use:

• creation:

      Semaphore new
  
      Semaphore forMutualExclusion
  
      RecursionLock new
  
  
  

• wait & signal:

      aSemaphore wait
  
  
      aSemaphore waitWithTimeOut:seconds
  
  
      aSemaphore signal
  
  
      aSemaphore wouldBlock
  
  
  

• critical regions (must be a Semaphore forMutualExclusion or a RecursionLock):

      aSemaphoreOrRecursionLock critical:[ ... criticalBlock ...]
  
  
  

• I/O triggering (low level):

      Processor signal:aSemaphore onInput:fileDescriptor
  
  
      Processor signal:aSemaphore onOutput:fileDescriptor
  
  
  

• timer triggering (low level):

      Processor signal:aSemaphore afterSeconds:numberOfSeconds
  

More details are found in the "Semaphore" or "RecursionLock" class documentation.

Delay

(Delay forSeconds:numberOfSeconds) wait


(Delay forMilliseconds:numberOfMilliseconds) wait


Delay waitForSeconds:numberOfSeconds


Delay waitForMilliseconds:numberOfMilliseconds


Delay waitUntil:aTimestamp

More details are found in the "Delay class documentation".

Copyright © 1996 Claus Gittinger Development & Consulting