Module: E:\source\tmp\spin.cpp
Group: 'DGROUP' CONST,CONST2,_DATA,_BSS

Segment: _TEXT  PARA USE32  00000327 bytes  

#define INCL_NOPMAPI
#define WIN32_LEAN_AND_MEAN
#define BIFINCL_THREAD
#define BIFINCL_SEMAPHORES
#include <bif.h>

// A few low-level operations
extern "C" void LockedIncrement(unsigned *p);
#pragma aux LockedIncrement = \
".386p                      " \
"lock inc dword ptr [eax]   " \
parm [eax] modify [];

extern "C" void LockedDecrement(unsigned *p);
#pragma aux LockedDecrement = \
".386p                       "\
"lock dec dword ptr [eax]    "\
parm [eax] modify [];

extern "C" unsigned LockedExchange(unsigned *p, unsigned v);
#pragma aux LockedExchange = \
".386p                      "\
"lock xchg ecx,[eax]        "\
parm [eax] [ecx] modify [] value [ecx];


const spin_retries=100;
///////////////////////////////////////////////////////////////////////////////
//FSpinMutex

class FSpinMutex {
        unsigned toggle;
        unsigned waiters;
        FEventSemaphore try_again;
public:
        FSpinMutex() : toggle(0), waiters(0), try_again() {}
        void Request();
        void Release();
};

void FSpinMutex::Request() {
 0000                    void near FSpinMutex::Request():
 0000  53                                push    ebx
 0001  51                                push    ecx
 0002  52                                push    edx
 0003  56                                push    esi
 0004  89 c3                             mov     ebx,eax
 0006  31 f6                             xor     esi,esi
 0008  b9 01 00 00 00    L1              mov     ecx,00000001H
 000d  89 d8                             mov     eax,ebx
 000f  f0 87 08                          lock    xchg     ecx,[eax]
 0012  85 c9                             test    ecx,ecx
 0014  74 3d                             je      L4

        for(unsigned spin=0; spin<spin_retries; spin++) {
                if(LockedExchange(&toggle,1)==0)
                        return;
        }
 0016  46                                inc     esi
 0017  83 fe 64                          cmp     esi,00000064H
 001a  72 ec                             jb      L1

        LockedIncrement(&waiters);
 001c  8d 43 04                          lea     eax,+4H[ebx]
 001f  f0 ff 00                          lock    inc      dword ptr [eax]
 0022  8d 73 08                          lea     esi,+8H[ebx]

        for(;;) {
                if(LockedExchange(&toggle,1)==0) {
 0025  b9 01 00 00 00    L2              mov     ecx,00000001H
 002a  89 d8                             mov     eax,ebx
 002c  f0 87 08                          lock    xchg     ecx,[eax]
 002f  85 c9                             test    ecx,ecx
 0031  75 0b                             jne     L3

                        LockedDecrement(&waiters);
 0033  8d 43 04                          lea     eax,+4H[ebx]
 0036  f0 ff 08                          lock    dec      dword ptr [eax]

                        return;
                }
 0039  5e                                pop     esi
 003a  5a                                pop     edx
 003b  59                                pop     ecx
 003c  5b                                pop     ebx
 003d  c3                                ret     

                try_again.Wait();
 003e  ba ff ff ff ff    L3              mov     edx,0ffffffffH
 0043  89 f0                             mov     eax,esi
 0045  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )

                try_again.Reset();
 004a  89 f0                             mov     eax,esi
 004c  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()

        }
 0051  eb d2                             jmp     L2

}

 0053  5e                L4              pop     esi
 0054  5a                                pop     edx
 0055  59                                pop     ecx
 0056  5b                                pop     ebx
 0057  c3                                ret     

void FSpinMutex::Release() {
        toggle=0;
 0058                    void near FSpinMutex::Release():
 0058  52                                push    edx

 0059  8b 50 04                          mov     edx,+4H[eax]

        if(waiters!=0)
 005c  c7 00 00 00 00 00                 mov     dword ptr [eax],00000000H
 0062  85 d2                             test    edx,edx
 0064  74 08                             je      L5

                try_again.Post();
 0066  83 c0 08                          add     eax,00000008H
 0069  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

}

///////////////////////////////////////////////////////////////////////////////
//SpinEvent
class FSpinEvent {
        unsigned toggle;
        FEventSemaphore wakeup;
        FSpinMutex modify;
public:
        FSpinEvent()
          : toggle(0),
            wakeup(0),
            modify()
          { }
        void Post();
        void Reset();
        void Wait();
};

 006e  5a                L5              pop     edx
 006f  c3                                ret     

void FSpinEvent::Post() {
 0070                    void near FSpinEvent::Post():
 0070  53                                push    ebx
 0071  51                                push    ecx
 0072  52                                push    edx
 0073  56                                push    esi
 0074  57                                push    edi
 0075  89 c7                             mov     edi,eax
 0077  8d 58 0c                          lea     ebx,+0cH[eax]
 007a  31 f6                             xor     esi,esi
 007c  b9 01 00 00 00    L6              mov     ecx,00000001H
 0081  89 d8                             mov     eax,ebx
 0083  f0 87 08                          lock    xchg     ecx,[eax]
 0086  85 c9                             test    ecx,ecx
 0088  74 3a                             je      L9
 008a  46                                inc     esi
 008b  83 fe 64                          cmp     esi,00000064H
 008e  72 ec                             jb      L6

        modify.Request();
 0090  8d 43 04                          lea     eax,+4H[ebx]
 0093  f0 ff 00                          lock    inc      dword ptr [eax]
 0096  8d 73 08                          lea     esi,+8H[ebx]
 0099  b9 01 00 00 00    L7              mov     ecx,00000001H
 009e  89 d8                             mov     eax,ebx
 00a0  f0 87 08                          lock    xchg     ecx,[eax]
 00a3  85 c9                             test    ecx,ecx
 00a5  75 08                             jne     L8
 00a7  8d 43 04                          lea     eax,+4H[ebx]
 00aa  f0 ff 08                          lock    dec      dword ptr [eax]
 00ad  eb 15                             jmp     L9
 00af  ba ff ff ff ff    L8              mov     edx,0ffffffffH
 00b4  89 f0                             mov     eax,esi
 00b6  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )
 00bb  89 f0                             mov     eax,esi
 00bd  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()
 00c2  eb d5                             jmp     L7

        if(LockedExchange(&toggle,1)==0)
 00c4  b9 01 00 00 00    L9              mov     ecx,00000001H
 00c9  89 f8                             mov     eax,edi
 00cb  f0 87 08                          lock    xchg     ecx,[eax]
 00ce  85 c9                             test    ecx,ecx
 00d0  75 08                             jne     L10

                wakeup.Post();
 00d2  8d 47 04                          lea     eax,+4H[edi]
 00d5  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

        modify.Release();
 00da  83 c7 0c          L10             add     edi,0000000cH
 00dd  8b 57 04                          mov     edx,+4H[edi]
 00e0  c7 07 00 00 00 00                 mov     dword ptr [edi],00000000H
 00e6  85 d2                             test    edx,edx
 00e8  74 08                             je      L11
 00ea  8d 47 08                          lea     eax,+8H[edi]
 00ed  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

}

 00f2  5f                L11             pop     edi
 00f3  5e                                pop     esi
 00f4  5a                                pop     edx
 00f5  59                                pop     ecx
 00f6  5b                                pop     ebx
 00f7  c3                                ret     

void FSpinEvent::Reset() {
 00f8                    void near FSpinEvent::Reset():
 00f8  53                                push    ebx
 00f9  51                                push    ecx
 00fa  52                                push    edx
 00fb  56                                push    esi
 00fc  57                                push    edi
 00fd  89 c7                             mov     edi,eax
 00ff  8d 58 0c                          lea     ebx,+0cH[eax]
 0102  31 f6                             xor     esi,esi
 0104  b9 01 00 00 00    L12             mov     ecx,00000001H
 0109  89 d8                             mov     eax,ebx
 010b  f0 87 08                          lock    xchg     ecx,[eax]
 010e  85 c9                             test    ecx,ecx
 0110  74 3a                             je      L15
 0112  46                                inc     esi
 0113  83 fe 64                          cmp     esi,00000064H
 0116  72 ec                             jb      L12

        modify.Request();
 0118  8d 43 04                          lea     eax,+4H[ebx]
 011b  f0 ff 00                          lock    inc      dword ptr [eax]
 011e  8d 73 08                          lea     esi,+8H[ebx]
 0121  b9 01 00 00 00    L13             mov     ecx,00000001H
 0126  89 d8                             mov     eax,ebx
 0128  f0 87 08                          lock    xchg     ecx,[eax]
 012b  85 c9                             test    ecx,ecx
 012d  75 08                             jne     L14
 012f  8d 43 04                          lea     eax,+4H[ebx]
 0132  f0 ff 08                          lock    dec      dword ptr [eax]
 0135  eb 15                             jmp     L15
 0137  ba ff ff ff ff    L14             mov     edx,0ffffffffH
 013c  89 f0                             mov     eax,esi
 013e  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )
 0143  89 f0                             mov     eax,esi
 0145  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()
 014a  eb d5                             jmp     L13
 014c  89 f8             L15             mov     eax,edi

        if(LockedExchange(&toggle,0)==1)
 014e  31 c9                             xor     ecx,ecx
 0150  f0 87 08                          lock    xchg     ecx,[eax]
 0153  83 f9 01                          cmp     ecx,00000001H
 0156  75 08                             jne     L16

                wakeup.Reset();
 0158  8d 47 04                          lea     eax,+4H[edi]
 015b  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()

        modify.Release();
 0160  83 c7 0c          L16             add     edi,0000000cH
 0163  8b 57 04                          mov     edx,+4H[edi]
 0166  c7 07 00 00 00 00                 mov     dword ptr [edi],00000000H
 016c  85 d2                             test    edx,edx
 016e  74 08                             je      L17
 0170  8d 47 08                          lea     eax,+8H[edi]
 0173  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

}

 0178  5f                L17             pop     edi
 0179  5e                                pop     esi
 017a  5a                                pop     edx
 017b  59                                pop     ecx
 017c  5b                                pop     ebx
 017d  c3                                ret     
 017e  8b c0                             mov     eax,eax

void FSpinEvent::Wait() {
 0180                    void near FSpinEvent::Wait():
 0180  52                                push    edx
 0181  89 c2                             mov     edx,eax
 0183  31 c0                             xor     eax,eax
 0185  83 3a 00          L18             cmp     dword ptr [edx],00000000H
 0188  75 13                             jne     L19

        for(unsigned spin=0; spin<spin_retries; spin++) {
                if(toggle)
                        return;
        }
 018a  40                                inc     eax
 018b  83 f8 64                          cmp     eax,00000064H
 018e  72 f5                             jb      L18

        wakeup.Wait();
 0190  8d 42 04                          lea     eax,+4H[edx]
 0193  ba ff ff ff ff                    mov     edx,0ffffffffH
 0198  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )

}

///////////////////////////////////////////////////////////////////////////////
//SpinSemaphore
class FSpinSemaphore {
        unsigned count;
        FEventSemaphore notzero;
        FSpinMutex wait_mutex,change_mutex;
public:
        FSpinSemaphore()
          : count(0),
            notzero(0),
            wait_mutex(),
            change_mutex()
          {}
        void Signal();
        void Wait();
};

 019d  5a                L19             pop     edx
 019e  c3                                ret     
 019f  90                                nop     

void FSpinSemaphore::Signal() {
 01a0                    void near FSpinSemaphore::Signal():
 01a0  53                                push    ebx
 01a1  51                                push    ecx
 01a2  52                                push    edx
 01a3  56                                push    esi
 01a4  57                                push    edi
 01a5  89 c7                             mov     edi,eax
 01a7  8d 58 1c                          lea     ebx,+1cH[eax]
 01aa  31 f6                             xor     esi,esi
 01ac  b9 01 00 00 00    L20             mov     ecx,00000001H
 01b1  89 d8                             mov     eax,ebx
 01b3  f0 87 08                          lock    xchg     ecx,[eax]
 01b6  85 c9                             test    ecx,ecx
 01b8  74 3a                             je      L23
 01ba  46                                inc     esi
 01bb  83 fe 64                          cmp     esi,00000064H
 01be  72 ec                             jb      L20

        change_mutex.Request();
 01c0  8d 43 04                          lea     eax,+4H[ebx]
 01c3  f0 ff 00                          lock    inc      dword ptr [eax]
 01c6  8d 73 08                          lea     esi,+8H[ebx]
 01c9  b9 01 00 00 00    L21             mov     ecx,00000001H
 01ce  89 d8                             mov     eax,ebx
 01d0  f0 87 08                          lock    xchg     ecx,[eax]
 01d3  85 c9                             test    ecx,ecx
 01d5  75 08                             jne     L22
 01d7  8d 43 04                          lea     eax,+4H[ebx]
 01da  f0 ff 08                          lock    dec      dword ptr [eax]
 01dd  eb 15                             jmp     L23
 01df  ba ff ff ff ff    L22             mov     edx,0ffffffffH
 01e4  89 f0                             mov     eax,esi
 01e6  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )
 01eb  89 f0                             mov     eax,esi
 01ed  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()
 01f2  eb d5                             jmp     L21

        LockedIncrement(&count);
 01f4  89 f8             L23             mov     eax,edi
 01f6  f0 ff 00                          lock    inc      dword ptr [eax]

        if(count==1)
 01f9  83 3f 01                          cmp     dword ptr [edi],00000001H
 01fc  75 08                             jne     L24

                notzero.Post();
 01fe  8d 47 04                          lea     eax,+4H[edi]
 0201  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

        change_mutex.Release();
 0206  83 c7 1c          L24             add     edi,0000001cH
 0209  8b 5f 04                          mov     ebx,+4H[edi]
 020c  c7 07 00 00 00 00                 mov     dword ptr [edi],00000000H
 0212  85 db                             test    ebx,ebx
 0214  74 08                             je      L25
 0216  8d 47 08                          lea     eax,+8H[edi]
 0219  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

}

 021e  5f                L25             pop     edi
 021f  5e                                pop     esi
 0220  5a                                pop     edx
 0221  59                                pop     ecx
 0222  5b                                pop     ebx
 0223  c3                                ret     

void FSpinSemaphore::Wait() {
 0224                    void near FSpinSemaphore::Wait():
 0224  53                                push    ebx
 0225  51                                push    ecx
 0226  52                                push    edx
 0227  56                                push    esi
 0228  57                                push    edi
 0229  89 c7                             mov     edi,eax
 022b  8d 58 0c                          lea     ebx,+0cH[eax]
 022e  31 f6                             xor     esi,esi
 0230  b9 01 00 00 00    L26             mov     ecx,00000001H
 0235  89 d8                             mov     eax,ebx
 0237  f0 87 08                          lock    xchg     ecx,[eax]
 023a  85 c9                             test    ecx,ecx
 023c  74 3a                             je      L29
 023e  46                                inc     esi
 023f  83 fe 64                          cmp     esi,00000064H
 0242  72 ec                             jb      L26

        wait_mutex.Request();
 0244  8d 43 04                          lea     eax,+4H[ebx]
 0247  f0 ff 00                          lock    inc      dword ptr [eax]
 024a  8d 73 08                          lea     esi,+8H[ebx]
 024d  b9 01 00 00 00    L27             mov     ecx,00000001H
 0252  89 d8                             mov     eax,ebx
 0254  f0 87 08                          lock    xchg     ecx,[eax]
 0257  85 c9                             test    ecx,ecx
 0259  75 08                             jne     L28
 025b  8d 43 04                          lea     eax,+4H[ebx]
 025e  f0 ff 08                          lock    dec      dword ptr [eax]
 0261  eb 15                             jmp     L29
 0263  ba ff ff ff ff    L28             mov     edx,0ffffffffH
 0268  89 f0                             mov     eax,esi
 026a  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )
 026f  89 f0                             mov     eax,esi
 0271  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()
 0276  eb d5                             jmp     L27

        for(unsigned spin=0; spin<spin_retries; spin++) {
 0278  31 db             L29             xor     ebx,ebx

                if(count>0) goto OkeyDokey;
        }
 027a  83 3f 00          L30             cmp     dword ptr [edi],00000000H
 027d  77 13                             ja      L31
 027f  43                                inc     ebx
 0280  83 fb 64                          cmp     ebx,00000064H
 0283  72 f5                             jb      L30

        notzero.Wait();
 0285  ba ff ff ff ff                    mov     edx,0ffffffffH
 028a  8d 47 04                          lea     eax,+4H[edi]
 028d  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )

OkeyDokey:
 0292  8d 5f 1c          L31             lea     ebx,+1cH[edi]
 0295  31 f6                             xor     esi,esi
 0297  b9 01 00 00 00    L32             mov     ecx,00000001H
 029c  89 d8                             mov     eax,ebx
 029e  f0 87 08                          lock    xchg     ecx,[eax]
 02a1  85 c9                             test    ecx,ecx
 02a3  74 3a                             je      L35
 02a5  46                                inc     esi
 02a6  83 fe 64                          cmp     esi,00000064H
 02a9  72 ec                             jb      L32

        change_mutex.Request();
 02ab  8d 43 04                          lea     eax,+4H[ebx]
 02ae  f0 ff 00                          lock    inc      dword ptr [eax]
 02b1  8d 73 08                          lea     esi,+8H[ebx]
 02b4  b9 01 00 00 00    L33             mov     ecx,00000001H
 02b9  89 d8                             mov     eax,ebx
 02bb  f0 87 08                          lock    xchg     ecx,[eax]
 02be  85 c9                             test    ecx,ecx
 02c0  75 08                             jne     L34
 02c2  8d 43 04                          lea     eax,+4H[ebx]
 02c5  f0 ff 08                          lock    dec      dword ptr [eax]
 02c8  eb 15                             jmp     L35
 02ca  ba ff ff ff ff    L34             mov     edx,0ffffffffH
 02cf  89 f0                             mov     eax,esi
 02d1  e8 00 00 00 00                    call    int near FEventSemaphore::Wait( long )
 02d6  89 f0                             mov     eax,esi
 02d8  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()
 02dd  eb d5                             jmp     L33

        LockedDecrement(&count);
 02df  89 f8             L35             mov     eax,edi
 02e1  f0 ff 08                          lock    dec      dword ptr [eax]

        if(count==0)
 02e4  83 3f 00                          cmp     dword ptr [edi],00000000H
 02e7  75 08                             jne     L36

          notzero.Reset();
 02e9  8d 47 04                          lea     eax,+4H[edi]
 02ec  e8 00 00 00 00                    call    int near FEventSemaphore::Reset()

        change_mutex.Release();
 02f1  8d 5f 1c          L36             lea     ebx,+1cH[edi]
 02f4  8b 4b 04                          mov     ecx,+4H[ebx]
 02f7  c7 03 00 00 00 00                 mov     dword ptr [ebx],00000000H
 02fd  85 c9                             test    ecx,ecx
 02ff  74 08                             je      L37
 0301  8d 43 08                          lea     eax,+8H[ebx]
 0304  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

        wait_mutex.Release();
 0309  83 c7 0c          L37             add     edi,0000000cH
 030c  8b 77 04                          mov     esi,+4H[edi]
 030f  c7 07 00 00 00 00                 mov     dword ptr [edi],00000000H
 0315  85 f6                             test    esi,esi
 0317  74 08                             je      L38
 0319  8d 47 08                          lea     eax,+8H[edi]
 031c  e8 00 00 00 00                    call    int near FEventSemaphore::Post()

}
 0321  5f                L38             pop     edi
 0322  5e                                pop     esi
 0323  5a                                pop     edx
 0324  59                                pop     ecx
 0325  5b                                pop     ebx
 0326  c3                                ret     

No disassembly errors

------------------------------------------------------------