unter welcher prog kann ich assembler laufen lassen???

[tigga.ls]

hallo pro's

ich bin in 1. Semester Informatik Studium und leider ist an meiner Hochschule nur Windows Rechner und natürlich muss ich da mit diesen Maschinen arbeiten...
was ich doch gerne wissen möchte ist dies:

1. mit was kann ich auf mein MB Assembler laufen lassen? welches prog'?
2. funktioniert er wie auf den Windows Rechnern??
3. gibt es auch (eine Art) Benutzeranleitung???

ich danke euch schon mal

 

[lemming71]

hallo pro's

ich bin in 1. Semester Informatik Studium und leider ist an meiner Hochschule nur Windows Rechner und natürlich muss ich da mit diesen Maschinen arbeiten...
was ich doch gerne wissen möchte ist dies:

1. mit was kann ich auf mein MB Assembler laufen lassen? welches prog'?
2. funktioniert er wie auf den Windows Rechnern??
3. gibt es auch (eine Art) Benutzeranleitung???

ich danke euch schon mal

Ich denke mal, Du willst/musst Assembler aber ebenfalls unter Win programmieren, oder?
Also ich bin kein Developer oder sowas. Aber in Deinem Fall empfehle ich foglendes:

1.) Nutze eine virtuelle Umgebung um ein Windows auf Deinem MB unterzubringen. Entweder kommerzielles wie VMWare oder Parallels oder gute Freeware wie unter virtualbox.org zu finden.

2.) Schnapp Dir dann Entwicklungstools für Windows, es gibt da glaube ich irgendein von ehem. Borland entwickeltes C++-Paket für Lau. Assembler wird es bestimmt auch geben, für die Hardcore-Fraktion. Da fragste dann aber am Besten in Windows Boards nach, zum Beispiel bei chip.de oder so.

 

[delycs]

1. mit was kann ich auf mein MB Assembler laufen lassen? welches prog'?
2. funktioniert er wie auf den Windows Rechnern??
3. gibt es auch (eine Art) Benutzeranleitung???

zu 1) wird wohl mit "make" gehen, wie jedes andere Kompilat auch Es gibt diverse Assembler-Umgebungen, aber

[SIZE=1]__asm{ 
 mov eax,sz 
...
}[/SIZE]

sollte einen C-Compiler wohl zum Übersetzen nötigen. Das Ganze packst du vorher noch schön in C-Code (main() und #includes) und dann sollte es gehen.

zu 2) JA. VS.Net ist dein Freund. Wie üblich kann es sein das der die Syntax etwas anders ist also mit Präprozessor-Direktiven arbeiten. Bsp:

[SIZE=1]#ifndef SAD_SSE_H
#define SAD_SSE_H

#ifndef WIN32
inline int SADsse(const unsigned int *p1, const unsigned int *p2, unsigned int ws, unsigned int skip)
{
    int sum; 
    asm volatile(
        ".intel_syntax noprefix            \n"   // normalen x86-Assembler-Syntax einschalten
        // in mm0 wird aufsummiert
        "pxor xmm0, xmm0                    \n"   // mm0 auf 0 setzen
        //cl zählt zeilen
        //ch zählt spalten
        //Fenstergröße ws ist in dl
        "mov cl, dl                        \n"   
        "shr dl, 1                        \n"   // da wir 2 Pixel gleichzeitg bearbeiten, brauchen wir
                                              // nur halbsoviele durchläufe in der innersten schleife
        "nextrow:                        \n"   // BEGIN schleife für zeilen
        "    mov ch, dl                    \n"
        "    nextcol:                    \n"   // BEGIN schleife für spalten
        "        movq xmm1, [eax]            \n"  // *p1 in mm1 (2 pixel)
        "        movq xmm2, [ebx]            \n"  // *p2 in mm2 (2 pixel)
        "        psadbw xmm1, xmm2            \n"  // summe der absoluten differenzen (erg in mm1)
        "        paddd xmm0, xmm1            \n"  // in mm0 aufsummieren
        "        add eax, 8                \n"  // 2 pixel weiter
        "        add ebx, 8                \n"
        "    dec ch                        \n"   // ENDE schleife für spalten
        "    jnz nextcol                    \n"   
        "add eax, edi                    \n"   // p1+=skip;
        "add ebx, edi                    \n"   // p2+=skip;
        "dec cl                            \n"   // ENDE schleife für zeilen
        "jnz nextrow                    \n"
        "movd edx, xmm0                    \n"   // summe aus mm0 in edx speichern
        ".att_syntax                    \n"   // gnu-assebler-syntax wiederherstellen
    :"=d"(sum)          // ergebnis aus edx in sum
    :"d"(ws),           // ws in dl
     "D"(skip),         // skip in edi
     "a"(p1),"b"(p2)    // zeiger p1 in eax und zeiger p2 in ebx
    :"ecx","xmm0","xmm1","xmm2");            // ecx register wird verändert*/
    return sum;
}

#else
__forceinline int SADsse(const unsigned int *p1, const unsigned int *p2, unsigned int ws, unsigned int skip)
{
    int sum; 
    __asm
    {
        mov edx, ws
        mov edi, skip
        mov eax, p1
        mov ebx, p2
     
        // in mm0 wird aufsummiert
        pxor mm0, mm0       // mm0 auf 0 setzen
        //cl zählt zeilen
        //ch zählt spalten
        //Fenstergröße ws ist in dl
        mov cl, dl
        shr dl, 1                     // da wir 2 Pixel gleichzeitg bearbeiten, brauchen wir
                                     // nur halbsoviele durchläufe in der innersten schleife
        nextrow:                     // BEGIN schleife für zeilen
            mov ch, dl
            nextcol:                 // BEGIN schleife für spalten
                movq mm1, [eax]         // *p1 in mm1 (2 pixel)
                movq mm2, [ebx]         // *p2 in mm2 (2 pixel)
                psadbw mm1, mm2         // summe der absoluten differenzen (erg in mm1)
                paddd mm0, mm1         // in mm0 aufsummieren
                add eax, 8             // 2 pixel weiter
                add ebx, 8
            dec ch                     // ENDE schleife für spalten
            jnz nextcol   
            add eax, edi             // p1+=skip;
            add ebx, edi             // p2+=skip;
        dec cl                         // ENDE schleife für zeilen
        jnz nextrow
        movd edx, mm0                 // summe aus mm0 in edx speichern
        emms                         // wir sind fertig mit mmx
        mov sum, edx
    }
    return sum;
}
#endif
#endif[/SIZE]

ohne SSE siehts so aus:

[SIZE=1]inline unsigned int SAD(const unsigned char *pP1, const unsigned char *pP2, size_t pWidth, size_t pWin)
{
    unsigned int tSum=0;
    pWidth = pWidth << 2;
    size_t tWin4 = pWin << 2;
    // calc the number of bytes we have to skip to get to the next line
    pWidth-=tWin4;
    for(size_t tRow=0; tRow<pWin; tRow++)
    {
        for(size_t tCol=0; tCol<tWin4; tCol++)
        {
            int tDiff = (int)*pP1 - (int)*pP2;
            if(tDiff<0) tDiff = -tDiff;
            tSum+= (unsigned int)tDiff;
            // next pixel
            pP1++;
            pP2++;
        }
        // next line
        pP1+=pWidth;
        pP2+=pWidth;
    }
    return tSum;
}[/SIZE]

zu 3: MSDN, Hilfe zur Gnu-Compiler-Collection

Hinweis und Nachtrag: Wie man das mit XCode macht weiß ich nicht. Sollte aber sicher ähnlich sein. Das gilt übrigens nur für X86 Prozessoren. PPC ist ein anderes Buch. Oben genannte Beispiele sind SSE-Code. Sollte also auch auf nem MB laufen, da dieses nen CD oder C2D hat der SSE unterstützt. Bei Verwendung von AMD's gibts eigentlich nur bei neueren ASM-Befehlen Unterschiede. bis SSE3 ist man mit aktuellen Prozessoren auf der sicheren Seite.

 

[tigga.ls]

danke euch ich werde es mal austesten und euch evtl nochmal belässtigen