"

 COPYRIGHT (c) 1992 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Link subclass:#Process

         instanceVariableNames:'id prio state startBlock name 

                                restartable pushedInterruptActions exitAction'

         classVariableNames:''

         poolDictionaries:''

         category:'Kernel-Processes'

!

Process comment:'

COPYRIGHT (c) 1992 by Claus Gittinger

             All Rights Reserved

'!

!Process class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1992 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

version

"

$Header: /cvs/stx/stx/libbasic/Process.st,v 1.12 1994-06-02 16:21:26 claus Exp $

"

!

documentation

"

    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. Processes are

    typically created by sending #fork or #forkAt: to a block.

    Scheduling is done by processor, which is the sole instance of 

    ProcessorScheduler.

"

! !

!Process methodsFor:'accessing'!

state

    "return a symbol describing the processes state"

    ^ state

!

state:aSymbol

    "set the state - only to be used from scheduler"

    state := aSymbol

!

startBlock:aBlock

    "set the receivers startup block"

    startBlock := aBlock

!

priority

    "return the receivers priority"

    ^ prio

!

priority:aNumber

    "set my priority"

    Processor changePriority:aNumber for:self

!

setPriority:aNumber

    "set priority without telling processor - no public use"

    prio := aNumber

!

id

    "return the processes id"

    ^ id

!

name

    "return the processes name"

    ^ name

!

name:aString

    "set the processes name"

    name := aString

!

nameOrId

    "return a string to identify the process - either name or id"

    name notNil ifTrue:[^ name].

    ^ id printString

!

exitAction

    "return the processes exit action"

    ^ exitAction

!

exitAction:aBlock

    "set the processes exit action"

    exitAction := aBlock

!

suspendedContext

    "return the processes suspended context"

%{  /* NOCONTEXT */

    extern OBJ __threadContext();

    OBJ i;

    if (_isSmallInteger(i = _INST(id))) {

        RETURN (__threadContext(_intVal(i)));

    }

%}

.

    ^ nil

!

usedStackSize

    "for monitoring only: return the processes current stack size.

     This method is for monitoring purposes only."

%{  /* NOCONTEXT */

    extern int __threadUsedStackSize();

    OBJ i;

    if (_isSmallInteger(i = _INST(id))) {

        RETURN( _MKSMALLINT(__threadUsedStackSize(_intVal(i))) );

    }

%}

.

    ^ nil

!

totalStackSize

    "return the processes maximum used so far stack size.

     This method is for monitoring purposes only."

%{  /* NOCONTEXT */

    extern int __threadTotalStackSize();

    OBJ i;

    if (_isSmallInteger(i = _INST(id))) {

        RETURN( _MKSMALLINT(__threadTotalStackSize(_intVal(i))) );

    }

%}

.

    ^ nil

!

maximumStackSize

    "returns the processes stack limit - i.e. it will be 

     interrupted with a recursionSignal-raise, if it ever

     needs more stack (in bytes) than this number"

%{  /* NOCONTEXT */

    extern int __threadMaxStackSize();

    OBJ i;

    if (_isSmallInteger(i = _INST(id))) {

        RETURN( _MKSMALLINT(__threadMaxStackSize(_intVal(i))) );

    }

%}

.

    ^ nil

!

setMaximumStackSize:limit

    "sets the processes stack limit - i.e. it will be

     interrupted with a recursionSignal-raise, if it ever

     needs more stack (in bytes) than this number.

     Returns the old value."

%{  /* NOCONTEXT */

    extern int __threadSetMaxStackSize();

    OBJ i;

    if (_isSmallInteger(i = _INST(id)) 

     && _isSmallInteger(limit) ) {

        RETURN ( _MKSMALLINT(__threadSetMaxStackSize(_intVal(i), _intVal(limit))) );

    }

%}

.

    ^ nil

! !

!Process methodsFor:'private scheduler access'!

setId:aNumber

    "set the processes id"

    id := aNumber

! !

!Process methodsFor:'suspend / resume'!

suspend

    "suspend the receiver process - will continue to run when a resume is sent"

    Processor suspend:self

!

resume

    "resume the receiver process"

    Processor resume:self

!

terminate

    "terminate the receiver process"

    Processor terminate:self

! !

!Process methodsFor:'special'!

interruptWith:aBlock

    "interrupt the receiver and make it evaluate aBlock.

     If the receiver is currently suspended, the block will be remembered

     to be evaluated once the receiver wakes up"

    OperatingSystem blockInterrupts.

    pushedInterruptActions isNil ifTrue:[

        pushedInterruptActions := OrderedCollection with:aBlock.

        Processor scheduleForInterrupt:self

    ] ifFalse:[

        pushedInterruptActions addLast:aBlock.

    ].

    OperatingSystem unblockInterrupts.

! !

!Process methodsFor:'printing'!

printOn:aStream

    aStream nextPutAll:state article;

            space;

            nextPutAll:state;

            nextPutAll:' Process (';

            nextPutAll:self nameOrId;

            nextPutAll:')'

! !