4. A Compact Time Representation with Logarithmic Range (Représentation temporelle compacte avec plage logarithmique)
4. A Compact Time Representation with Logarithmic Range (Représentation temporelle compacte avec plage logarithmique)
Ce document utilise la représentation temporelle compacte décrite dans "Information-Centric Networking (ICN) Adaptation to Low-Power Wireless Personal Area Networks (LoWPANs)" (adaptation des réseaux centrés sur l'information aux réseaux personnels sans fil à faible puissance) (voir section 7 de [RFC9139]) qui a été inspirée par [RFC5497] et [IEEE.754.2019]. Son encodage logarithmique prend en charge une représentation allant des millisecondes aux années. La figure 1 illustre la nature logarithmique de cette représentation temporelle.
|| | | | | | | | | | |
+-----------------------------------------------------------------+
millisecondes années
Figure 1: Une représentation de plage logarithmique permet une précision plus élevée dans les plages temporelles plus petites et prend toujours en charge de grands deltas temporels.
Les codes temporels (time codes) encodent les valeurs d'exposant et de mantisse dans un seul octet. Contrairement à la représentation dans [IEEE.754.2019], les codes temporels n'encodent que des nombres non négatifs et n'incluent donc pas de bit séparé pour indiquer le signe de l'entier. La figure 2 montre la configuration d'un code temporel: une largeur d'exposant de 5 bits et une largeur de mantisse de 3 bits.
<--- un octet de large --->
+----+----+----+----+----+----+----+----+
| exponent (b) | mantissa (a) |
| exposant (b) | mantisse (a) |
+----+----+----+----+----+----+----+----+
0 1 2 3 4 5 6 7
Figure 2: Un code temporel avec exposant et mantisse pour encoder une représentation temporelle à plage logarithmique.
L'unité de base pour les valeurs temporelles est la seconde. Une valeur temporelle est calculée à l'aide de la formule suivante (adoptée de [RFC5497] et [RFC9139]), où (a) représente la mantisse, (b) l'exposant et (C) un facteur constant fixé à C := 1/32.
Sous-normal (Subnormal) (b == 0): (0 + a/8) * 2 * C
Normalisé (Normalized) (b > 0): (1 + a/8) * 2^b * C
La forme sous-normale fournit un sous-dépassement progressif entre zéro et le plus petit nombre normalisé. Huit valeurs temporelles existent dans la plage sous-normale [0s,~0.0546875s] avec une taille de pas de ~0.0078125s entre chaque valeur temporelle. Cette configuration encode également les nombres pratiques suivants en secondes: [1, 2, 4, 8, 16, 32, 64, ...]. L'annexe A inclut des vecteurs de test pour illustrer la plage logarithmique.
Un exemple d'algorithme pour encoder une valeur temporelle dans l'exposant et la mantisse correspondants est donné sous forme de pseudocode dans la figure 3. Toutes les valeurs temporelles ne peuvent pas être représentées par un code temporel. Pour ces cas, un code temporel est produit qui représente une valeur temporelle la plus proche et inférieure à la valeur temporelle d'entrée initiale.
input: float v // valeur temporelle
output: int a, b // mantisse, exposant du code temporel
(a, b) encode (v):
if (v == 0)
return (0, 0)
if (v < 2 * C) // sous-normal
a = floor (v * 4 / C) // arrondi vers le bas
return (a, 0)
else // normalisé
if (v > (1 + 7/8) * 2^31 * C) // vérifier les limites
return (7, 31) // retourner le maximum
else
b = floor (log2(v / C)) // arrondi vers le bas
a = floor ((v / (2^b * C) - 1) * 8) // arrondi vers le bas
return (a, b)
Figure 3: Algorithme sous forme de pseudocode.
Par exemple, aucun code temporel spécifique pour 0.063 n'existe. Cependant, cet algorithme correspond au code temporel valide le plus proche qui est inférieur à 0.063, c'est-à-dire exposant 1 et mantisse 0 (identique à la valeur temporelle 0.0625).