"

 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

                           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

        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.

    The flushXXX methods perform the task of flushing various caches - to be 

    'on the brigth side of live', use ObjectMemory>>flushCaches, when in dooubt

"

!

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

    by sending 'ObjectMemory XXXInterruptHandler:aHandler'.

    (see Smalltalk>>initialize or ProcessorScheduler>>initialize)

"

!

garbageCollection

"

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

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

    This newSpace is cleaned by a scavenge-operation whenever becoming

    objects as garbage behind. Once an object survives enough of these copying

    operations, the next scavenge will move it into the so called oldSpace,

    which is much larger. This movement of an object from newSpace to oldSpace

    is called 'tenure'.

    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 

    hints & tricks:

      normally, there is no need to call for an explicit garbage collection;

      the memory system should adapt reasonable and provide good performance 

      for a wide range of allocation patterns.

      However, there could be situations, in which hints and/or explicit

      control over allocation can speedup your programs.

      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.

      Keep in mind, that do-loops may allocate block-objects and other temoraries,

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

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

      force the system to do an oldspace collect earlier, which may make things

      worse).

      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.

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

"

! !

!ObjectMemory class methodsFor:'initialization'!

initialize

    AllocationFailureSignal isNil ifTrue:[

        AllocationFailureSignal := (Signal new) mayProceed:true.

        AllocationFailureSignal notifierString:'allocation failure'.

    ].

    IncrementalGCLimit := 500000.

    MemoryInterruptHandler := self

! !

!ObjectMemory class methodsFor:'signal access'!

allocationFailureSignal

    "return the signal raised when an object allocation failed"

    ^ AllocationFailureSignal

! !

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

    ErrorInterruptHandler := aHandler

!

signalInterruptHandler

    "return the handler for UNIX-signal interrupts"

    ^ SignalInterruptHandler

!

signalInterruptHandler:aHandler

    "set the handler for UNIX-signal interrupts"

    SignalInterruptHandler := aHandler

!

childSignalInterruptHandler

    "return the handler for UNIX-death-of-a-childprocess-signal interrupts"

    ^ ChildSignalInterruptHandler

!

disposeInterruptHandler

    "return the handler for object disposal interrupts"

    ^ DisposeInterruptHandler

!

disposeInterruptHandler:aHandler

    "set the handler for object disposal interrupts"

    DisposeInterruptHandler := aHandler

!

recursionInterruptHandler

    "return the handler for recursion/stack overflow interrupts"

    ^ RecursionInterruptHandler

!

recursionInterruptHandler:aHandler

    "set the handler for recursion/stack overflow interrupts"

    RecursionInterruptHandler := aHandler

!

ioInterruptHandler

    "return the handler for I/O available signal interrupts (SIGIO/SIGPOLL)"

    ^ IOInterruptHandler

!