Zum Hauptinhalt springen

4. A Compact Time Representation with Logarithmic Range (Kompakte Zeitdarstellung mit logarithmischem Bereich)

4. A Compact Time Representation with Logarithmic Range (Kompakte Zeitdarstellung mit logarithmischem Bereich)​

Dieses Dokument verwendet die in "Information-Centric Networking (ICN) Adaptation to Low-Power Wireless Personal Area Networks (LoWPANs)" (Anpassung informationszentrierter Netzwerke an drahtlose persönliche Netzwerke mit niedriger Leistung) beschriebene kompakte Zeitdarstellung (siehe Abschnitt 7 von [RFC9139]), die von [RFC5497] und [IEEE.754.2019] inspiriert wurde. Ihre logarithmische Kodierung unterstützt eine Darstellung von Millisekunden bis Jahren. Abbildung 1 zeigt die logarithmische Natur dieser Zeitdarstellung.

 || |  |   |    |     |      |       |        |         |          |
 +-----------------------------------------------------------------+
 Millisekunden                                                 Jahre

Abbildung 1: Eine logarithmische Bereichsdarstellung ermöglicht höhere Präzision in den kleineren Zeitbereichen und unterstützt dennoch große Zeitdeltas.

Zeitcodes (time codes) kodieren Exponenten- und Mantissenwerte in einem einzelnen Byte. Im Gegensatz zur Darstellung in [IEEE.754.2019] kodieren Zeitcodes nur nicht-negative Zahlen und enthalten daher kein separates Bit zur Anzeige der Ganzzahlvorzeichen. Abbildung 2 zeigt die Konfiguration eines Zeitcodes: eine Exponentenbreite von 5 Bits und eine Mantissenbreite von 3 Bits.

              <---          ein Byte breit          --->
              +----+----+----+----+----+----+----+----+
              |      exponent (b)      | mantissa (a) |
              |      Exponent (b)      | Mantisse (a) |
              +----+----+----+----+----+----+----+----+
                0    1    2    3    4    5    6    7

Abbildung 2: Ein Zeitcode mit Exponent und Mantisse zur Kodierung einer logarithmischen Bereichszeitdarstellung.

Die Basiseinheit für Zeitwerte ist Sekunden. Ein Zeitwert wird mit der folgenden Formel berechnet (übernommen von [RFC5497] und [RFC9139]), wobei (a) die Mantisse darstellt, (b) den Exponenten und (C) einen Konstantenfaktor, der auf C := 1/32 gesetzt ist.

Subnormal (b == 0): (0 + a/8) * 2 * C

Normalisiert (Normalized) (b > 0): (1 + a/8) * 2^b * C

Die subnormale Form bietet einen graduellen Unterlauf zwischen Null und der kleinsten normalisierten Zahl. Acht Zeitwerte existieren im subnormalen Bereich [0s,~0.0546875s] mit einer Schrittgröße von ~0.0078125s zwischen jedem Zeitwert. Diese Konfiguration kodiert auch die folgenden praktischen Zahlen in Sekunden: [1, 2, 4, 8, 16, 32, 64, ...]. Anhang A enthält Testvektoren zur Veranschaulichung des logarithmischen Bereichs.

Ein Beispielalgorithmus zur Kodierung eines Zeitwerts in den entsprechenden Exponenten und die Mantisse wird in Abbildung 3 als Pseudocode gegeben. Nicht alle Zeitwerte können durch einen Zeitcode dargestellt werden. Für diese Fälle wird ein Zeitcode erzeugt, der einen Zeitwert darstellt, der dem ursprünglichen Zeitwerteingabewert am nächsten und kleiner als dieser ist.

 input: float v    // Zeitwert
output:   int a, b // Mantisse, Exponent des Zeitcodes

(a, b) encode (v):

    if (v == 0)
        return (0, 0)

    if (v < 2 * C)                              // subnormal
        a = floor (v * 4 / C)                   // abrunden
        return (a, 0)
    else                                        // normalisiert
        if (v > (1 + 7/8) * 2^31 * C)           // Grenzen prüfen
            return (7, 31)                      // Maximum zurückgeben
        else
            b = floor (log2(v / C))             // abrunden
            a = floor ((v / (2^b * C) - 1) * 8) // abrunden
            return (a, b)

Abbildung 3: Algorithmus in Pseudocode-Form.

Zum Beispiel existiert kein spezifischer Zeitcode für 0.063. Dieser Algorithmus bildet jedoch auf den nächstgelegenen gültigen Zeitcode ab, der kleiner als 0.063 ist, d.h. Exponent 1 und Mantisse 0 (identisch mit dem Zeitwert 0.0625).

Letztes Update am