1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
.. _glossary-u:

=============================
Memory Management Glossary: U
=============================

.. include:: alphabet.txt

.. glossary::

    unaligned

        .. aka:: *misaligned*.

        An :term:`address` is unaligned or misaligned if it does not
        comply with some :term:`alignment` constraint on it.

        For example, typically double precision floating point numbers
        occupy 8 :term:`byte (1)` and have an alignment of 4 bytes;
        that is, their address must be a multiple of four. If a
        program tries to access such a number using an address that is
        not a multiple of four, a :term:`bus error` may result,
        depending on the processor architecture and instruction used.

        .. opposite:: :term:`aligned <alignment>`.

        .. seealso:: :term:`alignment`, :term:`bus error`.

    unboxed

        Unboxed :term:`objects` are represented by an
        encoding of the data itself, and not by a :term:`pointer` to
        that data.

        Representations are typically chosen so that unboxed values
        are the same size as the pointer part of a :term:`boxed`
        object. Sometimes the value is :term:`tagged <tag>` to
        distinguish it from a boxed object. The entire object is
        duplicated when the object is passed around, so updates to it,
        if allowed, only affect one copy.

        .. similar:: :term:`immediate data`.

        .. opposite:: :term:`boxed`.

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

    unclamped state

        .. mps:specific::

            One of the three states an :term:`arena` can be in (the
            others being the :term:`clamped state` and the
            :term:`parked state`). In the unclamped state, object
            motion and other background activity may occur. Call
            :c:func:`mps_arena_release` to put an arena into the
            unclamped state.

    undead

        An undead object is an :term:`object` that cannot be proven to
        be :term:`dead` by the :term:`garbage collector`, but whose
        :term:`liveness <live>` is dubious.

        For example, an :term:`ambiguous reference` to an object on a
        :term:`page` may mark the entire page as :term:`reachable`. No
        further data is collected about that page. The other objects
        on the page will survive, even though their reachability has
        not been determined. They are *undead*.

    unmapped

        .. aka:: *free*.

        A range of :term:`virtual addresses` is said
        to be *unmapped* (*free* on Windows) if there is no
        :term:`physical memory (2)` associated with the range.

        An unmapped range may or may not be :term:`reserved`.

        .. opposite:: :term:`mapped`.

    unreachable

        An :term:`object` is unreachable if there is no
        :term:`reference` chain to it from any :term:`root`.

        An object will become unreachable when the :term:`mutator`
        overwrites its last (direct or indirect) reference to the
        object.

        .. similar:: :term:`dead`.

        .. opposite:: :term:`reachable`, :term:`live`.

        .. seealso:: :term:`reachable`, :term:`garbage collection`.

    unsure reference

        .. see:: :term:`ambiguous reference`.

    unwrapped

        .. aka:: *raw*.

        A value is *unwrapped* or *raw* if it is not encoded with type
        information.

        In a dynamically-typed language, the compiler may sometimes be
        able to pick a more compact or efficient representation for a
        value if it can prove that the type can be determined at
        compile-time. This is a particularly useful optimization for
        numeric values such as integers or floats.

        .. opposite:: :term:`wrapped`.

        .. seealso:: :term:`boxed`, :term:`tag`, :term:`value object`.

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

    use after free

        .. see:: :term:`premature free`.