1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

unter welcher prog kann ich assembler laufen lassen???

Dieses Thema im Forum "Unix & Terminal" wurde erstellt von tigga.ls, 19.11.07.

  1. tigga.ls

    tigga.ls Jamba

    Dabei seit:
    04.12.06
    Beiträge:
    55
    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
     
  2. lemming71

    lemming71 Weisser Rosenapfel

    Dabei seit:
    02.12.05
    Beiträge:
    780
    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.
     
  3. delycs

    delycs Weigelts Zinszahler (Rotfranch)

    Dabei seit:
    13.09.06
    Beiträge:
    245
    zu 1) wird wohl mit "make" gehen, wie jedes andere Kompilat auch :) Es gibt diverse Assembler-Umgebungen, aber
    Code:
    [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:
    Code:
    [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:
    Code:
    [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.
     
  4. tigga.ls

    tigga.ls Jamba

    Dabei seit:
    04.12.06
    Beiträge:
    55
    danke euch ich werde es mal austesten und euch evtl nochmal belässtigen :p
     

Diese Seite empfehlen