"

 COPYRIGHT (c) 1991 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.

"

Array subclass:#WeakArray

	instanceVariableNames:'dependents'

	classVariableNames:'RegistrationFailedSignal AlreadyInitialized'

	poolDictionaries:''

	category:'Collections-Arrayed'

!

!WeakArray class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1991 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.

"

!

documentation

"

    WeakArrays can be used to trace disposal of objects; in contrast to other

    objects, references by WeakArrays will NOT keep an object from being

    garbage collected.

    Instead, whenever an object kept in a WeakArray dies, its entry is zeroed,

    and the WeakArray is informed by the storage manager. The WeakArray itself

    WeakArrays are used to track disposal of objects which keep external

    world resources. For example, FileStreams must close their underlying

    file when disposed (otherwise you could run out of OS filedescriptors).

    This can be done by keeping the FileStream objects in a weakArray, and

    keep a parallel array of filedescriptors. Whenever a fileStream is

    freed, search both arrays for an index where the stream is zero, but the

    filedescriptor is non-nil. Then close that file, and nil the filedescriptor

    entry. Notice, that there is a class (Registry) which does exactly this in

    a more programmer friendly way.

    Another application is caching of data: keep it in a weakArray, so the

    data in that cache will not be unreclaimable due to being cached.

    (for example, the ResourcePack class uses a WeakArray to cache recently

     used resource data for a while).

    The way in which weakArrays get informed by the runtime system is via

    an interrupt (DisposeInterrupt) which is first sent to the disposeHandler

    (typically ObjectMemory). ObjectMemory then takes the required steps to

    notify all weakArrays via the #lostPointer message.

    The reason for not sending messages directly from the VM is to make it 

    possible to run the finalization code at lower priority or from another class. 

    Also, as a side effect, it is possible to delay finalization by blocking 

    A weakArray notifies its dependents via normal dependency notfications.

    [hint:] 

    As a possible option, we could perform the weakArray scanning only in

    the oldSpace reclamation code - this would remove most of the overhead,

    but will lead to much longer delayed finalization .... we will see.

    [instance variables:]

    [class variables:]

    [author:]

    [See also:]

"

! !

!WeakArray class methodsFor:'initialization'!

initialize

    "setup the private signal"

    RegistrationFailedSignal isNil ifTrue:[

	RegistrationFailedSignal := ErrorSignal newSignalMayProceed:true.

	RegistrationFailedSignal nameClass:self message:#registrationFailedSignal.

	RegistrationFailedSignal notifierString:'weakArray registration failed'.

    ]

! !

!WeakArray class methodsFor:'instance creation'!

new:size

    "return a new weakArray with size slots"

     initialize method, but (currently) the order in which the class-initialize

     methods are called is not defined ...

     ... therefore it could happen, that a WeakArray is used by other

     classes initialize method BEFORE this method is evaluated. 

     To avoid this, the WEAK bit in the class is set here, when the very first 

    AlreadyInitialized isNil ifTrue:[

    ].

    ^ (self basicNew:size) registerAsWeakArray

! !

!WeakArray methodsFor:'GC registration'!

registerAsWeakArray

    "register the receiver in the VM - 

     i.e. tell the VM to nil disposed entries in the receiver

     and notify the disposeInterruptHandler whenever that happened."

    |ok|

%{

    OBJ __addShadowObject();

    ok = __addShadowObject(self, 0);

    if (ok == false) {

    }

%}.

    ok ifFalse:[

    ]

! !

!WeakArray methodsFor:'accessing'!

at:index

    "return the indexed instance variable with index, anInteger.

    ^ self basicAt:index

!

basicAt:index

    "return the indexed instance variable with index, anInteger.

%{  /* NOCONTEXT */

    REGISTER int indx;

    REGISTER unsigned int nIndex;

    OBJ el;

    if (__isSmallInteger(index)) {

    }

%}.

    ^ super basicAt:index

!

dependents 

    "return the dependents of the receiver"

    ^ dependents

!

dependents:aCollection

    "set the dependents of the receiver"

    dependents := aCollection

! !

!WeakArray methodsFor:'copying'!

postCopy

    "copying alone does not really help - we have to tell

     the VM, that there is a new WeakArray around ...

     Q: who copies weakArrays ?"

    dependents := nil.

    self registerAsWeakArray.

! !

!WeakArray methodsFor:'enumerating'!

do:aBlock

    "evaluate the argument, aBlock for each element in the collection.

     - reimplemented for IGC readBarrier. 

     You dont have to understand this."

%{

    REGISTER int index;

    unsigned int nIndex;

    static struct inlineCache val = _ILC1;

    index = __intVal(__ClassInstPtr(__qClass(self))->c_ninstvars);

    nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);

    if (__isBlockLike(aBlock)

     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {

	{

	    /*

	     * the most common case: a static compiled block, with home on the stack ...

	     */

	    REGISTER OBJFUNC codeVal;

	    if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)

	     && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))) {

#ifdef NEW_BLOCK_CALL

#               define BLOCK_ARG        aBlock

#else

#               define BLOCK_ARG        rHome

		REGISTER OBJ rHome;

		rHome = __BlockInstPtr(aBlock)->b_home;

		if ((rHome == nil) || (__qSpace(rHome) >= STACKSPACE)) 

#endif

		{

		    for (; index < nIndex; index++) {

			OBJ element;

			if (InterruptPending != nil) __interruptL(@line);

			element = __InstPtr(self)->i_instvars[index];

			if (__isNonNilObject(element)) element = __WEAK_READ__(self, element);

			(*codeVal)(BLOCK_ARG, element);

		    }

		    RETURN (self);

		}

	    }

	}

	/*

	 * sorry, must check code-pointer in the loop

	 * it could be recompiled or flushed

	 */

#       undef BLOCK_ARG

#ifdef NEW_BLOCK_CALL

#       define BLOCK_ARG        aBlock

#       define IBLOCK_ARG       nil

#else

#       define BLOCK_ARG        (__BlockInstPtr(aBlock)->b_home)

#       define IBLOCK_ARG       (__BlockInstPtr(aBlock)->b_home)

#endif

	for (; index < nIndex; index++) {

	    REGISTER OBJFUNC codeVal;

	    OBJ element;

	    if (InterruptPending != nil) __interruptL(@line);

	    element = __InstPtr(self)->i_instvars[index];

	    if (__isNonNilObject(element)) element = __WEAK_READ__(self, element);

	    if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {

		(*codeVal)(BLOCK_ARG, element);

	    } else {

		if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {

		    /*

		     * arg is a compiled block with bytecode -

		     * directly call interpreter without going through Block>>value

		     */

#ifdef PASS_ARG_POINTER

		    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &element);

#else

		    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, element);

#endif

		} else {

		    /*

		     * arg is something else - call it with #value

		     */

		    (*val.ilc_func)(aBlock, @symbol(value:), nil, &val, element);

		}

	    }

	} 

	RETURN (self);

#       undef BLOCK_ARG

#       undef IBLOCK_ARG

    }

    /*

     * not a block - send it #value:

     */

    for (; index < nIndex; index++) {

	OBJ element;

	if (InterruptPending != nil) __interruptL(@line);

	element = __InstPtr(self)->i_instvars[index];

	if (__isNonNilObject(element)) element = __WEAK_READ__(self, element);

	(*val.ilc_func)(aBlock, 

			    @symbol(value:), 

			    nil, &val, 

			    element);

    }

%}.

    ^ self

!

forAllDeadIndicesDo:aBlock

    "evaluate the argument, aBlock for all indices where elements have been

    self keysAndValuesDo:[:index :element |

    ]

!

forAllDeadIndicesDo:aBlock replacingCorpsesWith:newValue

    "evaluate the argument, aBlock for all indices where elements have been

     replaced by zero (due to a collected object), and replace the element

     with newValue.

     In the current implementation, the block sees the newValue (i.e. it is

     changed before the block is called); this behavior is not guaranteed

    self keysAndValuesDo:[:index :element |

    ]

!

nilAllCorpsesAndDo:aBlock

    "evaluate the argument, aBlock for all indices where elements have been

     cleared (due to a collected object), nil the entry."

    self forAllDeadIndicesDo:aBlock replacingCorpsesWith:nil

!

nonNilElementsDo:aBlock

    "evaluate the argument, aBlock for each non-nil element"

%{

    REGISTER int index;

    int nIndex;

    static struct inlineCache val = _ILC1;

    index = __intVal(__ClassInstPtr(__qClass(self))->c_ninstvars);

    nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);

    if (__isBlockLike(aBlock)

     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {

	{

	    /*

	     * the most common case: a static compiled block, with home on the stack ...

	     */

	    REGISTER OBJFUNC codeVal;

	    if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)

	     && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))) {

#ifdef NEW_BLOCK_CALL

#               define BLOCK_ARG        aBlock

#else

#               define BLOCK_ARG        rHome

		REGISTER OBJ rHome;

		rHome = __BlockInstPtr(aBlock)->b_home;