Beiträge von Techmix

Techmix

Hallo
Ich habe schon mehrfach mit TCP gearbeitet, das einzigste was mich an deinem Post etwas irritiert ist das Linux-Script. Mit Linux & Co kenne ich mich überhaupt nicht aus, aber wieso sollte das Linux-Script - wenn dein 'Client' verbunden ist - die 'Daten' NUR auf der Console ausgeben??? Hast du das Script selber verfasst, dann mußt du es wahrscheinlich anpassen (Rückgabe zusätzlich auf TCP...).

Aber mit AutoIt mache ich das so, ich verbinde mich erst zu TCP:IP und kann bei belieben Senden und Empfangen. Windows Cacht evtl. verpasste Daten und dieser wird erst ausgeöscht wenn due diesen ausließt

[autoit]

TCPStartup()
$hSocket = TCPConnect($s_TCP_IP, $i_TCP_Port)
Do
TCPSend($hSocket, "Irgendwas") ; An Socket senden
Sleep(20)
$sTcpData = TCPRecv($hSocket) ; Aus Socket lesen
if $sTcpData <> "" then ConsoleWrite($sTcpData & @CRLF)
Until @error
TCPShutdown()

[/autoit]

...Sorry, wollt noch nicht absenden

Du mußt natürlich die Variablen anpassen, und dann kannst du das Script ja mal auf deiner Config anpassen und testen.
Solltest du keine Daten auslesen können, mußt du eben noch das Linux-Sript anpassen.

Grüsse!

Techmix

Hallo ich hab wieder einen Hängerchen

Es geht voran, aber ich habe gerade ein Problemchen mit einer Poolzuweisung. Obwohl ich im Kernel 'if (Local_NotReplace[j] != i)' verwende wird an dieser Position das Ungleich '!=' völlig übergangen und das resultierende Array wir nicht korreckt aufgebaut. UND ich bin endlich bei der letzten großen Funktion angekommen, den Replacer (ab Zeile 184). Dort benötige ich noch das Pool-Array welches nicht richtig erstellt wird, habe aber noch Probleme die Durchlauflogik richtig umzusetzen - Es soll der Pool überprüft werden, und ein vorhandensein des aktuellen Pool-Chars im 'String' (In AU3 würde ich StringInString() verwenden). Wenn erst das Pool-Array richtig erstellt wird, denke ich das der Rest nicht mehr allzuviel Schwierigkeiten machen wird

Du erwähntest das man im *.cl Kernel auch Funktionen ausserhalb des __Kernel erstelen und ausführen kann. Ich habe eine Analyse- und eine Replacefunktion bereits in Void Funktionen eingebaut. Die identischen Durchläufe befinden sich jetzt auch noch zusätzlich im __Kernel, weil mir nur Fehlermeldungen ausgespuckt werden egal wie ich in die Funktionen springe, oder wie ich die Parameter übernehme (Zeile 148 bis 162). Deswegen habe ich auch die beiden Funktionen Auskommentiert...

Grüsse!

CL-Kernel

Code

/*
    SimpleCompression:


    Master:
    Im Master-Script werden die Eingangsdaten in Daten-Cluster aufgeteilt (Momentan 25KB, muß noch optimiert werden)
    Die Daten-Cluster werden nacheinander an den OpenCL-Kernel übergegeben
    In AU3 werden Variablen ausgetauscht um Arraygrößen im Kernel flexibel zuweisen zu können


    Kernel-StartUP:
    Der Kernel teilt seine Eingangsdaten in '$iGlobalSize' große Teile in 'Local_String' auf - Umwandlung dabei nach uInt (wie bei Asc())
    Für alle wichtigen Arrays werden 'Lokale' erstellt und reinkopiert


    Analyse:
    Char Wiederholungen in 'Local_iNewAnalyse' zählen
    Analyse von jeweils 2 'Local_String's, wenn nicht in 'NotReplace' vorhanden 'Local_iAnalyse[i]+=1'
    Analyse-Ergebniss in globalen Speicher addieren
    Fertiggestelltes Analyse-Ergebniss in 'Local_iNewAnalyse' zurück kopieren


    Replacing:
    'Local_iNewAnalyse' absteigend sortieren
    ? 'Local_iNewAnalyse' tauschen mit (uInt)Chars welche nicht in 'Local_NotReplace' vorhanden sind


    Rückgabe:
    ???


*/


//~ void _Sorter(private uint* _iNewAnalyse, uint iNumAnalyse);
//~ void _Replacer(private uint _Input, private uint* _Output, private uint _Array, private uint _NotReplace, private uint* _Replaced);


#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable    // Atomics einschalten


__kernel void SimpleCompression(
                __constant char* _In,                                 // Input
                __global char* _Out,                                // Output - Rückgabe
                __constant uint* NotReplace,                        // NotReplace
                __constant char* Analyse,                             // Analyse-Chars
                __global uint* iAnalyse)                            // Analyse-Counter
{
// Deklarationen
    uint iTrenner        = NotReplace[0];                            // Trenner, für die Schlüsselerzeugung
    uint iNumElements    = $iNumElements;                            // Input Länge ($iNumElements wird in AU3 Replaced)
    uint iNumNotReplace    = $iNumNotReplace;                            // Anzahl von Not-Replacern ($iNumNotReplace wird in AU3 Replaced)
    uint iGlobalSize    = $iGlobalSize;                                // Eingangs-Datengröße für Globale Daten ($iGlobalSize wird in AU3 Replaced)
    uint iLocalSize        = $iLocalSize;                                // Datengröße je Thread für Lokale Daten ($iLocalSize wird in AU3 Replaced)
    uint iNumAnalyse    = $iNumAnalyse;                                // Anzahl von Analyse-Einträgen ($iNumAnalyse wird in AU3 Replaced)
    uint iThreadID        = get_global_id(0)*iGlobalSize;                // Global-ThreadID alle iDataSize-Char
    uint iLocalID        = get_local_id(0)*2;                        // Local-ThreadID alle 2-Char
    uint iOutput        = 0;                                        // Output Counter
    uint i, j;


// Lokale Array´s
    private uint Local_String[$iGlobalSize];                        // Lokales Array 'Local_String'        ($iGlobalSize wird in AU3 Replaced)
    private char Local_sOutput[$iGlobalSize];                        // Lokales Array 'Local_sOutput'    ($iGlobalSize wird in AU3 Replaced)
    private uint Local_NotReplace[$iNumNotReplace];                    // Lokales Array 'Local_NotReplace'    ($iNumNotReplace wird in AU3 Replaced)
    private uint Local_sAnalyse[$iNumAnalyse*2];                    // Lokales Array 'Local_sAnalyse'    ($iNumAnalyse wird in AU3 Replaced)
    private uint Local_iAnalyse[$iNumAnalyse];                        // Lokales Array 'Local_iAnalyse'
    private uint Local_iNewAnalyse[$iNumAnalyse][2];                // Lokales Array 'Local_iNewAnalyse'
    private uint Local_iReplaced[$iNumAnalyse][3];                    // Lokales Array 'Local_iReplaced'    Schlüsselerzeugung
    private uint Local_iPool[$iNumAnalyse];                            // Lokales Array 'Local_iPool'        Freie Replacer


// Debugging
    //~ printf("get_global_id(0)=%i \n", get_global_id(0));            // 0
    //~ printf("get_global_size(0)=%i \n", get_global_size(0));        // 1
    //~ printf("get_local_id(0)=%i \n", get_local_id(0));            // 0
    //~ printf("get_local_size(0)=%i \n", get_local_size(0));        // 1
    //~ printf("iGlobalSize=%i \n", iGlobalSize);
    //~ printf("iNumElements=%i \n", iNumElements);
    //~ printf("iNumNotReplace=%i \n", iNumNotReplace);
    //~ printf("iNumAnalyse=%i \n", iNumAnalyse);


//
//     Kernel-StartUP


//     Input-Daten verarbeiten...
    for (i = 0; i < iGlobalSize; i++) {                                // 'iGlobalSize' Chars von 'String' in lokales Array kopieren
        if (iThreadID+i < iNumElements) {                            // Aufpassen das 'iThreadID+i' < 'iNumElements' bleibt
            Local_String[i] = convert_int(_In[iThreadID+i]);        // Umwandlung von Char zu Int
            //~ printf("iThreadID+i=%i, _In[iThreadID+i][i]=%c, Local_String[i]=%i \n", iThreadID+i, _In[iThreadID+i], Local_String[i]);
        }
    }
    for (i = 0; i < iGlobalSize; i++) {                                // 'Local_sOutput' Leeren
        Local_sOutput[i] = "";
    }
    for (i = 0; i < iNumNotReplace; i++) {                            // NotReplace in lokales Array kopieren
        Local_NotReplace[i] = NotReplace[i];
        //~ printf("Local_NotReplace[i]=%i \n", Local_NotReplace[i]);
    }
    for (i = 0; i < iNumAnalyse*2; i++) {                            // Analyse in lokales Array kopieren
        Local_sAnalyse[i] = convert_int(Analyse[i]);
        //~ printf("Local_sAnalyse[i]=%i, Local_sAnalyse[i]=%c \n", Local_sAnalyse[i], Local_sAnalyse[i]);
    }
    for (i = 0; i < iNumAnalyse; i++) {                                // Analyse-Counter im lokalen Array erstellen
        Local_iAnalyse[i] = 0;                                        // Nullen für spätere Addition
    }
    for (i = 0; i < iNumAnalyse; i++) {                                // Zweiten Analyse-Counter im lokalen Array erstellen
        Local_iNewAnalyse[i][0] = 0;                                // Nullen
        Local_iNewAnalyse[i][1] = 0;                                // Nullen
    }
    for (i = 0; i < iGlobalSize; i++) {                                // Output im lokalen Array erstellen
        Local_sOutput[i] = "";                                        // Leeren für spätere Aktion
    }
    for (i = 0; i < iNumAnalyse; i++) {                                // Schlüssel-Array Erstellung
        Local_iReplaced[i][0] = -1;                                    // Replacer
        Local_iReplaced[i][1] = -1;                                    // Analyse Char 1
        Local_iReplaced[i][2] = -1;                                    // Analyse Char 2
    }
    for (i = 32; i < iNumAnalyse; i++) {                            // Pool-Array Erstellung
        Local_iPool[i] = -1;                                        // Leeren
        for (j = 0; j < iNumNotReplace; j++) {                        // Prüfen ob 'i' in 'Local_NotReplace' enthalten ist
            if (Local_NotReplace[j] != i) {
        //~ printf("Local_NotReplace[j]=%i \n", Local_NotReplace[j]);
                Local_iPool[i] = i;                                    // Dann 'Local_iPool[i]' = 'i'
            }
        }
        printf("Local_iPool[i]=%i \n", Local_iPool[i]);
    }
//~ private uint Local_iPool[$iNumAnalyse];


//
//     Analyse


//     Analyse der 'Local_String' Daten
    for (i = 0; i < iGlobalSize-1; i+=2) {                            // Lokales Array 'Local_String' durchgehen
        for (j = 0; j < iNumAnalyse*2-1; j+=2) {                    // Und bei Erfolg 'Local_iAnalyse[i]++'
            if (Local_String[i] == Local_sAnalyse[j]) {
                if (Local_String[i+1] == Local_sAnalyse[j+1]) {
                    Local_iAnalyse[j/2]++;
                    //~ printf("j/2=%i, Local_iAnalyse[j/2]=%i \n", j/2, Local_iAnalyse[j/2]);
                }
            }
        }
    }
    // Debug 'Local_iAnalyse'
    //~ for (i = 0; i < iNumAnalyse; i++) {
        //~ if (Local_iAnalyse[i] > 0) {printf("i=%i, Local_iAnalyse[i]=%i \n", i, Local_iAnalyse[i]);}
    //~ }


//     Analyse-Ergebniss im globalen Speicher addieren
    barrier(CLK_GLOBAL_MEM_FENCE);                                     // Warten, bis alle Workitems fertig sind!
    for (i = 0; i < iNumAnalyse; i++) {                                // Ergebniss addieren
        if (Local_iAnalyse[i] > 0) {atomic_add(&iAnalyse[i], Local_iAnalyse[i]);}
        //~ if (Local_iAnalyse[i] > 0) {iAnalyse[i] += Local_iAnalyse[i];}
        //~ printf("iAnalyse[i]=%i \n", iAnalyse[i]);
    }


//     Fertiggestelltes Analyse-Ergebniss in 'Local_iNewAnalyse' kopieren
    barrier(CLK_GLOBAL_MEM_FENCE);                                     // Warten, bis alle Workitems fertig sind!
    for (i = 0; i < iNumAnalyse; i++) {                                // Analyse-Counter im lokalen Array erstellen
        Local_iNewAnalyse[i][0] = iAnalyse[i];                        // Anzahl in lokal schreiben
        Local_iNewAnalyse[i][1] = i;                                // uIntChar für Sortierung
        //~ printf("Local_iNewAnalyse[i][0]=%i, Local_iNewAnalyse[i][1]=%i \n", Local_iNewAnalyse[i][0], Local_iNewAnalyse[i][1]);
    }


//
//     Replacing


//     'Local_iNewAnalyse' sortieren
    //~ _Sorter(Local_iNewAnalyse, iNumAnalyse);
    uint iWert1, iWert2, iElemente = iNumAnalyse;
    barrier(CLK_LOCAL_MEM_FENCE);                                    // Lokaler Barrier
    while(iElemente--){                                                // BubbleSort2D, angepasst aus C
        for(i = 1; i <= iElemente; i++){
            if(Local_iNewAnalyse[i-1][0] < Local_iNewAnalyse[i][0]){
                iWert1 = Local_iNewAnalyse[i][0];                    // Anzahl
                iWert2 = Local_iNewAnalyse[i][1];                    // uIntChar
                Local_iNewAnalyse[i][0] = Local_iNewAnalyse[i-1][0];
                Local_iNewAnalyse[i][1] = Local_iNewAnalyse[i-1][1];
                Local_iNewAnalyse[i-1][0] = iWert1;
                Local_iNewAnalyse[i-1][1] = iWert2;
            }
        }
    }
    // Debug sortiertes 'Local_iNewAnalyse'
    //~ for (i = 0; i < iNumAnalyse; i++) {                                // Analyse-Counter im lokalen Array erstellen
        //~ printf("Sorted: Local_iNewAnalyse[i][0]=%i, Local_iNewAnalyse[i][1]=%i \n", Local_iNewAnalyse[i][0], Local_iNewAnalyse[i][1]);
    //~ }


//     'Local_iNewAnalyse' tauschen mit (uInt)Chars welche nicht in 'Local_NotReplace' vorhanden sind
    //~ _Replacer(Local_String, Local_sOutput, Local_iNewAnalyse, Local_NotReplace, Local_iReplaced);
    uint uIntChar1, uIntChar2, iCount = 0;
    //~ for (i = 0; i < iGlobalSize; i++) {
        //~ printf("Local_sOutput[i]=%s \n", Local_sOutput[i]);
    //~ }
    barrier(CLK_LOCAL_MEM_FENCE);                                    // Lokaler Barrier
    for (i = 0; i < iGlobalSize-1; i+=2) {
        uIntChar1 = Local_String[i];                                // uIntChar´s erstellen
        uIntChar2 = Local_String[i+1];
        for (j = 0; j < iNumAnalyse; j+=2) {                        // Lokales Array 'Local_String' durchgehen
            if (Local_iNewAnalyse[j][0] > 1) {
                if (Local_String[i] == Local_sAnalyse[Local_iNewAnalyse[j][1]]) {
                    if (Local_String[i+1] == Local_sAnalyse[Local_iNewAnalyse[j][1]+1]) {
                    //~ if (Local_String[i+1] == Local_sAnalyse[Local_iNewAnalyse[j][1]+1]) {
                        //~ private uint Local_NotReplace[$iNumNotReplace];
                        //~ private uint Local_iReplaced[$iNumAnalyse][3];
                        uIntChar1 = Local_iNewAnalyse[j][1];
                        uIntChar2 = -1;
                    }
                }
            }
        }
        if (iCount < iNumElements) {                                // Aufpassen das 'iCount' < 'iNumElements' bleibt
            Local_sOutput[iCount] = convert_char(uIntChar1);        // uIntChar1 schreiben
            iCount++;
            if (uIntChar2 != -1){                                    // uIntChar2 schreiben, wenn nicht Leer
                if (iCount < iNumElements) {                        // Aufpassen das 'iCount' < 'iNumElements' bleibt
                    Local_sOutput[iCount] = convert_char(uIntChar2);
                    iCount++;
                }
            }
        }
    }
    for (i = 0; i < iGlobalSize; i++) {
        printf("Local_sOutput[i]=%c \n", Local_sOutput[i]);
    }


//
//     Rückgabe erstellen


//    '_Out' mit 'Local_sOutput' befüllen
    j = 0;
    barrier(CLK_GLOBAL_MEM_FENCE);                                     // Warten, bis alle Workitems fertig sind!
    for (i = 0; i < iGlobalSize; i++) {                                // Lokales Array 'Local_sOutput' durchgehen
        if (Local_sOutput[i] != ""){
            _Out[j] = Local_sOutput[i];
            j++;
        }
    }


//    Schlüsselerzeugung
    barrier(CLK_GLOBAL_MEM_FENCE);                                     // Warten, bis alle Workitems fertig sind!
    for (i = 0; i < iNumAnalyse; i++) {                                // Schlüssel anhängen
        if (Local_iReplaced[i][0] > -1){
            _Out[j] = convert_char(iTrenner);                        // Trenner
            _Out[j+1] = convert_char(Local_iReplaced[i][0]);        // Replacer
            _Out[j+2] = convert_char(iTrenner);                        // Trenner
            _Out[j+3] = convert_char(Local_iReplaced[i][1]);        // Char 1
            _Out[j+4] = convert_char(Local_iReplaced[i][2]);        // Char 2
            j+=5;
        }
    }


}


// Schlüsselerstellung in AU3
//~ $sData = $sString & $a_Trenner[0][1]


//~ ; $sKey Erstellen
//~ For $i = 0 To UBound($aReplaced, 1) - 1
    //~ If $aReplaced[$i][0] <> "" And $aReplaced[$i][1] <> "" Then $sKey &= $aReplaced[$i][0] & $a_Trenner[0][1] & $aReplaced[$i][1] & $a_Trenner[0][1]
//~ Next
//~ $sData &= StringTrimRight($sKey, 1)


//~ void _Sorter(                                                        // Sortier Funktion
        //~ private uint* _iNewAnalyse,                                 // Analyse Array - Rückgabe
        //~ uint iElemente)                                                // Größe
//~ {
    //~ uint i, Wert1, Wert2;
    //~ barrier(CLK_LOCAL_MEM_FENCE);                                    // Lokaler Barrier
    //~ while(iElemente--){                                                // BubbleSort2D, angepasst aus C
        //~ for(i = 1; i <= iElemente; i++){
            //~ if(_iNewAnalyse[i-1][0] < _iNewAnalyse[i][0]){
                //~ Wert1 = _iNewAnalyse[i][0];                            // Anzahl
                //~ Wert2 = _iNewAnalyse[i][1];                            // uIntChar
                //~ _iNewAnalyse[i][0] = _iNewAnalyse[i-1][0];
                //~ _iNewAnalyse[i][1] = _iNewAnalyse[i-1][1];
                //~ _iNewAnalyse[i-1][0] = Wert1;                        // Neue Werte schreiben
                //~ _iNewAnalyse[i-1][1] = Wert2;
            //~ }
        //~ }
    //~ }
//~ }


//~ void _Replacer(                                                        // Austausch Funktion
                //~ private uint _Input,                                 // Eingangsdaten
                //~ private uint* _Output,                                 // Ausgang - Rückgabe
                //~ private uint _Array,                                 // _Sorter() Analyse-Array
                //~ private uint _NotReplace,                            // NotReplace
                //~ private uint* _Replaced)                            // Austausch-Array, benötigt zur Schlüsselerzeugung - Rückgabe
//~ {
    //~ uint uIntChar1, uIntChar2, iCount = 0;
    //~ barrier(CLK_LOCAL_MEM_FENCE);                                    // Lokaler Barrier
    //~ for (i = 0; i < iGlobalSize-1; j+=2) {
        //~ uIntChar1 = Local_String[i];                                // uIntChar´s erstellen
        //~ uIntChar2 = Local_String[i+1];
        //~ if (Local_iNewAnalyse[i][0] > 0) {
            //~ for (j = 0; j < iNumAnalyse; j+=2) {                        // Lokales Array 'Local_String' durchgehen
                //~ if (Local_String[i] == Local_sAnalyse[Local_iNewAnalyse[i][1]]) {
                    //~ if (Local_String[i+1] == Local_sAnalyse[Local_iNewAnalyse[i][1]+1]) {
                        //~ uIntChar1 = Local_iNewAnalyse[i][1];
                        //~ uIntChar2 = "";
                    //~ }
                //~ }
            //~ }
        //~ }
        //~ Local_sOutput[iCount] = uIntChar1;                            // uIntChar1 schreiben
        //~ iCount++;
        //~ if (uIntChar2 > ""){                                        // uIntChar2 schreiben, wenn nicht Leer
            //~ Local_sOutput[iCount] = uIntChar2;
            //~ iCount++;                                                // dann auch iCount++
        //~ }
    //~ }


//~ }

Alles anzeigen

Techmix

Hallo,
aus aktuellen Umständen gibt es ein Update!

Es ist noch ziemlig BETA sollte aber schon zuverlässig laufen (solange man nicht die Einstellungen zu sehr ändert). Habe die Tage 1200 Zeilen abgespeckt und mich auf die Kernfunktionen beschränkt. Es gibt noch Bugs, aber was soll´s

Grüsse!

Techmix

Genau so hatte ich mir das vorgestellt, habe auch schon die "opencl.properties"entsprechend vorbereitet da hab ich schon ein .chm Helpfile auf F1 integriert.

Techmix

Das wäre super! Würde den Umgang mit den Kerneln deutlich erleichtern. Ich halte das eh für eine gute Idee das in SciTE zu integrieren weil die meißten AU3 User sowieso den Editor verwenden. Und wie du sagtest, so kann man besser VS umgehen und effizienter Arbeiten.

Grüsse!

[Edit]
Die warnungen haben mich anfangs auch sehr irritiert, habe versucht diese "Wegzuarbeiten"... Können ruhig ausbleiben!

Techmix

Ja, diese ist mir fremd. Ausserdem welche Variable p?? Habe diese jedenfalls nicht deklariert...

[Edit]
Das sieht mir danach aus, als würde der Compiler dazwischen funken...

Techmix

Hy,
Wie bekomme ich es mit einigen Zeilen so hin, das ich an einem CL-Kernel einen Synaxcheck ausführen kann? Mir geht es um diese SciTE Ausgabe:

Code

LOG:
Compilation started
1:33:29: error: parameter may not be qualified with an address space
1:33:73: error: parameter may not be qualified with an address space
...

Ich habe doch noch 'OpenCL4SciTE' erstellt, habe da ein kleines Script für ein Helpfile integriert - Jetzt möchte ich noch den Kernel direkt aus SciTE kompilieren um damit einen Synaxcheck zu integrieren. Es nervt mich das ich andauernd in´s AU3 Script wechseln muss um im Kernel einen Synatax-Check durchführen zu können!
In der Funktion '_cl_GetDevice()' wird das Logfile erstellt, auf welches ich so scharf bin Nur leider wird zum Erstellen des Log´s großes PiPaPo betrieben, und ich bin mir nicht sicher wie oder welche Teile davon ich verwenden soll...

[OpenCL4SciTE]
Auch stimmt was nicht in der 'opencl.properties' nicht, wieso wird das API-File nicht verwendet?!
Mir ist auch nicht entgangen das nicht alle Keywords verwendet werden, habe schon einige manuell zugefügt. Das ist einfach passiert weil ich mir ein Highlighting von einem anderen Editor aus dem Netz geladen habe und diese Daten eben dür SciTE´s Format angepasst.
Auch hätte ich die Farben in SciTE näher an AU3, also keine roten Funktionsbezeichnungen oder lila Textinhalt - sondern Hellblaue Funktionen und grauer Text, da stimmen sicherlich noch andere Farben nicht aber das ist störend. Ich habe schon mit den 'style' Einstellungen gespielt, muß ich diese wirklich händisch sortieren oder reicht eine richtige 'keywordsNR' Zuweisung - obwohl ich auch hier experimentiret habe. Auch macht es einen riesen Unterschied ob ich bei 'lexer.$(ocl)=cpp' oder einfach was anderes angebe. So viele Möglichkeiten, da steige ich nicht ganz durch...
Ich hänge noch die aktuelle Datei dazu an, enthällt kleinere Änderungen...

Grüsse!

Techmix

Ich hatte vor etlichen Jahren in meinem Ascona auch ne fette Anlage verbaut. Habe aber die halbe kiste zerlegt um Dämmmatten und Bitumen zur Schalldämmung unterzubringen. In der Front hatte ich mir einen passiven Centerspeaker zur besseren Streuung verbaut. Das perverse an dem Auto waren die drei 30 cm Bässe welche ich rückseitig an der hinteren Sitzbank mit einer Arbeitsplatte aus der Küche versehen hatte. Wenn mein Bruder mit fuhr wurde dem immer ganz übel da hinten
Aber die restliche Anlage konnte sich hören lassen, hatte schon immer gerne mit Canton gearbeitet, auch hatte ich mir schöne Kickbässe von Phonocar (waren führend dabei) in alle vier Türen verbaut. In dem Ascona konntest du Pavarotti genaus so gut hören wie Slipknot

Techmix

Du stehst auf Bass, dan hole dir die Infraschallwandler von Emphaser. Die hatte ich mal unterm Sofa verbaut, weil ich in der Wohnung keinen Kinobass betreiben konnte.
Die haben ordentlich gefetzt

Grüsse!

Techmix

Hallo

Zitat

...Ich verstehe jedenfalls deinen Ansatz nicht...

Das mit dem einen Workitem mache ich nur, damit ich die printf() Ausgaben besser analysieren kann! Ist quasi NUR zu Debbugzwecken gesetzt, wird natürlich noch angepasst...

Zitat

...das meinst du hoffentlich mit ByRef...

Ich meine das innerhalb des Kernels (der *.cl Datei), wenn ich aus dem Kernel eine eigene Funktion aufrufe und ich eben ein Array als Rückgabe brauche. In anderen Sprachen muss ich "Arrays" ByRef an die Funktion übergeben - weil es nicht möglich ist ein Array aus der Funktion zurückgeben zu lassen

Zitat

Du machst dir dein Leben auch dermaßen schwer

Grins... Ich Denke einfach zu kompliziert, kann mich aber nicht entsprechend äussern/ausdrücken... DAS ist das Problem!

Zitat

...Kernelparameter und AutoItvariablen...

Ganz einfach, in OpenCL kann ich keine variablen Arrays verwenden - diese müssen eine vordefinierte Größe erhalten. Aber je nach Datengröße müsste ich immer den Kernel händisch anpassen, jetzt nicht mehr! Das übernimmt AU3 für mich... UND ich befinde mich doch in der Lernphase dieses Rumgeieiere erleichtert mir einfach den Umgang...

OK, der Kernel befindet sich noch in der Analyse von dem Input. Ich erstelle in AU3 eine 'uInt' Struct, Nulle diese und übergebe sie mit '__global uint* iAnalyse' an den Kernel. Am Kernel angekommen lasse ich mir dieses mit printf() ausgeben, und es ist nicht mehr 0. Die komischten Werte werden mir ausgespuckt, mal eine Null, sogar negative Zahlen werden ausgespuckt. Dabei erstelle ich die Struct wie alle anderen auch, und übergebe diese auch ganz normal. Alle anderen Structs kann ich mir ebenso mit printf() ausgeben, und da sind die Daten wie erwartet... Liegt das jetzt an einer unachtsammkeit innerhalb meines AU3 Scriptes, oder an meinem Kernel selber

Ausserdem finde ich meinen Kernel garnicht soooo kompliziert... Der Vorgang liegt ersichtlich im AU3 Source, ist eine einfache Analyse der Eingangsdaten, mit anschliessender Sortierung der Ergebnisse und Austausch mit freien Chars. Anschliessend alles in die Output-Struct schreiben und in AU3 den Buffer auslesen - Und fertig! <- Wo ist das kompliziert

Ich habe das Multiprocessing absichtlich eingebaut, das ist auch nicht wirklich aktuell hab das schon vor 2 Jahren verwendet. In manchen Bereichen kann ich damit AutoIt einen richtigen Turbo verpassen. Und dieses lässt sich anhand von dieser Billig-Kompression sehr schön darstellen, im normalen Singleprozess-Betrieb braucht das standart Script 63 Sekunden bei mir um die 'AutoIt.exe' zu komprimieren, im Multiprozess-Betrieb nur noch 18 Sekunden - das ist drei mal schneller als normal. Und wieso nicht mit OpenCL ebenso vorgehen - es bietet sich mit den unterschiedlichen Platformen und Devices doch dafür an . Mir geht es auch nicht um SLI oder 'prestige' (hier guck mal, Boahhh...) für mich ist das eine normale Vorgehensweise! Maximierung der Rechenleistung durch Auslagerung in Prozesse oder Threads
Daher bin ich auch schon so angefressen, das ich mich mit den Fortschritt in OpenCL "etwas" schwer tue! Immer wieder Stolpersteine, die OCL SDK´s lassen sich nicht in die 'Express' Versionen vom VisualStudio integrieren, dann das dumm gelaufene Update, ... Immerhin konnte ich SciTE überreden mir endlich etwas Farbe im Kernel anzeigen zu lassen

Grüsse!

[Edit]
Hab jetzt erst dein Edit gelesen... Das ist ja mal peinlich Aber Danke!

Techmix

Hy,

Das in deinem ersten Post ist wohl ein Scriptausschnitt - das kann so nicht funktionieren... Wo steht eigentlich das '_FileWriteFromArray()' an das Dateiende anhängen kann, das wäre mir neu! Du musst mit den File-Befehlen Arbeiten, schau mal in die Hilfe. Und wo weist du der Variable '$Test Daten' zu??
Überprüfe nochmal deinen Code, weise der richtigen Variable entsprechende Daten zu und schreibe alles mit 'FileWrite()' auf deiner HDD. Bei dem 'FileOpen()' Befehl kannst du anweisen das die Daten angehängt werden sollen.

Grüsse!

Techmix

Nabend

Ich war ansatzweise Fleißig und bin vier Baustellen gleichzeitig angegangen... Erstmal habe ich für den Kompressionsalgorythmus die absolute Mindest-Basis geschaffen, diese enthällt eine funktionierende Vorlage in AU3 und eine Interpretation in OpenCL. Dann habe ich die Herkunft des Alogo´s entstaubt und einigermaßen Lauffähig bekommen dazu einen Post verfasst und werde diesen noch aktualisieren. Auch habe ich ein Syntax-Highlighting für OpenCL in SciTE erstellt, damit mir das Arbeiten damit leichter fällt - ist aber farblich nicht so dolle geworden...

Meine Motivation liegt darin eine OpenCL Interpretation der Kompressionsmethoden aus cHEX zu realisieren, weil ich die Geschwindigkeitsvorteile durchaus zu schätzen weiß! Außerdem bietet sich das Projekt für OCL an, weil ich dort mit Multiprocessing arbeite; in OCL könnten diese jeweils ein Device darstellen, und die Geschwindigkeit maximieren OHNE dabei auf Multi-Kernel zugreifen zu müssen (Die Verwaltung übernimmt das Main-Script).

Ich habe eine lauffähige Kurzversion, welche das Multiprocessing verwendet, für das Anwendungsbeispiel angefertigt... So bin ich in der Lage innerhalb von AU3 die maximale Threadanzahl zu nutzen und in OpenCL habe ich den Vorteil alle vorhanden Devices als 'Threads' verwalten zu können <- Durch die Multiprocessing-Methode von cHEX wird der Prozess einmalig kompiliert und mehrfach ausgeführt, dabei wird dieser über TCP mit allen nötigen Parametern versorgt, und das Main-Script übernimmt dabei die Prozess- und Clusterverwaltung. Dann kann ein identischer Kernel auf allen Devices mit den jeweiligen Parametern ausgeführt werden - ohne das ich an den Kernel Anpassungen durchführen muss! (Hoffentlich :D)

Ich hänge alles an, aber Poste den Kernel noch - vielleicht kann mir ja jemand ja so schon helfen

Kernel

Code

/*
    SimpleCompression:


    Master:
    Im Master-Script werden die Eingangsdaten in Daten-Cluster aufgeteilt (Momentan 25KB, muß noch optimiert werden)
    Die Daten-Cluster werden nacheinander an den OpenCL-Kernel übergegeben


    Kernel-StartUP:
    Der Kernel teilt seine Eingangsdaten in '$iGlobalSize' große Teile in 'Local_String' auf - Umwandlung dabei nach uInt (wie bei Asc())
    Für alle wichtigen Arrays werden 'Lokale' erstellt und rein kopiert, so soll


    Analyse:
    Char Wiederholungen in 'Local_iNewAnalyse' zählen
    Analyse von jeweils 2 'Local_String's, wenn nicht in 'NotReplace' vorhanden 'Local_iAnalyse[i]+=1'
    ? Analyse-Ergebniss in globalen Speicher addieren
    Fertiggestelltes Analyse-Ergebniss in 'Local_iNewAnalyse' zurück kopieren
    ? 'Local_iNewAnalyse' absteigend sortieren


    Replacing:
    ? 'Local_iNewAnalyse' tauschen mit (uInt)Chars welche nicht in 'Local_NotReplace' vorhanden sind


    Rückgabe:
    ???


*/


#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable    // Atomics einschalten


__kernel void SimpleCompression(
                __constant char* _In, __global char* _Out, const uint iNumElements,            // In- und Output
                __constant uint* NotReplace, const uint iNumNotReplace,                        // NotReplace
                __constant char* Analyse, __global uint* iAnalyse)                            // Analyse
{
// Deklarationen
    uint iGlobalSize    = $iGlobalSize;                                // Eingangs-Datengröße für Globale Daten ($iGlobalSize wird in AU3 Replaced)
    uint iLocalSize        = $iLocalSize;                                // Datengröße je Thread für Lokale Daten ($iLocalSize wird in AU3 Replaced)
    uint iNumAnalyse    = $iNumAnalyse;                                // Anzahl von Analyse-Einträgen ($iNumAnalyse wird in AU3 Replaced)
    uint iThreadID        = get_global_id(0)*iGlobalSize;                // Global-ThreadID alle iDataSize-Char
    uint iLocalID        = get_local_id(0)*2;                        // Local-ThreadID alle 2-Char
    uint iOutput        = 0;                                        // Output Counter
    uint i, j;


// Lokale Array´s
    private uint Local_String[$iGlobalSize] ;                        // Lokales Array 'Local_String'        ($iGlobalSize wird in AU3 Replaced)
    private uint Local_NotReplace[32] ;                                // Lokales Array 'Local_NotReplace'
    private uint Local_sAnalyse[$iNumAnalyse*2] ;                    // Lokales Array 'Local_sAnalyse'    ($iNumAnalyse wird in AU3 Replaced)
    private uint Local_iAnalyse[$iNumAnalyse] ;                        // Lokales Array 'Local_iAnalyse'
    private uint Local_iNewAnalyse[$iNumAnalyse][2] ;                // Lokales Array 'Local_iNewAnalyse'


// Debugging
    //~ for (i = 0; i < iNumAnalyse; i++) {
        //~ printf("i=%i, Analyse[i]=%c \n", i, Analyse[i]);
    //~ }
    for (i = 0; i < iNumAnalyse; i++) {                                // Hier sollte die Ausgabe immer 0 sein...
        printf("i=%i, iAnalyse[i]=%i \n", i, iAnalyse[i]);
    }


    //~ printf("get_global_id(0)=%i \n", get_global_id(0));
    //~ printf("get_global_size(0)=%i \n", get_global_size(0));
    //~ printf("get_local_id(0)=%i \n", get_local_id(0));
    //~ printf("get_local_size(0)=%i \n", get_local_size(0));
    //~ printf("iGlobalSize=%i \n", iGlobalSize);
    //~ printf("iNumElements=%i \n", iNumElements);
    //~ printf("iNumNotReplace=%i \n", iNumNotReplace);
    //~ printf("iNumAnalyse=%i \n", iNumAnalyse);


//
//     Kernel-StartUP


//     Input-Daten verarbeiten...
    for (i = 0; i < iGlobalSize; i++) {                                // 'iGlobalSize' Chars von 'String' in lokales Array kopieren
        if (iThreadID+i < iNumElements) {                            // Aufpassen das 'iThreadID+i' < 'iNumElements' bleibt
            Local_String[i] = convert_int(_In[iThreadID+i]);        // Umwandlung von Char zu Int
            //~ printf("iThreadID+i=%i, _In[iThreadID+i][i]=%c, Local_String[i]=%i \n", iThreadID+i, _In[iThreadID+i], Local_String[i]);
            //~ printf("_In[iThreadID+i]=%c, Local_String[i]=%i, Local_String[i]=%c \n", _In[iThreadID+i], Local_String[i], Local_String[i]);
            //~ printf("_In[iThreadID+i]=%c \n", _In[iThreadID+i]);
        }
    }
    for (i = 0; i < iNumNotReplace; i++) {                            // NotReplace in lokales Array kopieren
        Local_NotReplace[i] = NotReplace[i];
        //~ // printf("Local_NotReplace[i]=%i \n", Local_NotReplace[i]);
    }
    for (i = 0; i < iNumAnalyse*2; i++) {                            // Analyse in lokales Array kopieren
        Local_sAnalyse[i] = convert_int(Analyse[i]);
        //~ // printf("Local_sAnalyse[i]=%i, Local_sAnalyse[i]=%c \n", Local_sAnalyse[i], Local_sAnalyse[i]);
    }
    for (i = 0; i < iNumAnalyse; i++) {                                // Analyse-Counter im lokalen Array erstellen
        Local_iAnalyse[i] = 0;                                        // Nullen für spätere Addition
        //~ // printf("Local_iAnalyse[i]=%i \n", Local_iAnalyse[i]);
    }


//
//     Analyse


//     Analyse der 'Local_String' Daten
    for (i = 0; i < iGlobalSize-1; i+=2) {                            // Lokales Array 'Local_String' durchgehen
        for (j = 0; j < iNumAnalyse*2-1; j+=2) {                    // Und bei Erfolg 'Local_iAnalyse[i]++'
            if (Local_String[i] == Local_sAnalyse[j]) {
                if (Local_String[i+1] == Local_sAnalyse[j+1]) {
                    Local_iAnalyse[j/2]+=1;
                    //~ // printf("j/2=%i, Local_iAnalyse[j/2]=%i \n", j/2, Local_iAnalyse[j/2]);
                }
            }
        }
    }
    // Debug 'Local_iAnalyse'
    for (i = 0; i < iNumAnalyse; i++) {
        //~ // if (Local_iAnalyse[i] > 0) {printf("i=%i, Local_iAnalyse[i]=%i \n", i, Local_iAnalyse[i]);}
    }


//     Analyse-Ergebniss im globalen Speicher addieren
    barrier(CLK_GLOBAL_MEM_FENCE);                                     // Warten, bis alle Workitems fertig sind!
    for (i = 0; i < iNumAnalyse; i++) {                                // Ergebniss addieren
        if (Local_iAnalyse[i] > 0) {atomic_add(&iAnalyse[i], Local_iAnalyse[i]);}
        //~ // if (Local_iAnalyse[i] > 0) {iAnalyse[i] += Local_iAnalyse[i];}
        //~ //printf("iAnalyse[i]=%i \n", iAnalyse[i]);
    }
    // Übergebe ich die Daten falsch an das globale Array zurück ?!? ...


//     Fertiggestelltes Analyse-Ergebniss in 'Local_iNewAnalyse' kopieren
    barrier(CLK_GLOBAL_MEM_FENCE);                                     // Warten, bis alle Workitems fertig sind!
    for (i = 0; i < iNumAnalyse; i++) {                                // Analyse-Counter im lokalen Array erstellen
        Local_iNewAnalyse[i][0] = iAnalyse[i];                        // Ergebniss in lokal schreiben
        Local_iNewAnalyse[i][1] = i;                                // Index für Sortierung
        //~ // printf("Local_iNewAnalyse[i][0]=%i, Local_iNewAnalyse[i][1]=%i \n", Local_iNewAnalyse[i][0], Local_iNewAnalyse[i][1]);
    }
    // jedenfalls können die Ergebnisse nicht stimmen...
    // Sind das wieder Syncronisations-Probleme, oder habe ich was falsch gemacht??


//     'Local_iNewAnalyse' sortieren


//
//     Replacing


//     'Local_iNewAnalyse' tauschen mit (uInt)Chars welche nicht in 'Local_NotReplace' vorhanden sind


//
//     Rückgabe


}


/*
    SimpleCompression:
    Dieser Kernel soll eine minimal Kompression in OpenCL darstellen.
    Ich wandel alle Char´s in uInt um, ich denke das so die Grafikkarten evtl. besser Arbeiten können (Eine Vermutung)
    Momentan hänge ich noch an der Analyse, der Array 'iAnalyse' liefert noch unerklärliche Daten...
    Spätere Versionen sollen noch weitere Methoden zur Analyse enthalten
    Auch soll noch der DeCompress-Key, welcher zur Entpackung nötig ist, wie im AU3 Orginal noch verarbeitet werden
*/

Alles anzeigen

Zu der Vorgehensweise, dem Kernel wird ein Datencluster (25KB) übergeben, dieser wird intern in '$iGlobalSize' große Teile geteilt. Ich Teste den Kernel mit '_CL_RunKernel(1, 0)' um nur mit einem Thread zu Arbeiten. Aber wie weise ich jetzt die richtige globale Threadanzahl zu? muß ich '_CL_RunKernel(int(StringLen($sInput) / $iGlobalSize)+1, 0)' verwenden?? Momentan zickt der Kernel noch rum deswegen lässt sich das schlecht testen...
Erstmal werde ich versuchen diesen Kernel in dieser Weise weiter auszubauen, sobald dieser richtig lauffähig ist möchte ich noch 'get_local_id(0)' integrieren - so wie ich das verstanden habe hat jeder globaler Thread ja noch seine lokalen Einheiten. (Ich hoffe das ist jetzt nicht zu Fantastisch)
Bei 'atomic_add(&iAnalyse[$i], Local_iAnalyse[$i])' übergebe ich an die Funktion 'atomic_add' den Pointer auf dem Index des 'iAnalyse' Array´s. Ich möchte die Analyse- und die Replacefunktion in 'Void' Funktionen packen und dort eben das gesammte Array übergeben - mache ich das denn so '_OclAnalyse(&iAnalyse)' auf 'void _OclAnalyse(uint *iArray)' ?? <- Dabei wird dieses Array doch 'ByRef' übergeben, oder?

[Multiprocessing]
In dem Script 'SimpleCompression_MP.au3' muß man ab Zeile 27 seine entsprechenden OpenCL-Devies eintragen - war die schnellste Lösung... Die Prozesse müssen kompiliert werden, werden als *.exe aufgerufen. Der 'SimpleCompression_AU3' Prozess läuft schonmal wie erwartet, und der 'SimpleCompression_OCL' verwendet den gleichen Kernel wie in 'SimpleCompression.au3' - ist somit noch nicht lauffähig. Aber die Basis des Multiprocessing sollte Lauffähig sein, bei den OCL-Part konnte nicht richtig testen aber es gibt bei mir 3 Rückgaben welcher meinen Devices entspricht.

Grüsse!

[EDIT]
Solltet ihr seltsamme Erscheiningungen in der OpenCL installation haben, wie z.B. mehr als einen Prozessor - obwohl ihr nur einen installiert habt; Dann habt ihr wahrscheinlich bei Intel Systemen erstmal die Runtime und anschliessend das SDK installiert. Ihr müsst einfach nur die Runtime DeInstallieren dann klärt sich das Problem.

[EDIT2]
Ich habe vergessen in 'SimpleCompression_MP.au3' die Zeile 101 zu De-Kommentieren, wenn diese Aktiviert wird startet auch das AutoIt Multiprocessing...

Techmix

Hy,
Zu Headsets kann ich leider weniger sagen, aber zu der restlichen Debatte schon. Ich bin absoluter Kabel-Freak!
Der hörbare Unterschied zwischen Kabelgebundener Übertragung und Funk - Ist so hoch wie beim Abspielen von Musik von orginal DVDs oder gerippt als mp3! Der eine hört es, der andere nicht - aber im direkten Vergleich nehmen es alle wahr.
Auch habe ich selber versilberte Litzen für die Hochtöner in meinem PC 5.1 System eingelötet. Habe sogar die Frequenzweichen mit Folienkondensatoren Ge-Pimpt. Verwende einen Kinobass aus dem Hause Teufel und einen super teuren JVC Digitalverstärker. Meine Frontspeaker haben Hochtöner mit Seidenkalotte, da kam das Stück 80€.
Auch vergoldete Stecker sind ein Muß! Schonmal Knackgeräusche gehört, oder erlebt das die Stereoposition sich verschoben hat? Liegt meißtens an den Steckern...
Grundsätzlich muß ich mir keine teuren Live BlueRays zum Musikhóren kaufen, Dvds tuns da auch. Aber Musik ist mir schon immer wichtig gewesen, und ich höre diese gerne in hoher Qualität. Deswegen habe ich mir auch die Arbeit gemacht 3 Frontspeaker selber zu entwickeln - sammt Frequenzweichen. Sehen zwar nicht hübsch aus, haben aber einen unbezahlbaren Sound!

Grüße!

Techmix

Hallo,
Ich muß Alina recht geben! Ohne Scriptausschnitt kann auch ich mir schlecht vorstellen wie dein Algorythmus aufgebaut ist... Das ist eigentlich auch selbstverständlich das du deinen Algo Postest wenn du eine Hilfestellung erwartest!
Hier sind Programmierer, keine Hellseher

Grüße!

Techmix

Hallo!

Danke für die Hinweise zu dem Kernel und der Paralellisierung!! Hatte mich schon gefragt wieso jedes mal andere Ergebnisse zustande kommen - Der Kernel selber konnte es nicht sein, das gibt es nichts zum falsch machen... Aber es wird jetzt immer besser mit OCL

>Gibst mir so eine Aufgabe, und wartest nichtmals das Wochenende ab...< Hatte mich extra damit beschäftigt weil ich mich darüber geärgert hatte, Habe 3 weitere Kernel geschrieben und den 4ten spare ich mir jetzt... Ich hänge das Script jetzt aus Trotz an
Ausserdem habe ich den 2ten Kernel vom vorigen Script lauffähig bekommen Es wird endlich richtig gezählt, aber die Auswertung folgt noch in Au3 und benötigt entsprechend viel Zeit. Gibt es vielleicht noch einen besseren (schnelleren) Weg die Daten zu sortieren?
Ich kläre diese Woche das Kompressionsscript, und prüfe mal welche Teile sich dafür eignen. Das war ja eh in meinem Sinn das Ding Aufzurollen. Die Standartmethode sollte jedoch gut umsetzbar sein, aber ich fände es trotzdem schön so nah an dem Orginal wie möglich zu bleiben...

Wenn man eine Lastanalyse für einen Kernel auf allen Devices durchführen möchte, dann muß ich doch so vorgehen das der Kernel auf jedem Device einzeln für nur einige Durchläufe ausgeführt werden soll - dabei die Zeit stoppen. Kann ich das z.B. so in etwa machen '_CL_RunKernel(StringLen($sInput) / 100, 0)' oder muß ich den Kernel extra dafür anpassen?
Theoretisch kann man Kernel im vorraus so Planen, das diese Multi fähig sind. Aber ich würde noch gerne 'Clustern' also alle OCL-Devices nutzen können (CPU/GPU Mix) - ich weiß inzwischen auch wie ich mit diesen umgehen muß

OpenCL Update

Hatte mich vielleicht undeutlich ausgedrückt
Vor dem Update:

Code

>Device verfügbar= 1;1;2;CPU;Intel(R) Core(TM) i7 CPU         920  @ 2.67GHz;18910080;18975064
>Device verfügbar= 2;1;4;GPU;GeForce GTX 460;57417256;57417200
>Device verfügbar= 2;2;4;GPU;GeForce GTX 460;9218672;57417200
CPU: _CL_GetDevice("cpu", 1,1)
GPU1: _CL_GetDevice("gpu", 2,1)
GPU2: _CL_GetDevice("gpu", 2,2)

Nach Update - Versuch 1:

Code

>Device verfügbar= 1;1;4;GPU;GeForce GTX 460;57417256;57417200
>Device verfügbar= 1;2;4;GPU;GeForce GTX 460;9218672;57417200
>Device verfügbar= 2;1;2;CPU;Intel(R) Core(TM) i7 CPU         920  @ 2.67GHz;18910080;18975064
CPU: _CL_GetDevice("cpu", 1,2)
GPU1: _CL_GetDevice("gpu", 1,1)
GPU2: _CL_GetDevice("gpu", 2,1)

Nach Update - Versuch 2:
Update auf: Nvidia (344.60), Intel (intel_sdk_for_ocl_applications_2014_x64):

Code

32Bit:
>Device verfügbar= 1;1;2;CPU;Intel(R) Core(TM) i7 CPU         920  @ 2.67GHz;46960640;46867144
>Device verfügbar= 2;1;4;GPU;GeForce GTX 460;69475744;69468584
>Device verfügbar= 2;2;4;GPU;GeForce GTX 460;69475800;69468584


64Bit:
WARNING: Linking two modules of different data layouts!
WARNING: Linking two modules of different target triples: C:\Program Files (x86)\Common Files\Intel\OpenCL\bin\common\clbltfnshared.rtl: 'i686-pc-win32-elf' and 'x86_64-pc-win32-elf'
>Device verfügbar= 1;1;2;CPU;Intel(R) Core(TM) i7 CPU         920  @ 2.67GHz;43352304;42695744
>Device verfügbar= 2;1;4;GPU;GeForce GTX 460;45596064;44965392
>Device verfügbar= 2;2;4;GPU;GeForce GTX 460;45596176;44965392


CPU: _CL_GetDevice("cpu", 1,1)
GPU1: _CL_GetDevice("gpu", 1,2)
GPU2: _CL_GetDevice("gpu", 2,2)

Alles anzeigen

Nach erneuter Neu-Installation aller OpenCL Komponenten, hat sich der Fehler immer noch nicht ganz geklärt...
So wie ich das sehe, hat das Update die komplette OCL-Installation durcheinander gebracht...
$num_device_used und $num_platform_used sind vertauscht, deswegen geht kein _cl_GetALLDevice("multi") mehr bei mir!
Seltsammerweise funktioniert aber _CL_GetALLDevice2("multi") mit $all=1 bei mir, _CL_GetALLDevice2("cpu") und $all=0 jedoch nicht... (aus 'tunnel_forum_ALL2.au3')
Die Aufrufe für die Grafikkarten muss ich umbedingt wieder so hinbiegen, wie sie zum Anfang waren - Das sorgt für Probleme bei der Multi Verwendung! Kennst du vielleicht irgendwelche Reg-Key´s (oder so) wo ich händisch eintragen kann wie die DeviceID´s auf die Platformen verteilt werden???

Grüsse!

P.S:
Diesmal hänge ich das Script an, zerstört sonst immer die Formatierung... Die Funktion 'CountChar_OCL2()' enthällt den zählenden Kernel, die anderen Funktionen sind experimentell.

Techmix

Mahlzeit

Ich mache eine neue Meldung, und zwar wollte ich auf meinem System die Intel OpenCL Runtime updaten. Dadurch hat sich die Device Reihenfolge verschoben!
Und das seltsammste ist jetzt der CL-CPU Aufruf '_CL_GetDevice("cpu", 1,2)'... Wie man entnehmen kann ist die Device und die Platform iwie vertauscht, bei diesem
Auruf müsste eigentlich der 2te GPU ausgewählt werden. Wenn ich den Aufruf wie gewohnt mit nur '_CL_GetDevice("cpu")' mache, passiert es das automatisch der erste GPU
ausgewählt wird...
Ich werde die gesammte OpenCL Installation vom Rechner entfernen und erst CPU und anschliessend GPU installieren, mal sehen ob das dir Reihenfolge wieder herstellt.
Auch laufen jetzt die von mir Gemoddeten Funktionen nicht mehr! Ebenso deine Multifunktionen.
Einige Vorteile hat das Update von Intel aber, ich erhalte jetzt etwas mehr Infos in der SciTE Ausgabe und auch ist der CPU bei Simd-Kerneln jetzt etwas schneller (10fps).
Die Verwendung von 64Bit beschleunigt "_CL_CreateBuffer()" um fast 50%!

>Device verfügbar= 1;1;4;GPU;GeForce GTX 460;58662400;57218520
>Device verfügbar= 1;2;4;GPU;GeForce GTX 460;58662480;57218520
>Device verfügbar= 2;1;2;CPU;Intel(R) Core(TM) i7 CPU 920 @ 2.67GHz;43780328;43771960

Ich habe auch versucht die angesprochene "Zeichen-Zählfunktion" in OCL zu realisieren, habe aber wieder Probleme mit dem Kernel, bzw. mit der Parameterübergabe. Sieh dir mal bitte den Kernel an, und sag mir was noch immer falsch ist - ich komme einfach nicht drauf?!?!?
Das ist furchtbar, bei jeder Ausführung erhalte ich untreschiedliche Ergebnisse... Liegt das jetzt am Kernel, oder an der Weise wie ich die Parameter übergebe?

Spoiler anzeigen

[autoit]

#Region - Includes -----------------------------------------------------------------------------------------------------------------
#AutoIt3Wrapper_UseX64=n
#AutoIt3Wrapper_UseUPX=n