Fenêtres d'instantané
Une fenêtre d'instantané définit un sous-ensemble d'événements se produisant durant une période donnée et sur lesquels vous pouvez effectuer un calcul basé sur un jeu (agrégation, par exemple). Les fenêtres d'instantané divisent la chronologie en fonction des heures de fin et de début des événements. Il s'agit donc de fenêtres dynamiques pilotées par des événements. Comme pour les modifications d'horodatage, elles peuvent être adaptées à un grand nombre de scénarios.
Pour obtenir une description générale des fenêtres d'événement et en savoir plus sur leur mode d'implémentation et d'utilisation dans StreamInsight, consultez Utilisation de fenêtres d'événement.
Fonctionnement des fenêtres d'instantané
Les fenêtres d'instantané sont définies en fonction des heures de début et de fin des événements dans le flux de données, plutôt que selon une grille fixe dans la chronologie. La taille et la période de temps de la fenêtre sont définies uniquement par les événements du flux. Une fenêtre d'instantané est créée pour chaque paire de points de terminaison d'événement les plus proches (heures de début et de fin). Selon cette définition, les heures de début et de fin des événements correspondent toujours aux limites de la fenêtre et ne sont jamais à l'intérieur des limites. Autrement dit, les fenêtres d'instantané divisent la chronologie en fonction de toutes les modifications effectuées.
L'illustration suivante montre un flux contenant trois événements : e1, e2 et e3. Les barres verticales affichent les limites de la fenêtre d'instantané définies par ces événements. Les flux d'événements en bleu clair représentent les flux d'événements qui se déplacent dans le temps. Les zones orange affichent les fenêtres d'instantané et les événements contenus dans chacune d'elles. Par exemple, compte tenu de l'heure de début et de fin, seul l'événement e1 figure dans la première fenêtre d'instantané. Cependant, dans la mesure où les événements e1 et e2 se chevauchent, ils sont inclus dans la deuxième fenêtre.
.gif "Illustration d'une fenêtre d'instantané")
Dès que l'infrastructure applique la stratégie d'entrée ayant pour effet de limiter les événements aux fenêtres (seule stratégie d'entrée actuellement disponible), les événements apparaissent comme indiqué dans l'illustration suivante.
.gif "Fenêtre d'instantané avec réduction des événements à la taille de la fenêtre.")
Il s'agit des fenêtres et des événements incorporés à l'opération reposant sur un jeu. Il est important de comprendre le fonctionnement du mode de limitation lors de l'application d'un agrégat ou d'un opérateur basé sur le temps capable d'analyser les horodateurs des événements d'entrée.
Définition d'une fenêtre d'instantané
Les fenêtres d'instantané n'ont pas de paramètres pour la définition de fenêtre. Les stratégies de fenêtre par défaut ont pour fonction de faire coïncider les événements d'entrée et de sortie à la taille de la fenêtre.
var snapshotAgg = from w in inputStream.SnapshotWindow()
select new { sum = w.Sum(e => e.i) };
Les arguments de la fenêtre d'instantané dans l'exemple ci-dessus sont des propriétés statiques qui retournent des instances des classes de stratégies correspondantes. Ces propriétés sont utilisées par commodité.
Les fenêtres d'instantané sont des éléments de construction puissants et pratiques pour implémenter des fenêtres défilantes. Une fenêtre défilante est une fenêtre qui se déplace dans le temps en fonction des événements, et non par période fixe. L'avantage d'une fenêtre défilante est qu'elle adapte sa longueur aux événements d'entrée et qu'elle ne produit donc pas de sortie si l'entrée n'a pas changé. C'est en quelque sorte un moyen de compresser le flux d'événements. Ce mécanisme est particulièrement utile pour une agrégation à l'intérieur d'un opérateur de groupe et d'application, lorsque les données d'entrée représentent un nombre de groupes important. Avec une fenêtre récurrente, chaque groupe produirait un résultat par fenêtre, indépendamment du taux de changement de l'entrée. Pour plus d'informations, consultez Fenêtres récurrentes.
Une fenêtre défilante est implémentée en associant l'opérateur Snapshot à la modification temporelle appropriée du flux d'entrée. Le changement d'horodateur (qui correspond généralement à une extension de la durée de l'événement) a pour effet de modifier d'abord la « couverture » de chaque événement dans le temps. L'instantané contiendra tous les événements correspondant à cette période. Supposons, par exemple, que le but soit de calculer la moyenne glissante d'un flux d'entrée d'événement point pendant les trois dernières minutes. L'illustration suivante montre dans quelle mesure la méthode AlterEventDuration() appliquée au flux d'entrée « allonge » chaque événement dans la chronologie.
.gif "Fenêtre d'instantané avec horodateurs modifiés.")
Après application de l'opérateur Snapshot à ce flux de données, la moyenne du champ d'événement désiré est calculée par rapport aux fenêtres résultantes comme indiqué dans l'illustration suivante.
.gif "Fenêtre d'instantané avec des résultats agrégés (moyenne).")
Les événements obtenus dans cette illustration décrivent la moyenne de tous les événements survenus au cours des trois dernières minutes, à chaque point limite dans le temps. Ce résultat est représenté par les événements intervalle d'une durée équivalente à la moyenne (tant que celle-ci ne change pas pendant la plage horaire considérée). Par exemple, le quatrième événement dans cette série considère que la moyenne de tous les événements pendant les trois dernières minutes correspondait à 1,5 (mesurée à partir de tout point dans cet événement). L'événement de résultat commence dès que l'événement point de charge utile 3 se produit juste en dehors de la fenêtre de trois minutes, et se termine juste avant que l'événement point de charge utile 1 se trouve en dehors de la fenêtre, comme indiqué dans l'illustration suivante.
.gif "Fenêtre d'instantané avec résultats de l'événement point.")
À l'aide de LINQ (Language Integrated Query), ce scénario est exprimé de la façon suivante (en supposant que le type d'événement d'entrée possède un champ « Valeur »).
var result = from win in inputStream.AlterEventDuration(e => TimeSpan.FromMinutes(3)).SnapshotWindow()
select new { average = win.Avg(e => e.Value) };
En général, pour « remonter » dans le temps lors de l'application d'une opération reposant sur un jeu à l'aide d'un opérateur Snapshot, il convient de prolonger les durées de vie des événements dans le futur. Il est possible d'utiliser d'autres types d'opérateurs de modification de durée de vie des événements pour parvenir à des résultats différents. Pour plus d'informations, consultez Modifications d'horodatage.
Voir aussi
Concepts
Agrégats et opérateurs définis par l'utilisateur