KlassenKlassenKlassenKlassen | | | | Operatoren

optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop (Operator)

Name

optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop — Überprüfen der Hardware bezüglich des Potentials zur automatischen Operator-Parallelisierung.

Signatur

optimize_aop( : : OperatorName, IconicType, FileName, ParamName, ParamValue : )

Herror optimize_aop(const char* OperatorName, const char* IconicType, const char* FileName, const char* ParamName, const char* ParamValue)

Herror T_optimize_aop(const Htuple OperatorName, const Htuple IconicType, const Htuple FileName, const Htuple ParamName, const Htuple ParamValue)

Herror optimize_aop(const HTuple& OperatorName, const HTuple& IconicType, const HTuple& FileName, const HTuple& ParamName, const HTuple& ParamValue)

void OptimizeAop(const HTuple& OperatorName, const HTuple& IconicType, const HTuple& FileName, const HTuple& ParamName, const HTuple& ParamValue)

static void HSystem::OptimizeAop(const HTuple& OperatorName, const HTuple& IconicType, const HTuple& FileName, const HTuple& ParamName, const HTuple& ParamValue)

static void HSystem::OptimizeAop(const HString& OperatorName, const HString& IconicType, const HString& FileName, const HString& ParamName, const HString& ParamValue)

static void HSystem::OptimizeAop(const char* OperatorName, const char* IconicType, const char* FileName, const char* ParamName, const char* ParamValue)

void HOperatorSetX.OptimizeAop(
[in] VARIANT OperatorName, [in] VARIANT IconicType, [in] VARIANT FileName, [in] VARIANT ParamName, [in] VARIANT ParamValue)

void HSystemX.OptimizeAop(
[in] VARIANT OperatorName, [in] VARIANT IconicType, [in] VARIANT FileName, [in] VARIANT ParamName, [in] VARIANT ParamValue)

static void HOperatorSet.OptimizeAop(HTuple operatorName, HTuple iconicType, HTuple fileName, HTuple paramName, HTuple paramValue)

static void HSystem.OptimizeAop(HTuple operatorName, HTuple iconicType, HTuple fileName, HTuple paramName, HTuple paramValue)

static void HSystem.OptimizeAop(string operatorName, string iconicType, string fileName, string paramName, string paramValue)

Beschreibung

HALCON unterstützt die automatische Parallelisierung (AOP) für eine Reihe von Operatoren. Mit optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop lässt sich eine effiziente Ausführung der Parallelisierung unabhängig von der Rechnerarchitektur gewährleisten. Daher können alle HALCON-Programme ohne Anpassungen an die Multiprozessor-Hardware durch den Benutzer verwendet werden, so dass der Benutzer leicht von dem Potential paralleler Hardware profitiert. Standardmäßig verwendet HALCON einen Thread je Prozessor für die AOP. Allerdings kann abhängig von der Datenmenge und den Parametern eines Operators die Parallelisierung auf allen verfügbaren Threads zu überzogen und ineffizient sein. optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop testet die parallele Datenverarbeitung der Operatoren und optimiert die AOP hinsichtlich der Threadanzahl. Hierfür wird jeder Operator überprüft, wie er sich auf Tupel-, Kanal- oder Domain-Ebene parallelisieren lässt (die partielle Ebene wird nicht betrachtet). Jeder dieser Operatoren wird mehrere Male ausgeführt - sequentiell wie parallel - mit unterschiedlichen Eingabeparametern und wechselnden Bildgrößen. Dadurch können Abhängigkeiten der Laufzeit des Operators von Eingabeparametern und Parallelisierung ermittelt werden. Dies kann bis zu einigen Stunden dauern, abhängig von den Parameterwerten dieses Operators. Für eine korrekte Optimierung ist es wichtig, keine anderen rechenintensiven Anwendungen gleichzeitig auf dem Rechner laufen zu lassen, da dies die Zeitmessungen des Operators stark beeinflussen und zu verfälschten Ergebnissen führen würde.

optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop sammelt eine Menge Informationen für die aktuelle Rechnerarchitektur, die es HALCON im laufenden Betrieb ermöglicht die automatische Parallelisierung zu optimieren. Dieses Wissen über die Hardware kann in einer Binärdatei, gegeben durch FileNameFileNameFileNameFileNameFileNamefileName, abgespeichert werden und in zukünftigen HALCON-Anwendungen wiederverwendet oder auf andere, ähnliche Rechner übertragen werden. Wenn ein leerer String ''"""""""""" als Dateiname übergeben wird, speichert optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop die gewonnenen Daten in die spezielle HALCON-System-Datei '.aop_info'".aop_info"".aop_info"".aop_info"".aop_info"".aop_info" unter Linux/OS X im HALCON-Installationsverzeichnis (siehe Umgebungsvariable $HALCONROOT) oder unter Windows in das Datenverzeichnis für gemeinsame Anwendungen. Diese Datei wird während der Initialisierungsphase beim Aufruf des ersten HALCON-Operators automatisch ausgelesen. Es ist zu beachten, dass die entsprechenden Zugriffsrechte für Lesen und Schreiben gesetzt sind. optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop überprüft die entsprechenden Zugriffsrechte vor dem Starten des Optimierungsprozesses und gibt im Falle des Scheiterns einen entsprechenden Fehler zurück. Die geschriebene Datei kann durch den Operator read_aop_knowledgeread_aop_knowledgeReadAopKnowledgeread_aop_knowledgeReadAopKnowledgeReadAopKnowledge wieder gelesen werden.

Es ist ausreichend, optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop einmal auf jedem Rechner auszuführen, auf dem die automatische Operator-Parallelisierung ausgeführt werden soll. Jedoch sollte der Operator erneut gestartet werden, wenn die Hardware des Rechners geändert wird, beispielsweise durch einen neue CPU, einen neuen Speicher oder ein verändertes Betriebsystem. Es ist notwendig optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop einmal für jede neue Laufzeitumgebung auszuführen, da sich das Zeitverhalten von Operatoren geändert haben könnte. Eine Veränderung der Laufzeitumgebung wird verursacht durch einen Wechsel des Betriebsystems, wie zum Beispiel Windows auf Linux, durch unterschiedliche HALCON-Architekturen, unterschiedliche HALCON-Varianten, d.h. HALCON und HALCON XL, oder wenn einen neue HALCON-Version oder -Revision aktualisiert wird. Diese Hardwareabhängigkeiten werden zusammen mit dem Computernamen gemeinsam mit den AOP-Optimierungsdaten in der Datei gespeichert. Diese Attribute ordnen einen gespeicherten AOP-Datensatz einem speziellen Recher zu und ermöglichen somit, dass AOP-Datensätze von unterschiedlichen Rechnern in der selben Datei gespeichert werden.

optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop unterstützt einen Reihe von Parametern, um das Verhalten der Optimierung zu beeinflussen. Eine Auswahl von Operatornamen kann dem Parameter OperatorNameOperatorNameOperatorNameOperatorNameOperatorNameoperatorName übergeben werden. Dadurch lässt sich der Optimierungsprozess beispielsweise auf Operatoren mit problematischen Laufzeitverhalten beschränken. Wird ein leerer String ''"""""""""" übergeben, werden alle Operatoren getestet. Der Testumfang von ikonischen Typen kann mit Hilfe des Parameters IconicTypeIconicTypeIconicTypeIconicTypeIconicTypeiconicType eingeschränkt werden. Der leere String ''"""""""""" bewirkt, dass alle unterstützten ikonischen Typen eines Operators getestet werden. Zusätzlich kann der Optimierungsprozess mit Hilfe des Parameterpaares ParamNameParamNameParamNameParamNameParamNameparamName und ParamValueParamValueParamValueParamValueParamValueparamValue beeinflusst werden. ParamNameParamNameParamNameParamNameParamNameparamName definiert dabei den Parameternamen, während ParamValueParamValueParamValueParamValueParamValueparamValue den jeweiligen Wert spezifiziert, so dass übergebene Tupel bei beiden Parametern die gleiche Länge haben müssen. Im Folgenden sind für alle Parameternamen von ParamNameParamNameParamNameParamNameParamNameparamName alle unterstützten Parameterwerte von ParamValueParamValueParamValueParamValueParamValueparamValue beschrieben:

'none'"none""none""none""none""none"

für ParamNameParamNameParamNameParamNameParamNameparamName hat keine Funktion, ignoriert aber den Parameter ParamValueParamValueParamValueParamValueParamValueparamValue.

'system_mode'"system_mode""system_mode""system_mode""system_mode""system_mode", 'file_mode'"file_mode""file_mode""file_mode""file_mode""file_mode"

setzen jeweils die Art und Weise, wie die Informationen im HALCON-System b.z.w. der Datei aktualisiert werden sollen.

'truncate'"truncate""truncate""truncate""truncate""truncate"

für ParamValueParamValueParamValueParamValueParamValueparamValue löscht alle bestehenden Informationen, bevor das neue Wissen hinzugefügt wird.

'renew'"renew""renew""renew""renew""renew"

überschreibt bestehendes Wissen und fügt neues hinzu (Standard).

'append'"append""append""append""append""append"

belässt bestehendes Operatorwissen und fügt ausschließlich Wissen hinzu, das noch nicht enthalten ist.

'nil'"nil""nil""nil""nil""nil"

führt den Optimierungsprozess durch, unterdrückt jedoch die Aktualisierung des Systems b.z.w. der Datei.

'parameters'"parameters""parameters""parameters""parameters""parameters"

testet auch laufzeitrelevante Parameter des entsprechenden Operators, falls der korrespondierende Wert in ParamValueParamValueParamValueParamValueParamValueparamValue auf 'true'"true""true""true""true""true" gesetzt ist. Es werden Parameter berücksichtig, die bedeutenden Einfluss auf die Laufzeit haben, wie beispielsweise Parameter, die eine Methode oder einen Mode des Operators die Größe eines Filters setzen. 'false'"false""false""false""false""false" unterdrückt die Überprüfung der Parameter zu Gunsten eines schnelleren Optimierungsprozesses (Standard).

'model'"model""model""model""model""model"

Setzt das zugrunde liegende Modell vom Laufzeitverhalten des parallelisierten Operators auf der aktuellen Hardware. Die Modelle, die durch den Parameter ParamValueParamValueParamValueParamValueParamValueparamValue ausgewählt werden, unterscheiden sich in ihrer Adaptionsfähigkeit an Hardwareeigenheiten und dem Rechenaufwand sie zu bestimmen:

'threshold'"threshold""threshold""threshold""threshold""threshold"

ermittelt für einen Operator, ob es sich rentiert, ihn auf der maximalen Threadanzahl zu parallelisieren. Dieses Modell ist standardmäßig auf Dual-Prozessor-Systemen eingestellt.

'linear'"linear""linear""linear""linear""linear"

spezifiziert ein lineares Skalierungsmodell, um die effizienteste Threadanzahl für einen Operator mit einer gegebene Datenmenge und Parametersatz. Dies ist der Standard auf Multi-Prozessor-Systemen.

'mlp'"mlp""mlp""mlp""mlp""mlp"

ist das komplexeste, aber auch das anpassungsfähigste Model. Der Optimierungsprozess kann allerdings abhängig von der verwendeten Hardware einige Stunden dauern.

'timeout'"timeout""timeout""timeout""timeout""timeout"

setzt die maximale Ausführungszeit für einen Testoperator. Falls die Laufzeitmessung eines Operators den Timeout überschreitet, wird der Test des Operators abgebrochen. In diesem Fall werden keine Informationen über diesen Operator gespeichert. Der Timeout wird durch ParamValueParamValueParamValueParamValueParamValueparamValue in Sekunden definiert. Der Wert 'infinite'"infinite""infinite""infinite""infinite""infinite" verhindert den Abbruch des Optimierungsprozesses eines Operators (Standard).

'split_level'"split_level""split_level""split_level""split_level""split_level"

beschränkt den Optimierungsprozess auf eine bestimmte Parallelisierungsmethode. Der entsprechende Wert in ParamValueParamValueParamValueParamValueParamValueparamValue kann einen der folgenden Werte annehmen:

'split_domain'"split_domain""split_domain""split_domain""split_domain""split_domain"

führt die Optimierung auf allen bildverarbeitenden Operatoren durch, die eine Datenparallelisierung auf Domainebene unterstützen.

'split_channel'"split_channel""split_channel""split_channel""split_channel""split_channel"

führt die Optimierung auf allen bildverarbeitenden Operatoren durch, die eine Datenparallelisierung auf Kanalebene unterstützen.

'split_tuple'"split_tuple""split_tuple""split_tuple""split_tuple""split_tuple"

führt die Optimierung auf allen bildverarbeitenden Operatoren durch, die eine Datenparallelisierung auf Tupelebene unterstützen.

Achtung

Während der Tests muss optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop jeden zu optimierenden Operator mehrere Male aufrufen. Abhängig von den Parameterwerten kann daher die Ausführzeit von optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop sehr lang sein. Es ist daher für eine korrekte Optimierung essentiell, keine weiteren rechenintensiven Anwendungen gleichzeitig auf dem Rechner laufen zu lassen, da diese die Zeitmessungen für die Optimierung deutlich beeinflussen und zu falschen Ergebnissen führen würden. optimize_aopoptimize_aopOptimizeAopoptimize_aopOptimizeAopOptimizeAop muss durch entsprechend autorisierte Benutzer aufgerufen werden, damit die gesammelten Informationen dauerhaft gespeichert werden können (Details hierzu finden sich in der obigen Operatorbeschreibung).

Parallelisierung

Parameter

OperatorNameOperatorNameOperatorNameOperatorNameOperatorNameoperatorName (input_control)  string(-array) HTupleHTupleHTupleVARIANTHtuple (string) (string) (HString) (char*) (BSTR) (char*)

Zu testende Operatoren.

Defaultwert: '' "" "" "" "" ""

IconicTypeIconicTypeIconicTypeIconicTypeIconicTypeiconicType (input_control)  string(-array) HTupleHTupleHTupleVARIANTHtuple (string) (string) (HString) (char*) (BSTR) (char*)

Zu testende Objekttypen.

Defaultwert: '' "" "" "" "" ""

Wertevorschläge: ''"""""""""", 'byte'"byte""byte""byte""byte""byte", 'int1'"int1""int1""int1""int1""int1", 'int2'"int2""int2""int2""int2""int2", 'uint2'"uint2""uint2""uint2""uint2""uint2", 'int4'"int4""int4""int4""int4""int4", 'int8'"int8""int8""int8""int8""int8", 'direction'"direction""direction""direction""direction""direction", 'cyclic'"cyclic""cyclic""cyclic""cyclic""cyclic", 'vector_field'"vector_field""vector_field""vector_field""vector_field""vector_field", 'complex'"complex""complex""complex""complex""complex", 'region'"region""region""region""region""region", 'xld'"xld""xld""xld""xld""xld", 'xld_cont'"xld_cont""xld_cont""xld_cont""xld_cont""xld_cont", 'xld_poly'"xld_poly""xld_poly""xld_poly""xld_poly""xld_poly"

FileNameFileNameFileNameFileNameFileNamefileName (input_control)  filename.write HTupleHTupleHTupleVARIANTHtuple (string / integer) (string / int / long) (HString / Hlong) (char* / Hlong) (BSTR / Hlong) (char* / Hlong)

Dateiname.

Defaultwert: '' "" "" "" "" ""

ParamNameParamNameParamNameParamNameParamNameparamName (input_control)  string(-array) HTupleHTupleHTupleVARIANTHtuple (string) (string) (HString) (char*) (BSTR) (char*)

Parameter-Name.

Defaultwert: 'none' "none" "none" "none" "none" "none"

Wertevorschläge: 'parameters'"parameters""parameters""parameters""parameters""parameters", 'model'"model""model""model""model""model", 'timeout'"timeout""timeout""timeout""timeout""timeout", 'file_mode'"file_mode""file_mode""file_mode""file_mode""file_mode", 'system_mode'"system_mode""system_mode""system_mode""system_mode""system_mode", 'split_level'"split_level""split_level""split_level""split_level""split_level"

ParamValueParamValueParamValueParamValueParamValueparamValue (input_control)  string(-array) HTupleHTupleHTupleVARIANTHtuple (string / real / integer) (string / double / int / long) (HString / double / Hlong) (char* / double / Hlong) (BSTR / double / Hlong) (char* / double / Hlong)

Parameter-Wert.

Parameteranzahl: ParamName == ParamValue

Defaultwert: 'none' "none" "none" "none" "none" "none"

Wertevorschläge: 'true'"true""true""true""true""true", 'renew'"renew""renew""renew""renew""renew", 'truncate'"truncate""truncate""truncate""truncate""truncate", 'threshold'"threshold""threshold""threshold""threshold""threshold", 'linear'"linear""linear""linear""linear""linear", 'mlp'"mlp""mlp""mlp""mlp""mlp", -1.0

Ergebnis

Sind die Parameterwerte korrekt, dann liefert read_aop_knowledgeread_aop_knowledgeReadAopKnowledgeread_aop_knowledgeReadAopKnowledgeReadAopKnowledge den Wert 2 (H_MSG_TRUE). Gegebenenfalls wird eine Fehlerbehandlung durchgeführt.

Modul

Foundation


KlassenKlassenKlassenKlassen | | | | Operatoren