Hallo Zusammen, ich hab mal wieder einen Plan, der sich einfach anhört, dessen Umsetzung mich aber ganz schön ins Grübeln bringt:
Ich hab ein dynamisches Stringarray mit ca. 15000 Elementen je etwa 30-80 Zeichen, unsortiert. (könnte es aber vorher auch mit fester Größe declarieren)
Dieses Array sortiere ich mit Quicksort nach Vorlage aus der Profanhilfe. Jedoch sortiere ich nur nach den ersten 8 Zeichen, die ich mit left$() ermittle.
Kompiliert benötigt mein Programm dafür ca. 14 Sekunden. Das ist mir zu langsam.
Kam deshalb auf die Idee, das Sortieren mit PureBasic über eine DLL zu erledigen, in der Hoffnung, mehr Speed beim Sortieren rauszuholen.
Zum Üben & Testen hab ich einfach mal in dieser DLL eine Funktion gebaut, die in einer von Profan erstellten StringVariable, dessen Adresse ich der DLL übergeben habe, ein paar Zeichen ausgetauscht habe (also replace). Das hat funktioniert.
Das ermitteln der Adresse des Arrays gelingt mir aber nicht (z.B. Addr(array$[])). Profan bricht dann mit einer Fehlermeldung ab, gefolgt von weiteren Fehlermeldungen, die den Speicherzugriff betreffen. Auch mit einem Strukturierten Array (array#()) klappt es nicht.
Glaube deshalb, daß ich vom Ansatz her auf dem Holzweg bin.
Also wie kann ich einer API/DLL ein mit Profan erzeugtes Array übergeben?
Array-Zeiger/Adresse bzw. Array an .dll übergeben
-
-
- Gerade eben
- Anzeige
Hallo!
Wenn du gerade an deiner Website arbeitest oder dein aktuelles Hosting überdenkst: Wir betreiben mit NetzLiving eine Hosting-Plattform, die speziell auf Performance, Sicherheit und einfache Verwaltung ausgelegt ist.
- ✔️ Schnelle Ladezeiten (optimiert für WordPress, WoltLab & Co.)
- ✔️ Deutsche Server & DSGVO-konform
- ✔️ Persönlicher Support (kein 0815-Ticket-System)
-
Hast du es mal ohne Addr() versucht ?
Denke mal, daß Arrays sowieso byRef, also
per Referenz übergeben werden.
PS: Wie schnell ist es denn mit Profans eigener ListboxListe ?
Da könnte man doch mit MoveListToArr() und MoveArrToList
hantieren. Auch die unsichtbare
@Create("List", T) wäre interessant. Dort könnte man dann
auch mit den Move-Befehlen rüber und zurück schieben.
Beide Listboxen gibt's ja auch sortiert.
-
Hallo Heinz, ok das mit den Verschieben in eine sortierte Liste & zurück wäre ein Versuch Wert. Spiel ich mal durch.
ZitatHast du es mal ohne Addr() versucht ?
werde ich sicherheitshalber auch noch mal testen - war mir nicht sicher, wie Array's innerhalb Profan übergeben werden.
Danke für die Anregungen
Verfolge inzwischen einen anderen Ansatz - ist kurz vorm ersten Testlauf:
1. mit Profan das Array per Schleife in einen Speicherbereich wuchten (mit string$, Nullbyte ist also der Trenner)
2. Die Adresse des Bereichs der DLL übergeben.
2a. Die DLL erzeugt selbst ein temporäres Array & ließt den Speicherbereich dort ein.
2b. Dann sortiert die DLL das Array & schreibt das sortierte Array wieder in den Speicherbereich zurück.
3. mit Profan die Strings wieder aus dem (jetzt sortierten) Speicherbereich in das Array schreiben.Von der Logik her sollte es funzen. Mal schauen, wie die Gesamtlaufzeit aussieht.
Egal, wie es ausgeht, werde ich deine beiden Vorschläge ebenfalls testen, dann vergleichen & ggf. die schnellste Variante verwenden.
Werde das Ergebnis dann hier auf jeden Fall kund tun. Brauch nur ein wenig Zeit - bis später...
-
Ich denke, daß du da wieder Zeit verlierst,
besonders bei Punkt 2.a.
Das sind ja 15000 Elemente.
-
So, kleiner Zwischenstand:
1. Es gibt keine Möglichkeit, ein Array direkt an einer dll zu übergeben. Der Grund dafür könnte sein, das jede Programmiersprache seine eigene "Array-Architektur" hat.2. Ich habe keine Möglichkeit gefunden, eine mit Create("List",1) erstellte Liste via Move-Funktion zu beschicken & umgekehrt. Die betreffenden Move-Funktionen beziehen sich nur auf die interne Listboxliste, die sich aber nicht sortieren läßt.
3. Ich konnte die Sortiergeschwindigkeit mit Quicksort auf ca. 7-8 Sek. bei gleicher Datenmenge verbessern, indem ich zum sortieren einfach den gesamten String zum Vergleichen verwende & nicht, wie zuvor, nur die ersten 8 Zeichen zum Vergleichen heranziehe (die Left$()-Funktion war also eher eine Bremse. Ich dachte, 8 Zeichen vergleichen geht schneller als 40 Zeichen.)
4. Die einzige Methode, ein Array an einer API zu übergeben ist: dieses zuvor in einen Bereich zu kopieren & die Adresse des Bereichs der API übergeben. Den Rest muß man dann in der dll programmieren, was ja auch grundsätzlich geht.
Habe die 4. Möglichkeit mal Testweise, wie in #3 grob beschrieben programmiert & die Zeit gemessen:
Das Kopieren vom Array in den Speicherbereich & umgekehrt dauert mit Profan jeweils ca. 2 Sek (also 4 sek. für die Kopierarbeit).
Die dll kopiert die Daten dann ebenfalls aus dem Bereich in ein eigenes temporäres Array, sortiert dieses & kopiert die sortierten Daten wieder in den selben Bereich.
Dies dauert zusammen ca. 200 ms (höchstens 300 ms). Das ist (für mich) ein super Ergebnis. Insgesamt ist die komplette Sortieraktion also in ca. 4 Sek. erledigt, was ja schon mal ganz erfreulich ist. Aber ich denke, da geht noch was...
Die Reserven liegen also in den Kopieroutinen, die ich mit Profan geschrieben habe:CodeProc fuell_bereich 'füllt ein speicherbereich mit den inhalt des arrays star$[], 'welches zuvor mit ca. 14000 elementen a 30-40 Zeichen gefüllt wurde Declare p& Dim ber#,SizeOf(star$[])* 41 'bereich dimmen (anz. der elemente x 41 Zeichen pro Element(max, incl. pipe+nullbyte)) WhileLoop 1,z& Inc p&,Len(star$[&loop - 1]) + 2 'offsetposition für den akt. string berechnen String ber#,p&,star$[&loop] 'startadresse = länge des letzen strings + 1 nullbyte + 1 = startadr. des akt. strings EndWhile EndProc
Jetzt macht die DLL ihren Kram...
...und jetzt wieder mit Profan aus dem Bereich ins Zielarray:CodeProc lese_bereich 'liest den speicherbereich aus & schreibt die elemente in ein array Declare p& Clear erg$[] WhileLoop 1,z& Inc p&,Len(erg$[&loop - 1]) + 2 erg$[&loop] = @string$(hber&,p&) 'startadr. = länge des letzten strings + 1 nullbyte + 1 = startadr. des nächsten strings EndWhile EndProc
Wie könnte man diese Routinen noch optimieren? (also schneller machen)
Warum jetzt der ganze Aufriss wegen paar Sekunden? Dieser Programmteil wird relativ oft aufgerufen & es können auch mal schnell 30000 unsortierte Elemente sein. Diese "Sortierpausen" sind dann einfach nervig & deshalb möchte sie so kurz wie möglich halten. -
ich könnte mit vorstellen, daß das Kopieren vom Array in den Speicher & umgekehrt mit reinen Delphi deutlich schneller gehen würde, als mit einer Profanschleife.
Wäre das nicht eine nette Ergänzung der Move-Funktionen für die nächste Profanversion? Anwendungsbereiche für sowas gibt es sicherlich genug. Stell mir das in etwa so vor:
Der Parameter für das Trennzeichen (Sep$) kann dann beliebig definiert werden. Z.B. Pipe oder Chr$(0) für Nullbyte etc.Wäre das was für die Rubrik "Anregungen/Vorschläge"?
-
Würde ich doch sagen. Das kann man immer wieder mal gebrauchen, auch um Arrays schnell in Datei und zurück zu schreiben.
Gruß Volkmar
-
Machs doch gleich mit einer Liste.
Wenn es doch ein Array sein soll, mach es über den Weg der Listboxliste.
so könnte das aussehen :
-
Erfahrungen aus Profan-11, vielleicht übertragbar?: Fest deklarierte Arraygröße führt (anders als bei Dynamischen Arrays) zu durchgängiger Belegung von Memory, also quasi Memorybereichen. Die Startadresse entspricht der Addr() des nullten Elements. Zweidimensionale Arrays (aka "Matrizen") werden spaltenweise (=Zeilenindex in Innenschleife) im aufsteigenden Speicherbereich abgelegt, wobei ja beim Zugriff mit der Elementgröße (&=4, !=8, $=Pointer&) zu multiplizieren ist.
Stringarrays bestehen aus den Startadressen der Strings, die selber aber kunterbunt im Speicher liegen, bei XP und 7 nach dem Rechts-anstückeln/Links-anstückeln-System.
GrussP.S.: Suchbegriff "Jonathans Getrickse" liefert auch Interessantes dazu.
-
Danke für die Erleuchtung, Peter ;). Dies erklärt auch, weshalb man ein Stringarray nicht außerhalb des Hauptprogramms per Pointer übergeben kann.
Heinz, habe mal deinen Vorschlag durchgetestet & die Daten direkt in eine sortierte Stringliste geschickt. Das ging schneller als ich anfangs dachte.
Die gleiche Testmenge war in 3 Sek. in der Liste. Zwar 2 Sek. langsamer als das Array, aber dafür liegen die Daten auch gleich sortiert vor - nicht schlecht.
In der Hilfe las ich, das jeder mit addstring() hinzugefügter String gleich einsortiert wird & stellte mir das bei 15000 x Einfügen ziemlich langsam vor, aber - falsch gedacht
Müßte meine Soft halt an dieser Stelle von Array auf Liste umbauen. Werd ich wohl auch so machen, denn der Aufwand ist relativ gering.
Den Plan mit der DLL & Array in den Speicher hin & her kopieren leg dann erstmal auf Eis. Aber war trotzdem ein interessantes Experiment. Hab dadurch immerhin meine erste DLL gebastelt, die sogar super funktionierte & einiges über Array-Handling gelernt.
Also nochmals Danke an euch für die Beiträge.PS: Aber die Vorschläge zu den Move-Funktionen stehen trotzdem

-
Warum nicht gleich konforme Arrays erstellen? Also statisch, bei 0 geginnend und adressbereich ist durchgehend.
Alles ausser MEMORY wird nur die Adresse abgelegt.Dann klappts auch mit PureBasic, C oder ähnlichem.
-
oh, das war Überschneidung.
Zitat...Also statisch, bei 0 geginnend und adressbereich ist durchgehend...
Bist du sicher, daß das auch bei einem String-Array so ist? Bei Numerisch, fest declarierten Arrays leuchtet das ein, weil die Feldlänge ja feststeht, aber Strings können ja unterschiedlich sein. Oder gibt eine Möglichkeit, String-Arrays mit fester Feldlänge zu definieren? -
Alles ausser MEMORY wird nur die Adresse abgelegt.
Nene, Du hast den zweiten Satz nicht gelesen bzw. nicht verstanden!Es wird immer nur die Adresse gespeichert, ausser bei MEMORY und FLOAT (nicht Double).
Allerdings weiß ich nicht, wie es mit den Speicherbereichen ist, die müßten schon sharable sein.
Am besten mal einen C-Source anschauen, aber mehr machen die im allgemeinen nicht. -
Zitat
...bzw. nicht verstanden!
ich fürchte, das dies wohl eher zutrifft
Bedeutet das jetzt, daß bei einem fest declarierten StringArray ab A$[] z.B. 15000 Speicheradressen zu finden sind?ZitatAllerdings weiß ich nicht, wie es mit den Speicherbereichen ist, die müßten schon sharable sein.
Ja, damit funktioniert es gut. Einen mit Profan gedimmten Speicherbereich kann ich ohne Probleme mit PureBasic lesen & schreiben. -
PS: Aber die Vorschläge zu den Move-Funktionen stehen trotzdem

Da stimme ich dir zu.
Die Move - Befehle sind zu sehr an die Listboxliste
gebunden. Wie oben schon geschrieben, geht zwar
manches über den Umweg der Listboxliste, das kostet
aber auch wiederum Zeit.Meiner Ansicht nach, müßten die Move-Funktionen
einen optionalen Parameter erhalten, der das
Handle entgegen nimmt. Wie bei unserem Beispiel
wäre da das Handle eines mit @Create("List", 1)
ein Kandidat.Roland macht das ja bei anderen Funktionen auch.
Ich denke da an ClearList oder AddString(). Da
wird ja auch bei Handle = 0 die Listboxliste genommen
und ansonsten das Handle.Auch Gegenstücke fehlen, wie z.B. zu @MoveListToMem().
Das kann man zwar auch mit @MoveStrToList() überbrücken,
indem man mit String$(V, 0) den String vom Memory liest,
ist aber auch nochmals ein zusätzlicher Schritt. -
Also, bei einem 1 Dimensinallen Array werden ab Adresse 0 + Offset alle Adressen zum String abgelegt. Der String ist nullterminiert
(also eine Null bei Ascii, ansonsten zwei Nullen). Praktisch ergibt sich dadurch kein Problem, da strings immer mit der Adresse abgelegt
werden, also per API. Können also normal gelesen werden.Wie Profan das macht, keine Ahnung, aber normalerweise ist das so. Es sollte also keine grosses Problem sein, ein Array an eine
DLL in PureBasic zu übergeben, dort z.B. mit SortArray(ArrayName(), #PB_Sort_Ascending) zu sortieren.Ein bissel probieren wirste wohl müssen, ich hab da keine Lust/Zeit zu

-
Zitat
...Array werden ab Adresse 0 + Offset alle Adressen zum String abgelegt. Der String ist nullterminiert
aha - ok. Die Info reicht ja schon. Danke. Allerdings hab ich mir ja genau mit dieser Übergabemethode vergeblich Stundenlang einen Wolf probiert. Es ist mir so auf diese Weise einfach nicht gelungen. Deshalb fing ich ja schließlich an. das Array in einen Bereich zu kopieren, um diesen dann zu übergeben. (siehe weiter oben)
Hat mich ja irgendwann rein 'sportlich' gewurmt, warum das technisch so nicht funktioniert.
Ich werd das jetzt noch mal mit einem klitzekleinen, fest declarierten StringArray Schritt für Schritt durchkauen.
Vllt. hab ja doch irgendwas übersehen oder falsch angewendet... -
So! Hier eine MiniDemo. Und genau aus diesem Grund geht das eben nicht Thomas, weil ich die Adresse von diesen Array nicht rauskriege, ab wo diese Stringadressen stehen.
CodeDeclare arr$[2] arr$[0] = "null" arr$[1] = "eins" arr$[2] = "zwei" WhileLoop 0,2 Print arr$[&loop] EndWhile Print "Ergebnis von arr$[]:",arr$[] Print "Ergebnis von Addr(arr$[]):",Addr(arr$[]) waitkey
Und deshalb bringt der dll-Aufruf auch nur Fehlermeldungen, weil da keine vernünftige Adresse angeflogen kommt.
Wie krieg ich denn die Adresse des Array raus? -
hmm, bei einen Numerischen Array wird anscheinend eine vernünfige Adresse geliefert:
CodeDeclare arl&[2] arl&[0] = 0 arl&[1] = 1 arl&[2] = 2 WhileLoop 0,2 Print arl&[&loop] EndWhile Print "Ergebnis von arl&[]:",arl&[] Print "Ergebnis von Addr(arl&[]):",Addr(arl&[])
Dann sind Stringarrays in dieser Beziehung halt ein Sonderfall. Deckt sich also mit dem, was P.Specht weiter oben schon angemerkt hat.
Also war meine Idee, das über einen Speicherbereich zu regeln doch garnicht so schlecht
-
Was Profan da intern macht, keine Ahnung. Ein Array in den meisten Sprachen entspricht dem, von mir gesagtem und sind
demnach auch austauschbar.Das ummodeln, wenn man das Format mal kennt, wird wohl wenig Sinn machen, weil das Zeit kostet.
-
Jetzt mitmachen!
Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!