"

 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.

"

Object subclass:#ObjectMemory

       instanceVariableNames:''

       classVariableNames:'InternalErrorHandler UserInterruptHandler TimerInterruptHandler

			   SpyInterruptHandler StepInterruptHandler ExceptionInterruptHandler

			   ErrorInterruptHandler MemoryInterruptHandler SignalInterruptHandler

			   ChildSignalInterruptHandler DisposeInterruptHandler

			   RecursionInterruptHandler IOInterruptHandler

			   CustomInterruptHandler

			   AllocationFailureSignal LowSpaceSemaphore

			   IncrementalGCLimit

			   Dependents

			   ImageName'

       poolDictionaries:''

       category:'System-Support'

!

ObjectMemory comment:'

COPYRIGHT (c) 1992 by Claus Gittinger

	     All Rights Reserved

'!

!ObjectMemory 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

"

"

!

documentation

"

    This class contains access methods to the system memory -

    in previous versions this stuff used to be in the Smalltalk class.

    It has been separated for better overall structure.

    Many methods here are for debuging purposes only, and not standard.

    Do not depend on them being there - some may vanish ...

    (especially those, that depend on a specific GC implementation)

    kludge:

    The InterruptHandler variables are known by the runtime system -

    they are the objects that get an interrupt message when the event

    occurs.

    ClassVariables:

	InternalErrorHandler            gets informed (by VM), when some runtime

					error occurs (usually fatal)

	UserInterruptHandler            gets informed (by VM) when CNTL-C is pressed

	TimerInterruptHandler           gets alarm timer interrupts (from VM)

	SpyInterruptHandler             another alarm timer (from VM)

	StepInterruptHandler            gets single step interrupts (from VM)

	ExceptionInterruptHandler       gets floating point exceptions (from VM)

	ErrorInterruptHandler           gets graphic device errors (from VM)

	MemoryInterruptHandler          gets soon-out-of-memory conditions (from VM)

	SignalInterruptHandler          gets unix signals (from VM)

	ChildSignalInterruptHandler     gets child death signals (from VM)

	DisposeInterruptHandler         gets informed, when an object is disposed from 

					a shadowArray (from VM)

	RecursionInterruptHandler       gets recursion limit violations (from VM)

	IOInterruptHandler              gets SIGIO unix signals (from VM)

	CustomInterruptHandler          gets custom interrupts (from VM)

	AllocationFailureSignal         signal raised when a new fails (see Behavior)

	IngrementalGCLimit              number of bytes, that must be allocated since

					last full garbage collect to turn on incremental

					collector.

	Dependents                      keep my dependents locally (its faster) for

					all those registries

"

!

caching

"

    The system uses various caches to speed up method-lookup.

    Currently, there is a three-level cache hierarchy:

	inline-cache            keeps the target of the last send at the caller-

				side (i.e. every send goes through its private 

				1-slot inline-cache, where the address of the last

				called function at this call location is kept.)

	polymorph-inline-cache  keeps a limited list of all targets ever reched 

				at this call location. The list is flushed if it 

				grows too large or the total number of poly-chache

				entries exceeds a limit.

	method-lookup-cache     a global cache. Hashes on class-selector pairs,

				returning the target method.

    Whenever methods are added or removed from the system, or the inheritance 

    hierarchy changes, some or all caches have to be flushed.

"

!

interrupts

"

    Handling of interrupts (i.e. unix-signals) is done via handler objects, which

    get a #XXXInterrupt-message sent. This is more flexible than (say) signalling

    a semaphore, since the handler-object may do anything to react on the signal

    (of course, it can also signal a semaphore to emulate the above behavior).

    Typically, the handlers are set during early initialization of the system

"

!

garbageCollection

"

    Currently, Smalltalk/X uses a two-level memory hierachy.

    Objects are created in a so-called newSpace, which is relatively small.

    full. Scavenging means, that all still-live objects (i.e. referenced by some 

    other) are copied over to another memory area, leaving all unreferenced

    Scavenging occurs automatically, and is usually done fast enough to go 

    unnoticed (typically, it takes some 5 to 50ms to perform a scavenge, 

    depending on how many live objects are in the newspace).

    Interrestingly, the scavenger performs better, if many garbage objects

    are to be reclaimed, since less object-copying has to be done. Therefore,

    the best case scavenge times are almost zero, if there is only garbage in

    the newSpace, while the worst case is when all newSpace objects are still

    living. To honor this situation, the systems uses an adaptive tenure-count,

    which adjusts the number of scavenges needed for tenure according to the

    fill-grade of the newSpace.

    To reclaim oldspace, the system uses three algorithms: mark&sweep, a copying

    (and compressing) baker-type collector and an incremental mark&sweep.

    The mark&sweep runs whenever the oldspace becomes full, putting dead objects

    onto a free list. If a memory request cannot be served from this freelist,

    and the total size of objects on the freelist exceeds a threshold, the system

    will compress the oldspace to make the free-space into one big area.

    Since a compressing oldspace collect leads to a noticable pause of the system,

    the memory manager tries hard to avoid oldspace compression.

    The incremental mark&sweep runs in the background, whenever the system is idle

    (see ProcessorSceduler>>waitForEventOrTimeout). Like the normal mark&sweep,

    this incremental collector follows object references and marks reachable objects

    on its way. This is done 'a few objects-at-a-time', to not disrupt the system

    noticable. Incremental collection is controlled by the variable 

    if the total space used by objects allocated since the last full collect exceeds 

    this number. Its default is set in ObjectMemory>>initialize and can be changed in

    your startup 'smalltalk.rc'-file. Setting it to nil will turn incremental GC off.

    Example 1: 

      you are about to allocate a huge data structure, which is known to

      survive long. In this case, it is better to have these objects move into the

      oldspace sooner, to avoid the copying overhead during scavenges.

      To do this, you can call ObjectMemory>>tenure after allocation, which

      forces all new-objects immediately into the oldspace. 

      Make certain, that not to many (ideally no) short-living objects are in the

      newspace when doing this.

      Another alternative is to tell the system that all allocation should be

      done directly in the oldspace. This completely avoids the scavenging overhead

      for these objects. To do so, use ObjectMemory>>turnGarbageCollectorOff

      before the allocation, and ObjectMemory>>turnGarbageCollectorOn afterwards.

      so there is a danger of making things worse due to having all those temporaries

      in the oldspace afterwards. (which is not a fatal situation, but will

      force the system to do an oldspace collect earlier, which may not be your

      intention).

   Example 2:

      you know in advance, that a certain (big) amount of memory will be needed.

      For example, the fileBrowser wants to show a huge file in its text-view.

      In this case, it is better to tell the memory system in advance, how much

      memory will be needed, since otherwise many compresses and reallocations will

      occur (the memory system will allocate additional memory in chunks of smaller

      256k pieces, if a compress failes. Thus, if you are going to allocate (say) 1Mb of 

      strings, it will perform 5 compressing GC's).

      avoids those annoying 5 compressing GC's.

      (BTW: if you have other smalltalk processes (threads) running, it is better

       processes and sometimes succeeds, while moreOldSpace will always block

       the whole system for a while).

      The amount of automatic increase (in case the oldSpace becomes full) is 256k by

      default. This number can be changed with ObjectMemory>>oldSpaceIncrement:.

    Example3:

      There are rare cases, when an explicit GC makes a difference: since

      object finalization is done at GC time, objects which keep operatingSystem

      resources may be finalized late. This is normally no problem, except if

      the system is running out of resources. For example, allocating new colors

      may fail if many colors have already been allocated in the past - even

      though these colors are actually free. The Depth8Image calls for an

      explicit GC, whenever it fails to allocate a color for a bitmap, to force

      finalization of free, but not yet finalized colors.

    Warning: many of these methods are not standard and may not even be available in

    future versions of ST/X. Use them only in very special situations or experiments.

"

! !

!ObjectMemory class methodsFor:'initialization'!

initialize

    "initialize the class"

    AllocationFailureSignal isNil ifTrue:[

	Object initialize.

	AllocationFailureSignal := Object errorSignal newSignalMayProceed:true.

	AllocationFailureSignal nameClass:self message:#allocationFailureSignal.

	AllocationFailureSignal notifierString:'allocation failure'.

	LowSpaceSemaphore := Semaphore new.

    ].

    IncrementalGCLimit := 500000.

    MemoryInterruptHandler := self

! !

!ObjectMemory class methodsFor:'signal access'!

allocationFailureSignal

    "return the signal raised when an object allocation failed"

    ^ AllocationFailureSignal

! !

!ObjectMemory class methodsFor:'semaphore access'!

lowSpaceSemaphore

    "return the semaphore that is signalled when the system detects a

     low space condition. Usually, some time after this, an allocationFailure

     will happen. You can have a cleanup process sitting in that semaphore and

     start to release object."

    ^ LowSpaceSemaphore

! !

!ObjectMemory class methodsFor:'dependents access'!

dependents

    "return the colleciton of my dependents"

    ^ Dependents

!

dependents:aCollection

    "set the dependents collection"

    Dependents := aCollection

! !

!ObjectMemory class methodsFor:'cache management'!

flushInlineCachesForClass:aClass

    "flush inlinecaches for calls to aClass."

%{  /* NOCONTEXT */

    __flushInlineCachesFor(aClass);

%}

!

flushInlineCachesWithArgs:nargs

    "flush inlinecaches for calls with nargs arguments"

%{  /* NOCONTEXT */

    __flushInlineCaches(_intVal(nargs));

%}

!

flushInlineCachesFor:aClass withArgs:nargs

    "flush inlinecaches for calls to aClass with nargs arguments"

%{  /* NOCONTEXT */

    __flushInlineCachesForAndNargs(aClass, _intVal(nargs));

%}

!

flushInlineCaches

    "flush all inlinecaches"

%{  /* NOCONTEXT */

    __flushAllInlineCaches();

%}

!

flushMethodCacheFor:aClass

    "flush the method cache for sends to aClass"

%{  /* NOCONTEXT */

    __flushMethodCacheFor(aClass);

%}

!

flushMethodCache

    "flush the method cache"

%{  /* NOCONTEXT */

    __flushMethodCache();

%}

!

flushCachesFor:aClass

    "flush method and inline caches for aClass"

%{  /* NOCONTEXT */

    __flushMethodCacheFor(aClass);

    __flushInlineCachesFor(aClass);

%}

!

flushCaches

    "flush method and inline caches for all classes"

%{  /* NOCONTEXT */

    __flushMethodCache();

    __flushAllInlineCaches();

%}

! !

!ObjectMemory class methodsFor:'enumeration'!

allObjectsDo:aBlock

    "evaluate the argument, aBlock for all objects in the system.

     There is one caveat: if a compressing oldSpace collect

     occurs while looping over the objects, the loop cannot be

     continued (for some internal reasons). In this case, false

     is returned."

    |work|

%{  /* NOREGISTER - work may not be placed into a register here */

    nonTenuringScavenge(__context);

    /*

     * allObjectsDo needs a temporary to hold newSpace objects

     */

    if (__allObjectsDo(&aBlock, &work COMMA_CON) < 0) {

	RETURN (false);

    }

%}.

    ^ true

!

allOldObjectsDo:aBlock

    "evaluate the argument, aBlock for all old objects in the system.

     For debugging and tests only - do not use"

%{

    if (__allObjectsDo(&aBlock, (OBJ *)0 COMMA_CON) < 0) {

	RETURN (false);

    }

%}. 

    ^ true

! !

!ObjectMemory class methodsFor:'handler access'!

internalErrorHandler

    "return the handler for ST/X internal errors.

     An internal error is reported for example when a methods

     bytecode is not a ByteArray, the selector table is not an Array

     etc.  

     Those should not occur in normal circumstances."

    ^ InternalErrorHandler

!

userInterruptHandler

    "return the handler for CNTL-C interrupt handling"

    ^ UserInterruptHandler

!

userInterruptHandler:aHandler

    "set the handler for CNTL-C interrupt handling"

    UserInterruptHandler := aHandler

!

timerInterruptHandler

    "return the handler for timer interrupts"

    ^ TimerInterruptHandler

!

timerInterruptHandler:aHandler

    "set the handler for timer interrupts"

    TimerInterruptHandler := aHandler

!

spyInterruptHandler

    "return the handler for spy-timer interrupts"

    ^ SpyInterruptHandler

!

spyInterruptHandler:aHandler

    "set the handler for spy-timer interrupts"

    SpyInterruptHandler := aHandler

!

stepInterruptHandler

    "return the handler for single step interrupts"

    ^ StepInterruptHandler

!

stepInterruptHandler:aHandler

    "set the handler for single step interrupts"

    StepInterruptHandler := aHandler

!

exceptionInterruptHandler

    "return the handler for floating point exception interrupts"

    ^ ExceptionInterruptHandler

!

errorInterruptHandler

    "return the handler for display error interrupts"

    ^ ErrorInterruptHandler

!

errorInterruptHandler:aHandler

    "set the handler for display error interrupts"