Beiträge von AspirinJunkie
-
-
Bei meiner Set-Variante ist die MT-Variante beilspielsweise bei 4 logischen Prozessoren bei mir um den Faktor 3,2 schneller.
Also deutlich schneller als nur die 50% die du erwartest.
Aber im Grunde stimmts schon - wenn's nicht notwendig warum dann noch einen zusätzlichen Aufwand betreiben und neue Unwägbarkeiten mit reinholen.
-
byte[col] = 4 (nachdem alle Threads fertig sind)
Nicht unbedingt.
Inkrement funktioniert (falls es kein atomares inkrement ist) so:- aktuellen Wert aus Speicher auslesen
- im Register addieren
- Neuen Wert schreiben
Gehen wir doch mal einen möglichen Fall das 4 Threads gleichzeitig die selbe Farbe haben durch:
- Thread 1 liest aus -> 0
- Thread 2 liest aus -> 0
- Thread 1 addiert 1 im Register (Registerwert = 1)
- Thread 3 liest aus -> 0
- Thread 2 addiert 1 im Register (Registerwert = 1)
- Thread 1 schreibt seinen Wert zurück in den Speicher -> 1
- Thread 4 liest aus -> 1
- Thread 2 schreibt seinen Wert zurück in den Speicher -> 1
- Thread 3 addiert 1 im Register -> (Registerwert = 1)
- Thread 3 schreibt seinen Wert zurück in Speicher -> 1
- Thread 4 addiert 1 im Register -> (Registerwert = 2)
- Thread 4 schreibt seinen Wert zurück in den Speicher -> 2
Heißt: 4 Threads haben einen Anfangswert von 0 inkrementiert und nachdem alle fertig sind steht als Ergebnis eine 2 da.
Die nächste Frage ist wie man das Überlaufproblem behandelt. Bei homogenen Bildern wo eine Farbe mehr als 256x vorkommt kommt es zu einem Überlauf und es geht wieder bei 0 los.
farbcounter = 4 (nachdem alle Threads fertig sind)
Die Tatsächliche Anzahl Farben ist also: farbcounter MINUS (Summe der Bytestruct MINUS 1 für jedes Element >0) = 4 - 3 = 1
Wann bestimmst du den Moment dass gerade alle Threads fertig sind und an welcher Stelle soll die anschließende Rechnung stattfinden?
Ich arbeite bei meiner MT-Variante mit einem atomaren Inkrement+Fetch. Heißt: Es ist garantiert dass auf die Speicherstelle für den gesamten Vorgang (auslesen, inkrementieren, neu schreiben) nur ein Thread zugreift.
Anschließend wird der Farbcounter nur hochgezählt wenn das inkrement-Ergebnis 1 ist.
-
Dann musst du tatsächlich erst den entsprechenden Bereich per Binary-Funktionen herausschneiden, diesen als Integer behandeln und dort per BitAnd die entsprechenden Bits abfragen.
Edit: Hier mal fix (also nicht ausgiebig getestet) umgesetzt:
AutoIt
Alles anzeigen$sVar = "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" $b_Binary = Binary($sVar) ConsoleWrite(_GetBitOfBinary($b_Binary, 74) & @CRLF) Func _GetBitOfBinary($b_Binary, $d_BitNum) If Not IsBinary($b_Binary) Then Return SetError(1, 0, -1) If $d_BitNum < 1 Then Return SetError(2,0,-1) If BinaryLen($b_Binary) < $d_BitNum / 8 Then Return SetError(3, $d_BitNum, -1) Local $i_Byte = Floor(($d_BitNum-1) / 8) Local $i_SubBit = Mod($d_BitNum-1, 8) Local $d_Var = Int(BinaryMid($b_Binary, $i_Byte+ 1, 1)) Return BitAND($d_Var, 2^$i_SubBit) = 0 ? 0 : 1 EndFunc -
Zu deiner Funktion _getBit():
- Der Parameter $max wird nicht verwendet und kann daher weg
- Das erste Bit ist in dieser Funktion $bitcount = 0 (wie du ja auch in der Funktionsbeschreibung schreibst). Eventuell wäre es intuitiver bei 1 zu beginnen.
-
Bezüglich der "nur 24Bit": Wenn man "_GDIPlus_BitmapLockBits" mit "$GDIP_PXF32PARGB", also PARGB aufruft, dann werden die Alphawerte doch vorher auf die RGB-Werte umgerechnet und somit müsste die Anzahl der Farben wieder stimmen, oder liege ich da falsch?
Naja kommt halt darauf an was du genau zählen willst.
Der Alpha-Channel ist kein Farbwert an sich - klar. Aber er beeinflusst dennoch die Darstellung des jeweiligen Pixels.Jetzt ist die Frage ob man diese Info dazuzählen möchte oder lediglich das Endergebnis auf einem homogenen Hintergrund wichtig ist.
Wenn man den Alphachannel als eigenständigen Kanal betrachten will dann kann PARGB hingegen nicht die Lösung sein.
Wir haben in diesem Fall eine surjektive Abbildung von 32Bit auf 24Bit -> also einen Informationsverlust.
Unterschiedliche Ausgangswerte können also gleiche Ergebniswerte produzieren, was dazu führt, dass eigentlich unterschiedliche Farbwerte fälschlicherweise als gleichfarbig gezählt werden.Also wie gesagt: Was willst du genau zählen bzw. wozu brauchst du es?
-
Mit Binary wirst du nicht weiterkommen.
Das richtige Tutorial hast du ja schon gefunden.
Musst es im Grunde nur noch anwenden - dann könntest du auf z.B. sowas kommen:AutoIt$sVar = "FF0F" $dNumber = Dec($sVar) ConsoleWrite($dNumber & @CRLF) ; Schrittweise alle Bits abfragen: For $i = 0 To 31 ConsoleWrite("Bit " & $i+1 & ": " & (BitAND($dNumber, 2^$i) <> 0) & @CRLF) NextIm Grunde musst du nur die Zahl aus der du ein bestimmtes Bit haben willst mit einer anderen Zahl bitweise Und-verknüpfen wo ausschließlich dieses gewünschte Bit gesetzt ist.
Das Ergebnis ist nur dann 1 wenn in der Ausgangszahl dieses Bit auf 1 gesetzt ist.
-
Multi-Threading wird bei dieser Lösung wohl fast keinen großen Sinn machen.
Warum? Nun wir haben hier den klassischen Fall von Race-Conditions.
Schauen wir uns mal den wichtigen Codeausschnitt an:
Cfor(int i = 0; i < len; i++) { if (colors[aPixel[i] & 0xffffff] == 0){ colorSum++; colors[aPixel[i] & 0xffffff] = 1; } }Was passiert in einem besonders blöden Fall:
- Thread 1 hat ein Pixel mit der Farbe 0 (schwarz also).
- Thread 1 fragt an der entsprechenden Stelle im Array colors nach ( [0] ) und vergleicht dort auf 0 -> Ergebnis: Es ist noch 0
- Also springt Thread 1 in den True-Case der If-Verzweigung
- In der Zwischenzeit hat Thread 2 ebenfalls ein Pixel der Farbe 0 und testet gegen das Array colors -> und siehe da: Noch ist der Wert dort ebenfalls noch 0 da Thread 1 ja noch nicht geschrieben hat und springt ebenfalls in den True-Case
- colorSum wird dann einmal von Thread 1 als auch nochmal von Thread 2 inkrementiert.
- Die Farbe schwarz wurde also fälschlicherweise doppelt gezählt!
- Unser Ergebnis wird also höher sein als das korrekte.
Nun wie kann man das nun verhindern?
Im Grunde durch Locks oder atomare Prozeduren.Der Lock müsste im Grunde aber auf die ganze If-Abfrage gesetzt werden. Da damit der gesamte Schleifeninhalt hierbei als nichtparallel definiert wird kann man sich diese Lösung ergo aber schenken wenn man das ganze parallelisieren möchte.
Atomare Typen und Prozeduren als Alternative hierzu bringen hingegen soviel Overhead mit, dass der Geschwindigkeitsvorteil durch die Parallelisierung davon wieder mehr als aufgefressen wird.
Kurz: Auf Anhieb hab ich keine Lösung wie man bei einer Parallelisierung korrekte Werte erhält und dennoch einen Performancezuwachs gegenüber der Single-Thread-Variante erwarten kann. Vielleicht finde ich noch ne Lösung - mal schauen.
Die Multithread-Variante die zwar fix ist aber leicht falsche Ergebnisse produziert habe ich mal zum Nachvollziehen in der DLL belassen.
Edit: So nun doch eine Variante gefunden welche zumindest bei großen Bildern bessere Performance liefern kann und dennoch korrekte Werte liefert (über die Windows-API-Funktion InterlockedIncrement16 umgesetzt).
Oh super. Blöd nur dass wir bis jetzt nicht wissen warum die erste DLL bei dir nicht funktioniert hat.
Ich glaube nicht, dass MT hier noch was bringt bzw. MT sich richtig lohnt.
Warum nicht?
-
Wie würde die Multi-Thread-Version wohl mit der Array-Methode aussehen?
Zeig mir mal den Single-Thread Code und ich füg ihn noch als Threaded-Version der DLL hinzu.
-
Habe der DLL mal noch eine Multithread-Version hinzugefügt.
Hätte nicht gedacht dass es viel ausmacht aber gerade bei großen Bildern bringt es wirklich einen großen Unterschied.Siehe Anhang
-
Laut Bildbetrachter XnView sind es 103240 Farben - ein bischen Schwund ist immer
[...]
Anzahl Farben: 99394 (in XnView: 99375)
XnView zählt mal mehr, mal weniger als diese Funktion. (Wer zählt von Hand nach? )Ist der selbe Grund wie hier schon vorher genannt. Liegt am JPEG-Decoder der unterschiedliche Ergebnisse produziert.
Lass dir die Datei in XNView mal als PNG ausgeben dann sollten die Zahlen bei beiden übereinstimmen.
-
Ok dann weiß ich es spontan auch nicht.
Hab es hier auf Win10 x64 laufen und es läuft sowohl als x64 als auch als x86 dll.Eventuell hab ich gegen eine Win10-API gelinkt. Nutzt du Windows 10 oder vielleicht was anderes?
Heute komm ich aber sicher nicht mehr dazu genauer nachzuschauen - wenn dann morgen Abend.Edit: Hab es gerade auf einem Win 8.1 x64 probiert: Nachdem ich die VS 2017 Redistributables installiert habe lief es auch dort.
Kann es eventuell nochmal jemand anderes versuchen? -
Eventuell fehlen die Visual C++ 2017 Runtimes?
Also von hier ganz unten: https://www.visualstudio.com/de/downloads/
-
Ich bin mal ganz naiv rangegangen und dachte mir: Es gibt ne Set in C++ - warum nicht einfach die nutzen?
So ist der Code brutal simpel:
C
Alles anzeigen#include <windows.h> #include <unordered_set> extern "C" __declspec(dllexport) int __stdcall count_colors(int len, int *aPixel ) { std::unordered_set<int> setOfColors(aPixel, &aPixel[len]); return static_cast<int>(setOfColors.size()); } BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved) { switch (reason) { case DLL_PROCESS_ATTACH: break; case DLL_PROCESS_DETACH: break; case DLL_THREAD_ATTACH: break; case DLL_THREAD_DETACH: break;} return TRUE; }Das Ergebnis in Form zweier DLL liegt im Anhang.
Bei kleinen Bildern könnte der Code fix sein.
Bei größeren Bildern womöglich langsamer als die vorgestellten Lösungen.Auch wenn es vielleicht nicht die Performance-Bestmarke knackt: Viel einfacher geht es im Grunde nicht mehr.
Da ich bisschen neidisch auf die hier vorgestellten ASM-Lösungen schiele wollte ich dennoch noch was hier beitragen.
Edit: Ach ja: 32 Bit-Bilder funktionieren hiermit ebenfalls.
-
Gibt es eigentlich Assembler-Befehle bzw. -Routinen, mit denen man auf Basis von AssembleIt eine Datei einlesen und schreiben kann?
Dir ist es zu mühselig das FileRead in deinem Programm entsprechend anzupassen aber mal einfach die File-Prozeduren durch Assemblercode zu ersetzen stellst du dir einfacher vor?
Zum Thema Assemblerfilefunktionen: Möglich natürlich und sicher auch schon irgendwo vorhanden. Aber da man ja in ein bestimmtes FileSystem schreibt wird man die entsprechenden System-API-Funktionen hierfür ansprechen. Also genau das was auch die File-Funktionen von AutoIt machen - nur anders verpackt.
-
1. Du bist im Forum zu AutoIt und stellst eine Frage zu PHP. Wir haben jedoch extra für sowas ein Unterforum "Andere Programmiersprachen".
2. Hast du mal einen Beispielaufbau der fraglichen Tabelle "Mitarbeiter", so dass man sehen kann was du wie berechnest?
Hintergrund: Ich würde gern sehen warum es nötig sein sollte ist die Daten rauszuziehen, außerhalb zu bearbeiten und wieder in die Datenbank zu schreiben anstatt einfach direkt in der Datenbank die Daten entsprechend aufzubereiten.Weil ich denk da an sowas in der Art:
-
-
aber bei Yaw bin ich mir nicht so sicher, wenn ich immer +90 hinzufüge wirds wohl nicht ganz stimmen, ihr habt doch bestimmt ne bessere Lösung als +90 oder?
Naja +90 ist schon ok. Aber dann folgt noch eine Bereichsabfrage, damit man die daraus entstehenden Fälle über 180° korrekt behandelt.
Da es aber 90°-Differenzen zum normalen Arkustangens sind, kann man alternativ auch durch entsprechendes umstellen der Parameter von atan2 eine Drehum um 90° erreichen.
Entspricht dies dem was du erreichen möchtest?:
AutoIt
Alles anzeigenIf Not IsDeclared("PI") Then Global Const $PI = ACos(-1) Global Const $rad2deg = 180.0 / $PI Global Const $deg2rad = $PI / 180.0 ; Koordinaten Global $pt_A = [0, 0, 0] ; Kamerakoordinaten [X,Y,Z] Global $pt_B = [5, 5, 5] ; Punktkoordinaten [X,Y,Z] Global $f_Yaw = _calcYaw($pt_A, $pt_B) Global $f_Pitch = _calcPitch($pt_A, $pt_B) ConsoleWrite(StringFormat("% 10s: % 7.2f°\n% 10s: % 7.2f°\n", "Yaw", $f_Yaw * $rad2deg, "Pitch", $f_Pitch * $rad2deg)) #Region Funktionen Func _calcYaw($pt_From, $pt_To) Return atan2($pt_To[0] - $pt_From[0], -($pt_To[1] - $pt_From[1])) EndFunc ;==>_calcYaw Func _calcPitch($pt_From, $pt_To) Local $f_R2D = Sqrt(($pt_To[0] - $pt_From[0])^2 + ($pt_To[1] - $pt_From[1])^2) ; der Abstand auf der X-Y-Ebene Return -atan2($pt_To[2] - $pt_From[2], $f_R2D) EndFunc ;==>_calcPitch Func atan2($y, $x) If $y = 0 And $x < 0 Then Return $PI Return (2 * ATan($y / ($x + Sqrt($x * $x + $y * $y)))) EndFunc ;==>atan2 #EndRegion Funktionen -
Das ist immer recht fraglich. Mal reicht tatsächlich die vordefinierte Variable, mal muss sie als Pointer übergeben werden. Das sind dann die Dinge, die mit Trial&Error erledigt werden.
Hehe - exakt deswegen habe ich es so vorsichtig formuliert.
Eh ich mir lange dazu den Kopf zerbrochen hätte, hätte ich es einfach mal getestet.
Geht hier nur leider nicht.
TheDude - lass dir mal testweise $aRet per _ArrayDisplay() ausgeben. So kannst du herausfinden ob dein gesuchter Wert dann in $aRet[3] steht.Oops, hast natürlich recht - ich wollte eigentlich "BOOL" verwenden, also den 32 Bit Typ.
Ach guck an - hatte ich auch nicht mehr auf dem Schirm dass es da einen ähnlich benannten Typ als 32 Bit-Variante gibt.
-
Laut der Beschreibung wird dort als boolean ein 32 Bit-Integer verwendet - oder?
Dann würde ja der Rückgabewert und der 4. Parameter nicht passen da boolean in DLLCall ein 8 Bit-Wert darstellt.
Ich denke daher dass man für den Rückgabewert und den 4. Parameter daher stattdessen INT verwenden sollte.
Und zu dem 3. Parameter: Kann mich irren aber spontan hätte ich Double* statt Double verwendet.
-
Um die Frage abschließend zu klären fehlen ein paar wichtige Infos.
Vor allem wie denn deine eingezeichneten Winkelangaben im Koordinatensystem liegen.
Sprich: In welche Richtung zeigt denn die X bzw. Y-Achse?
Ansonsten sagst du dass du falsche Ergebnisse erhälst.
Was ist konkret falsch daran?
Was wären denn die richtigen Ergebnisse?
Mit den bisherigen Angaben und ein paar notwendigen Annahmen meinerseits hätte ich so angefangen:
AutoIt
Alles anzeigenIf Not IsDeclared("PI") Then Global Const $PI = ACos(-1) Global Const $rad2deg = 180.0 / $PI Global Const $deg2rad = $PI / 180.0 ; Koordinaten Global $pt_A = [0, 0, 0] ; Kamerakoordinaten [X,Y,Z] Global $pt_B = [5, 5, 5] ; Punktkoordinaten [X,Y,Z] Global $f_Yaw = _calcYaw($pt_A, $pt_B) Global $f_Pitch = _calcPitch($pt_A, $pt_B) ConsoleWrite(StringFormat("Yaw: % 6.2f°\nPitch: % 6.2f°\n", $f_Yaw * $rad2deg, $f_Pitch * $rad2deg)) #Region Funktionen Func _calcYaw($pt_From, $pt_To) Local $Yaw = atan2($pt_To[1] - $pt_From[1], $pt_To[0] - $pt_From[0]) Return $Yaw EndFunc ;==>_calcYaw Func _calcPitch($pt_From, $pt_To) Local $f_R2D = Sqrt(($pt_To[0] - $pt_From[0])^2 + ($pt_To[1] - $pt_From[1])^2) ; der Abstand auf der X-Y-Ebene Local $Yaw = atan2($pt_To[2] - $pt_From[2], $f_R2D) Return $Yaw EndFunc ;==>_calcPitch Func atan2($y, $x) Return (2 * ATan($y / ($x + Sqrt($x * $x + $y * $y)))) EndFunc ;==>atan2 #EndRegion Funktionen