.. _glossary-w:

=============================
Memory Management Glossary: W
=============================

.. include:: alphabet.txt

.. glossary::

    weak-key hash table

        A hash table which has :term:`weak references (1)` to its
        keys. If the key dies, the value for that key is automatically
        deleted from the table too. It can be used to store extra
        information about objects without keeping them alive.

        .. similar:: :term:`doubly weak hash table`, :term:`weak-value hash table`.

        .. mps:specific:: See :ref:`pool-awl`.

    weak-value hash table

        A hash table which has :term:`weak references (1)` to its
        value. If the value dies, any keys that refer to that value
        are automatically deleted from the table too. It can be used
        to index a set of objects without keeping them alive.

        .. similar:: :term:`doubly weak hash table`, :term:`weak-key hash table`.

        .. mps:specific:: See :ref:`pool-awl`.

    weak hash table

        A :term:`weak-key <weak-key hash table>` or :term:`weak-value
        hash table` (usually the former).

    weak reference (1)

        In :term:`tracing garbage collection`, a weak reference is a
        :term:`reference` that does not keep the :term:`object` it
        refers to :term:`alive <live>`.

        A weak reference does not keep the referent alive, but it will
        continue to refer to the object as long as it remains
        otherwise alive. When only weak references to the object
        remain, the weak references can be deleted ("splatted" or
        "cleared") and the object :term:`reclaimed`.

        :term:`Java` offers three kinds of weak references, called
        :term:`soft references`, :term:`weak references (2)`, and
        :term:`phantom references`, in order of increasing weakness.

        .. opposite:: :term:`strong reference`.

        .. seealso:: :term:`weak root`.

    weak reference (2)

        In :term:`Java` terminology, *weak reference* is used to mean
        a :term:`reference` encapsulated in a :term:`reference object`
        of class ``WeakReference``.

        Weak references form one of three kinds of :term:`weak
        reference (1)` in Java. They are handy for associating extra
        data with objects when you cannot store it in the objects
        themselves.

        .. seealso:: :term:`weakly reachable`.

        .. link::

            `Class java.lang.ref.WeakReference <http://docs.oracle.com/javase/8/docs/api/java/lang/ref/WeakReference.html>`_, `Reference Objects and Garbage Collection <http://pawlan.com/monica/articles/refobjs/>`_.

    weak root

        A weak root is a :term:`root`, such that all
        :term:`references` in it are :term:`weak references (1)`; that
        is, they do not affect the :term:`liveness <live>` of the
        :term:`objects` referred to.

        .. opposite:: :term:`strong root`.

        .. mps:specific::

            A weak root has :term:`rank` :c:func:`mps_rank_weak`.

    weak tri-color invariant
    weak tri-colour invariant
    weak tricolor invariant
    weak tricolour invariant

        The weak :term:`tri-color invariant` is the property of a
        :term:`reference` :term:`graph` that all :term:`white`
        :term:`nodes` pointed to by a :term:`black` node are
        also :term:`reachable` from some :term:`gray` node through a
        chain of white nodes.

        By preserving this property throughout :term:`tri-color
        marking`, a :term:`tracing <trace>` algorithm can ensure that
        the :term:`collector (2)` will not miss reachable objects,
        even if the :term:`mutator` manipulates the graph during the
        collection. Mutator actions might need to change the
        :term:`color` of the nodes affected in order to preserve the
        invariant.

        Algorithms using this invariant are
        :term:`snapshot-at-the-beginning <snapshot at the beginning>`
        algorithms.

        .. seealso:: :term:`barrier (1)`, :term:`strong tri-color invariant`.

        .. bibref:: :ref:`Johnstone (1997) <JOHNSTONE97>`, :ref:`Pirinen (1998) <PIRINEN98>`.

    weakly reachable

        In :term:`Java`, an object is *weakly reachable* if it is
        neither :term:`strongly <strongly reachable>` nor
        :term:`softly reachable` and there is a path from the
        :term:`roots` to it that contains at least one
        :term:`weak reference (2)` but no :term:`phantom references`.

        When the Java :term:`collector (1)` determines that an object
        is weakly reachable, it clears all the weak references
        involved, and declares the object :term:`finalizable
        <finalization>`. (Operationally, finalization works as if it
        was implemented by a class of "final references" that stand
        between weak and phantom references.) Also, the
        :term:`reference objects` containing the
        weak references are enqueued, if they were registered with a
        queue.

        .. seealso:: :term:`phantom reachable`, :term:`reachability <reachable>`.

        .. link::

            `Class java.lang.ref.WeakReference <http://docs.oracle.com/javase/8/docs/api/java/lang/ref/WeakReference.html>`_, `Reference Objects and Garbage Collection <http://pawlan.com/monica/articles/refobjs/>`_.

    weighted buddies

        A :term:`buddy system` :term:`allocation mechanism` using two
        series of size classes: :term:`binary buddies` (2, 4, 8, …)
        and three-times-power-of-two (3, 6, 12, …). A block that is
        in the latter series may be :term:`split` in two different
        ways. Thus a block of size 12 may be split into two blocks of
        size 6 or one block of size 4 and one block of size 8. The
        same applies for :term:`coalescing <coalesce>`. This gives
        this system more flexibility than a regular buddy system.

        .. seealso:: :term:`allocation mechanism`, :term:`binary buddies`, :term:`buddy system`.

        .. bibref:: :ref:`Wilson et al. (1995) <WIL95>`.

    weighted reference counting

        A technique for :term:`reference counting` which is in common
        use for :term:`distributed garbage collection` because of the
        low level of inter-process communication it requires.

        Inter-process :term:`references` to :term:`objects` are
        counted, but instead of simply counting the number of
        references, each reference is given a weight. When an object
        is created, the initial pointer to it is assigned a weight,
        which is usually a power of 2 for easy division. The object
        records the sum of all the weights of all of its references.
        Whenever a reference is copied, its weight is divided equally
        between the new and original copies. Since this operation
        preserves the weighted reference sum, there is no need for
        communication with the object at this time. When a reference
        is deleted, the weighted reference sum is decremented by the
        weight of the reference. This is communicated to the object by
        sending it a message. When the object detects that the
        weighted reference sum has dropped to zero, it may be
        :term:`reclaimed`. The algorithm is tolerant of communication
        protocols which don't guarantee order of arrival of deletion
        messages.

    white

        In a :term:`tri-color marking` scheme, white :term:`objects`
        are objects that were :term:`condemned <condemned set>` at the
        beginning of the :term:`collection cycle` and have not been
        shown to be :term:`reachable`. When :term:`tracing <trace>` is
        complete, white objects will be subject to :term:`reclamation
        <reclaim>`.

        .. opposite:: :term:`black`, :term:`gray`.

    word

        .. aka:: *machine word*.

        Almost all processor architectures have a characteristic data
        size that is handled most efficiently. This is known as the
        *word size*, and data of that size are known as *words*. The
        word size is usually a power of two multiple of :term:`bytes
        (2)`.

        Often the platform's word size is used to characterize the
        architecture by quoting the number of bits in it. For example,
        a 32-bit platform has a word size of four bytes and a 64-bit
        platform has eight-byte words (assuming 8-bit bytes).
        Typically, :term:`pointers` are the size of a word,
        and traditionally this determined the word size. Nowadays,
        word size is usually driven by the need for more accuracy and
        range in mathematical calculations.

        .. historical::

            In the past, the convenience of dealing with powers of two was not as significant, and word sizes such as 36- or 72-bits were not unknown.

        .. seealso:: :term:`alignment`, :term:`grain`.

    working set

        The working set of a program or system is that :term:`memory
        (2)` or set of :term:`addresses` which it will use
        in the near future.

        This term is generally used when discussing :term:`miss rates`
        at some :term:`storage level`; the time scale of "near future"
        depends upon the cost of a :term:`miss`. The working set
        should fit in the storage level; otherwise the system may
        :term:`thrash`.

        .. seealso:: :term:`cache (2)`, :term:`resident set`, :term:`storage hierarchy`.

        .. bibref:: :ref:`Denning & Schwartz (1972) <DS72>`.

    worst fit

        The :term:`allocation policy` that always allocates from the
        largest :term:`free block`. Commonly implemented using a
        size-ordered :term:`free block chain` (largest first).

        In practice, this tends to work quite badly because it
        eliminates all large blocks, so large requests cannot be met.

        .. seealso:: :term:`allocation policy`, :term:`best fit`, :term:`first fit`.

        .. bibref:: :ref:`Wilson et al. (1995) <WIL95>`.

    wrapped

        A value is wrapped if it is encoded with type information.

        .. opposite:: :term:`unwrapped`.

        .. seealso:: :term:`boxed`, :term:`tag`, :term:`wrapper`.

        .. bibref:: :ref:`Gudeman (1993) <GUDEMAN93>`.

    wrapper

        A wrapper is that part of a :term:`wrapped` representation
        that is copied when the value is passed by value.

        The wrapper does not include parts of the representation that
        are accessed indirectly, and are not copied when the value is
        passed.

        For instance, a :term:`Lisp` implementation might use the top
        two bits of a value representation as a :term:`tag` to
        distinguish between integers and :term:`cons (1)` cells,
        setting these bits to 01 for a :term:`pointer` to a cons cell
        and 11 for an integer. Then the wrapped value of the number 4
        would have binary representation 11000…00100, and the
        wrapper for this number is the whole of this wrapped value.
        The pointer to a cons cell stored at location 4 would have
        binary representation 01000…00100. The wrapped value of the
        cons cell is the combination of this pointer and the cons cell
        in memory itself. The wrapper of the cons cell is just the
        pointer; when the cons cell is passed as a function argument,
        just the pointer is passed.

        .. seealso:: :term:`boxed`, :term:`wrapped`.

        .. bibref:: :ref:`Gudeman (1993) <GUDEMAN93>`.

    write barrier

        A write :term:`barrier (1)` is a block on writing to certain
        :term:`memory (2)` :term:`locations <memory location>` by
        certain threads or processes.

        .. relevance::

            Write barriers are used for :term:`incremental
            <incremental garbage collection>` or :term:`concurrent
            <parallel garbage collection>` :term:`garbage collection`.
            They are also used to maintain :term:`remembered sets` for
            :term:`generational <generational garbage collection>`
            :term:`collectors (1) <garbage collector>`.

        .. seealso:: :term:`read barrier`.

    write fault

        An exception which occurs when writing to an address in
        :term:`virtual memory`.

        This is probably either a :term:`page fault`, an
        :term:`invalid page fault` or a :term:`protection fault`.

        .. similar:: :term:`segmentation violation`.

        .. seealso:: :term:`read fault`.
