Array-Zeiger/Adresse bzw. Array an .dll übergeben

  • 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?

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

    • 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)

    Mehr erfahren

  • 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.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Hallo Heinz, ok das mit den Verschieben in eine sortierte Liste & zurück wäre ein Versuch Wert. Spiel ich mal durch.

    Zitat

    Hast 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... :)

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • Ich denke, daß du da wieder Zeit verlierst,

    besonders bei Punkt 2.a.

    Das sind ja 15000 Elemente.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • 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:

    Code
    Proc 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:

    Code
    Proc 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.

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • 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:

    Code
    @MoveArrToMem(A[],Mem#,Sep$)
    @MoveMemToArr(Mem#,A[],Sep$)


    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"?

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • Machs doch gleich mit einer Liste.

    Wenn es doch ein Array sein soll, mach es über den Weg der Listboxliste.

    Code
    MoveArrToList(Arr[])

    so könnte das aussehen :

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • 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.
    Gruss

    P.S.: Suchbegriff "Jonathans Getrickse" liefert auch Interessantes dazu.

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

    Einmal editiert, zuletzt von p. specht (14. August 2014 um 22:21)

  • 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 ;)

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • 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?

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • 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 :oops:
    Bedeutet das jetzt, daß bei einem fest declarierten StringArray ab A$[] z.B. 15000 Speicheradressen zu finden sind?

    Zitat

    Allerdings 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.

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • 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.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • 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...

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • 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.

    Code
    Declare 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?

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

  • hmm, bei einen Numerischen Array wird anscheinend eine vernünfige Adresse geliefert:

    Code
    Declare 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 ;)

    Gruß Jörg

    Ideen gibt es viele - man muß sie nur haben...
    Linux Mint / LMDE / Antix

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!