RegisterVariable bei großen Datenmengen in kurzer Zeit

Ich experimentiere gerade ein wenig mit der Auswertung eines seriellen Datenstroms. Dazu zerlege ich die Daten vom I/O via Cutter und leite sie an eine RegisterVariable weiter. Soweit so schön.

Nun kann es aber hin und wieder vorkommen, dass der I/O sehr viele Daten in kurzer Zeit empfängt. Viel bezieht sich jetzt weniger auf die absolute Datenmenge sondern viel mehr darauf, wie viele zu verarbeitende Datenblöcke in einem bestimmten Intervall eintreffen.

Nun stelle ich mir die Frage, wie die RegisterVariable damit umgeht, wenn schneller neue Daten reinkommen als das zugehörige Skript sie abarbeiten kann. Für den I/O und Splitter stellt das kein Problem dar. Die reichen die Daten ruck zuck an die RegisterVariable weiter und diese fängt dann an, das Skript mehrmals parallel aufzurufen und die Daten dann irgendwann zu buffern und nach und nach dem Skript zu servieren.

Mich würde nun interessieren, wie robust das ganze ist. Ab einem gewissen Punkt wird es ja kritisch werden, wenn die Daten längere Zeit schneller rein kommen als sie abgearbeitet werden können. Gibt es da seitens der RegisterVariablen irgendwelche Schutzmechanismen, die das System vor Überlast schützen? Oder macht die Instanz so lange weiter, bis nichts mehr geht?

Gibt es irgendwelche Konzepte, wie man mit solchen Situationen umgeht? Kann ich irgendwie steuern, dass ich bei zu vielen Daten temporär keine weiteren Daten mehr ans Skript weiterleite und die Verarbeitung erst wieder ab einer bestimmten Grenze starte?

Die Verwendung eines Buffers wird mir ja nicht helfen, da ich das Skript der RegisterVariablen ja trotzdem aufrufen muss, um den Buffer zu lesen/schreiben.

Die Frage ist im Moment noch eher theoretischer Natur. Da ich aber zeitweise 30-50 zu verarbeitende Datensätze pro Sekunde habe, würde ich gerne die Grenzen kennen und wie man sowas am besten händelt.

Ich habe mal testweise für 5 Sekunden 30 Datensätze pro Sekunde über den I/O empfangen und an die RegisterVariable gegeben. Dem Skript habe ich spaßeshalber eine Ausführungszeit von 500 ms je Aufruf verpasst. Dann sieht man schön, wie sich die RegisterVariable noch eine ganze Zeit lang nach dem Ende der letzten Datenlieferung mit der Abarbeitung beschäftigt. Da läuft dann immer 2-3 mal das Skript parallel, bis der Puffer der Instanz irgendwann leer ist.

Bei dem Test habe ich außer der hohen Latenz bei der Datenverarbeitung noch keine Probleme festgestellt. Ich würde trotzdem gerne die Grenzen der RegisterVariablen kennen und ob man sowas überhaupt sinnvoll damit bearbeiten kann.

Gruß
Slummi

Robust → Ja. Wir sammeln die Daten in einer Queue und wir arbeiten die nacheinander in der korrekten Reihenfolge ab. D.h. nicht parallel (sonst hättest du Probleme beim Zusammenstecken), sondern nacheinander. Das ganze ist auch darauf ausgelegt, dass es mal solche Bursts gibt.

Theoretisch, wenn du mehr Daten „rein“ bekommst als du verarbeiten kannst, hättest du auf lange Sicht ein Speicherleck und einen Absturz wegen RAM Mangels. Aber ich habe soeben einen Patch vorbereitet, den ich noch in die 6.3 einbringen werde, der die interne Queue auf 512kB Daten limitiert und danach den Puffer wegwirft und mit einer Fehlermeldung im Log quittiert, um genau dieses Speicherleck zu verhindern.

Somit Danke für die kritische Frage und ein potenzielles Problem weniger.

Ich empfehle die Daten über den Cutter zu „zerlegen“, damit du weniger Einzelpakete hast, die dann ins Skript weitergereicht werden müssen, sofern es geht.

Der Cutter ist gegen dieses Problem übrigens abgesichert und macht ab 64kB Daten im Puffer stress.

paresy

1 „Gefällt mir“