LabVIEWForum.de

Hallo zusammen,

ich hoffe ich habe das richtige Forum für diese Frage erwischt.
Ich habe ein Performanceproblem und bräuchte dazu ein paar Tipps. Ich bin kein richtiger LabVIEW Neuling mehr, aber über "Optimales" Programmieren musste ich mir bis jetzt nicht so viele Gedanken machen....

Die Aufgabe:

ich habe ein array mit 6553600 Werten (16 bit numeric) die aus einer Queue ausgelesen werden (zuvor wurden sie mit einer A/D Karte aufgenommen und Bufferweise in die Queue gesteckt, aber ich denke das ist nebensächlich)
nun soll auf das Signal getriggert werden und danach "sortiert" um das neue array dann wieder in eine Queue zu stecken (zur Weiterverarbeitung).
Bisher habe ich das mit einer while-schleife und mit der "built array" Funktion gelöst. Also while-Schleife mit shift registern. Habe dazu ein Bild angehängt (aufs wesentliche beschränkt).
Nachdem ich jetzt das Problem habe, das mein Programm insgesamt zu langsam ist (Queue läuft irgendwann voll...) habe ich versucht mich schlau zu machen wo ich optimieren kann und bin zu dem Schluss gekommen, das hier vielleicht die richtige Stelle ist
Ich habe gelesen das die "built array" Funktion nicht optimal ist weil der Speicher bei jedem durchlauf neu zugeordnet werden muss. Deswegen habe ich versucht das ganze mit "replace array subset" zu lösen. Das erscheint mir jetzt aber noch weniger schnell zu sein (vielleicht hab ich das einfach schlecht gelöst... hab auch dazu ein Bild angehängt).

Habe ich das einfach ungeschickt gemacht, oder ist in dem Fall die "built array" funktion doch die bessere? Oder gibt es noch irgendeine andere Möglichkeit, auf die ich noch nicht gekommen bin? Bin für jeden Tipp dankbar!

nur Vollständigkeitshalber: Ich verwende LabVIEW 2009

Grüße,
Christian

Hallo tinger,

ich kann dir nicht ganz folgen, da der gepostete Code unvollständig ist. Du sagst, im Puffer liegen 6553600 Elemente, warum liest du einmal 1000 und einmal alles aus? Warum initialisiert du bei der Variante Array Subset zwei neue Arrays und nimmst nicht stattdessen das bereits vorhandene? Bitte poste den vollständigen Code.

Hallo schrotti,

Danke das du versuchst mir zu helfen!
die "1000" bzw. "-1" sind nur der timeout vom queue auslesen, ich bekomme also immer ein array mit den 6553600 Werten aus der queue.
Das mit den zwei arrays mache ich, weil ich glaube anders nicht an das selbe ergebnis wie beim "built array" zu kommen, aber vielleicht liegt da mein denkfehler...

Ich kann gerne den ganzen code posten, aber ich glaube das hilft nicht, weil es nur verwirrt (da unten ist die relativ komplizierte trigger suche).

Der linke Draht der nach unten führt bringt dazu das array nach unten, wo dann in die "trigger"-Variable geschrieben wird. Im Falle vom "built array" kommt dann von unten nur noch die Referenz auf die neue queue (die zur Weiterverarbeitung). Im falle des "reshape array" geht rechts der Draht mit dem array nach unten um genauso in die neue queue gesteckt zu werden (hab ich dummerweise nicht genauso angeordnet... hoffe das verwirrt nicht zusätzlich).

Also was mein Problem angeht passiert da unten eigentlich gar nichts mehr

Wird einigermaßen klar was ich mit dem "built array" erreichen möchte (ich denke das ist die leichter lesbare code-Variante)? Genau das gleiche versuche ich danach mit dem "reshape array subset"...

Array sind immer einwenig tricky. Wenn mir etwas nicht klar ist wie es funktioniert, arbeite ich in einem seperaten .vi mit der Funktion weiter (z.B manipulieren oder füllen von Arrays) und füge diese erst später wieder ein.


lg

Mein Fehler. Das ist natürlich der Timeouteingang. Teil das vorhandene Array auf und füge die zwei Arrays dort wieder ein.

Jetzt kann ich dir nicht mehr ganz folgen. Wo soll ich die zwei arrays wieder einfügen?
Vielleicht nochmal zur Erklärung, was ich tun möchte:
gehen wir davon aus ich bekomme erst das array
aaaaa1bbb
, dann das array
ccccc1ddd
und dann
eeeee1fff, wobei a, b, c, d, e und f beliebige werte sind und 1 den wert markiert, an dem der trigger festgestellt wurde. Dann soll meine schleife daraus
1bbbccccc
1dddeeee
usw. machen

ich denke das "built array" macht das auch, oder?
die frage ist nur, geht das mit array reshape subset vielleicht besser (oder mit einer dritten möglichkeit)

Ob das mit "Replace Array Subset" schneller geht musst du ausprobieren. Ich frage mich nur, warum du so viele Arrays anlegst. Du hast das Array A[]. Weiterhin bildest du mittels des Inhalts von A[] die Teilarrays B[] und C[]. Aus B[] und C[] baust du nun wieder irgendwelche Arrays, obwohl doch B[] und C[] zusammen exakt die Größe von A[] haben, du also bloß den Inhalt von A[] überschreiben musst. Hier mal ein Bild.

[attachment=31574]

Ah, da haben wir uns noch nicht ganz verstanden. Im Prinzip hast du natürlich Recht, die beiden Teilarrays sind genau so groß wie das ursprungsarray, aber wenn ich sie so wie du vorschlägst zusammen setze, bekomme ich ein array mit dem triggerereignis am anfang und danach werten die eigentlich vor dem trigger signal aufgenommen wurden. Was ich aber machen will, ist die eingehenden arrays so zu "sortieren" oder "umzubauen", dass arrays herauskommen, die mit einem triggerevent beginnen und dann die werte bis zum nächsten triggerevent enthalten. Deswegen die shift register...
Ich fürchte das hab ich v.a. in meiner ersten Nachricht nicht so gut dargelegt, Entschuldigung!
Aber vielleicht macht auch das Beispiel mit den Buchstaben klar, was ich haben will. Nach dem triggerevent (1) sollen eben die werte "b" und dann die werte "c" kommen und nicht "b" und "a". Und dann komme ich mit dem "reshape array subset" glaube ich nicht um die vielen arrays rum... oder doch?

Ich denke, dass die Variante mit "Split 1D Array" nicht die schlechteste ist. Mit dem Menupunkt Tools > Profile > Show Buffer Allocations kannst Du Dir jedenfalls angucken wie oft ein Array angelegt wird.

Was mich irritiert ist die lokale Variable Trigger. Er gibt den Index an bei dem das Array geteilt wird. Den Wert berechnest Du doch aus dem gerade aus der Queue genommenen Array berechnen, oder? Diesen Wert solltest Du per Draht und nicht über die Variable anschließen. Kurzum die lokale Varible ist nicht notwendig.

Variablen sind aber nicht so schlecht für die Performance, oder?
Ich verwende sie, weil ich davon ausgehe das sich die Trigger Position nicht so schnell/drastisch verändert sondern langsam driftet... ich suche den Trigger also nicht in jedem Buffer (auch wegen der Geschwindigkeit, hoffe die Variable macht das nicht kaputt)

Mit der Methode "split 1D array" meinst du das zusammensetzen mit dem "built array", oder?