+- LabVIEWForum.de (https://www.labviewforum.de)
+-- Forum: LabVIEW (/Forum-LabVIEW)
+--- Forum: LabVIEW Allgemein (/Forum-LabVIEW-Allgemein)
+--- Thema: Parallelisierung von DLLs (/Thread-Parallelisierung-von-DLLs)
Seiten: 1 2
RE: Parallelisierung von DLLs - Herm - 21.08.2012 09:32
(20.08.2012 15:00 )GerdW schrieb: Hallo Herm,
deine Erzeugerschleife sieht schon sehr "kompliziert" aus.
Wozu schreibst du in eine Queue, um dann in der gleichen Schleife und sofort danach wieder aus dieser Queue auszulesen??? Warum dann nicht einfach einen Draht nehmen? Außerdem verteilst du munter "Bilder" an alle Verbraucherschleife, egal, wie schnell diese die Daten abarbeiten...
Überlege mal selbst, ob du das nicht einfacher hinbekommst...
Dass ich die Bilder munter verteile ist mir auch aufgefallen. Ich dachte die Ereignisstruktur läuft folgendermaßen: Wenn eine Schleife abgearbeitet ist, wird durch die Wertänderung des Ergebnisses in dieser Schleife die dazugehörige Ereignisstruktur ausgewählt, die die darin beinhaltete Zahl zum Zuweisen weitergibt. So wie es momentan implementiert ist, gibt die Ereignisstruktur die Werte einfach der Reihe nach weiter. Wenn eine Schleife dann länger benötigt, verfallen die übrigen "Bilder" einfach. Der Sinn dahinter sollte eigentlich sein, dass die Verbraucherschleifen nur angesteuert werden, wenn sie zuvor ein "Bild" verarbeitet haben und dies durch die Wertänderung am Ende bekannt gegeben haben.
Zum Aufbau: Die eine Queue, in der die Bilder gespeichert werden, war dazu gedacht, einen Puffer einzubauen, wenn die "Bilder" deutlich schneller geliefert werden, als die Schleifen diese abarbeiten können. Wenn sich zwei Schleifen innerhalb von 33 ms ein "Bild" abgreifen wollen, dann wäre bei einer normalen Verdrahtung bis dahin ja noch kein neues Bild angekommen. Was würde die zweite Schleife in dem Fall machen? Verwendet sie dasselbe Bild, wie die erste Schleife, oder wartet sie so lange, bis ein neues Bild anliegt?
Den restlichen Teil weis ich nicht zu vereinfachen. Die vier Schleifen müssen initialiisert werden, damit die Ereignisse überhaupt statt finden können, dafür sind die ersten vier Cases gedacht. Danach geht das Programm in den 5. Case und arbeitet ab da mit der Ereignisstruktur. Die Zuweisungswerte lasse ich in einer Queue speichern, ebenfalls als Puffer, falls ich langsamer "Bilder" bekomme, als ich abarbeiten kann.
Ich finde das selbst nich sonderlich schön, eigentlich wollte ich es so haben, dass nur so viele Schleifen angseteuert, wie gebraucht werden. Wenn meine Schleifen schnell arbeiten, reichen zwei davon, wenn sie langsamer sind, brauch ich 3 oder 4. Wenn sie noch langsamer sind, müssen die übrigen "Bilder" verfallen. Wenn ich auf 2 oder 3 Schleifen zurückfahre muss ich dann ja wieder die 3. bzw. 4. wieder neue initialisieren, wenn ich sie wieder brauche. Wenn ich langsamer Bilder geliefert kriege, als eine alleine abarbeiten kann, dann muss diese so lange Warten, bis wieder ein neues "Bild" anliegt. Momentan hört sie dann einfach auf, weil das Ereignis ja nicht gespeichert wird, dafür war die Queue gedacht.
Wenn ich das so haben will, geht das warscheinlich auf diesem Weg garnicht, ich habe aber keine Idee, wie ich das sonst machen soll.
Gruß
Herm
RE: Parallelisierung von DLLs - GerdW - 21.08.2012 09:36
Hallo Herm,
falls du Ideen brauchst, kann ich dich noch mal an Beitrag #3 erinnern...
RE: Parallelisierung von DLLs - Jontef - 30.08.2012 07:58
Hast du mittlerweile eine Lösung für dein Problem gefunden?
Könnte dir sonst heute Abend noch einen anderen Lösungansatz posten!
Gruß