+- LabVIEWForum.de (https://www.labviewforum.de)
+-- Forum: LabVIEW (/Forum-LabVIEW)
+--- Forum: LabVIEW Allgemein (/Forum-LabVIEW-Allgemein)
+--- Thema: Schneller Umgang mit großen Arrays (/Thread-Schneller-Umgang-mit-grossen-Arrays)
Schneller Umgang mit großen Arrays - curassas - 09.09.2011 08:54
Hallo,
vielleicht hat ja jemand ein paar Tipps für mich.
Ich erhalte aus einem Dll-Aufruf ein Array von einem Bild (1280x1024).
Dieses Array läßt sich z.B. mit ArraytoIMAQ nahezu ohne Zeitverlust als IMAQ-Image darstellen.
Nun möchte ich jedoch mit dem Array arbeiten! Doch schon das schreiben in ein Array dauert ca. 20ms.
Kann man dies irgendwie beschleunigen, oder gibt es hier bessere Methoden.
Vielen Dank für eure Hilfe.
RE: Schneller Umgang mit großen Arrays - kaiman - 09.09.2011 09:35
Moin,
zwei Sachen sind mir nicht ganz klar. Warum willst du ein so großes Bild als Array anzeigen lassen? Klar, dass das Zeit kostet. Du kannst das Array auch ohne dass du es anzeigen lässt verarbeiten. Anzeigen auf dem FP Kosten immer relativ viel Zeit, es lohnt sich also immer die Anzahl der Anzeigen im FP zu reduzieren.
Zweite Unklarheit: Warum verarbeitest du nicht einfach das IMAQ Image? Dann sparst du dir den ganzen Array Kram. Oder willst du so spezielle Operationen machen die nicht im Vision Paket enthalten sind?
RE: Schneller Umgang mit großen Arrays - curassas - 20.09.2011 16:26
Hallo kaiman,
leider komme ich erst jetzt dazu, dir zu Antworten.
Also:
Hauptsächlich benötige ich das Array für Berechnungen. Da ich nur die "kleine" Vision-Lizenz verwende, analysiere ich das Array selbst.
Ich möchte eigentlich mehrere Schleifen (oder Eventstrukturen) parallel laufen lassen.
1. Bild holen (so schnell wie möglich)
2. Bild vermessen (so schnell wie benötigt)
3. Bild darstellen (15-20 Durchläufe pro Minute)
Dies sollte mir die Möglichkeit geben, je nach Bedarf die Mess- oder Anzeigeroutine auch asynchron laufen zu lassen, um so z.B. die Messroutine zu beschleunigen.
Natürlich ist hier die maximale Grenze die Bild-holen-Schleife. Das Holen der Bilddaten und das Speichern als Variable sind hier die Zeitfaktoren. An dem Dll-Aufruf kann ich nichts ändern, aber vielleicht gibt es eine schnellere Möglichkeit das Bild-Array (bzw. die Bilddaten) der VI zur Verfügung zustellen, als es in eine Variable zu schreiben.
In der jetzigen Version benötige ich wie schon erwähnt ca. 20ms fürs schreiben in das Array, meine Bild-holen-Schleife ist dadurch fast nur noch halb so schnell. Die Bilddarstellung ist ausgeschaltet, es läuft nur noch der DLL-Aufruf (IDS-uEye-GetImage) und das Schreiben ins Array (Variable).
Noch ein Vermerk zur Vision-Lizenz
Mit der kleinen Vision-Lizenz habe ich neben der reinen Darstellung (+Maskentools) nur die Wandler "IMAQ-Bild zu Array" und "Array zu IMAQ-Bild". IMAQ zu Array ist übrigen genauso langsam, wie das Schreiben in ein Array (ist ja letztlich auch nichts anderes!)
RE: Schneller Umgang mit großen Arrays - GerdW - 20.09.2011 20:01
Hallo curassas,
um die 3 Teilbereiche zu entkoppeln, bieten sich Queues an. Beispiele dazu findest du im Examplefinder.
Dann benötigst du auch keinen Arrayindicator mehr, um auf die Daten zuzugreifen...
RE: Schneller Umgang mit großen Arrays - curassas - 22.09.2011 13:38
Hallo GerdW,
Das mit den Queues werde ich mal probieren.
Doch das Entkoppeln der Routinen ist nicht mein Problem, denn letztlich schreibe/lese ich auch hier über eine Referenz in/aus einer Variablen.
Mein Problem ist das eigentliche Schreiben.
Ich kann mir nicht vorstellen, dass das Schreiben in eine Queue schneller ist als das Schreiben in ein Array.
Aber ein Versuch kann nicht schaden!
Ich werde wohl überlegen müssen, wie ich direkt auf den Speicher, wo die Kamera das Bild hinterlegt zugreifen kann!
RE: Schneller Umgang mit großen Arrays - eb - 22.09.2011 15:14
Also vielleicht grundsätzlich zu großen Arrays hätte ich noch folgende Hinweise:
- wenn das Füllen mit Realdaten schneller gehen soll, dann allokiere vorher den benötigten Speicherplatz mit "Array initialisieren", zum beschreiben dann einfach bestehende (Leer-)Elemente ersetzen, oder gleich "Inplace-Struktur" ausprobieren, evtll. passt das ja auf deinen Anwendungsfall
- "Anhängen" oder ähnliche Funktionen vermeiden, da eine neue Kopie erzeugt wird, die wieder allokiert werden muss, das dauert
- zum Überprüfen wo überall eine Kopie gemacht wird, unter "Profile" (Profile) -> "Show Buffer Allocations" (Zeige Puffer Allokation?) aktivierenn und das BD untersuchen
- wenn mit dem Array Operationen durchgeführt werden müssen, auf jeden fall Neuallokationen vermeiden, wenns geht mit "Inplace"-Strukturen arbeiten.
- Zur Darstellung Array dezimieren (in diesem Fall, Auflösung verringern?)
- Sofern sinnvoll lieber größere Arrays "in einem Stück" verarbeiten als viele kleine "Chunks". Ist natürlich abhängig vom gewünschten Schleifentiming
Grüße
RE: Schneller Umgang mit großen Arrays - eb - 26.09.2011 13:13
Zitat:- Sofern sinnvoll lieber größere Arrays "in einem Stück" verarbeiten als viele kleine "Chunks". Ist natürlich abhängig vom gewünschten SchleifentimingZu meinem letzten Satz muss ich jedoch noch sagen: zeitl. ist es meist sinnvoller große Arrays zu verwenden, statt viele kleine. Allerdings ist der RAM-verbrauch so auch deutlich höher. Ist der RAM knapp, ist eine Aufteilung in Chunks sinnvoll.