void
       lock()
       {
         int __e = __gthread_mutex_lock(&_M_mutex);
   
         // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
         if (__e)
           __throw_system_error(__e);
       }

 static inline int
 __gthread_mutex_lock (__gthread_mutex_t *mutex)
 {
   if (__gthread_active_p ())
     return __gthrw_(pthread_mutex_lock) (mutex);
   else
     return 0;
 }

spin_outer:
cmp flag, 1
je spin_outer // waiting until 0

spin_inner:
test-and-set ax, flag //executed atomicly
// {
// mov ax, flag // fetch current value to ax
// mov flag, 1 // set flag to 1
// }

cmp ax, 1
jne spin_inner // if old value was 0

// now in critical section

call do_work

mov flag, 0 // clean flag
leave:

spinlock s;

s.lock();
// здесь делаем что-то элементарное!
s.unlock();

#include <iostream>
#include <thread>

int mutex = 0;

inline void Lock(int * flag) {
    
    int spins_count = 0;
    
    __asm {
    outer:
        mov rbx,flag
        mov eax,[rbx]
        cmp eax,0
        jne outer
        
        xor ecx,ecx
        xor eax, eax
        mov rbx,flag
    loop:
        inc ecx
        lock bts [rbx], eax   // lock + bts atomic test-and-set
        jnc loop
        mov spins_count,ecx
    }
    // locked
    std::cout << "\nINSIDE_THE_LOCK:" << spins_count << "\n";
    __asm {
        mov rbx,flag
        xor eax,eax
        mov [rbx],eax
    }
}

void spinner(char * id) {
    
    while (true) {
        Lock(&mutex);
        // not locked
        std::cout << "·" << "SPINNER:" << id << "·";
    }
}

int main() {
    char * Q = "Q";
    char * W = "W";
    
    std::thread t1(spinner, Q);
    std::thread t2(spinner, W);
    
    while (true) {
        // not locked
        std::cout << "•";
    }
}

•
INSIDE_THE_LOCK:••2•
•
INSIDE_THE_LOCK:·•2SPINNER:•
Q•··•SPINNER:
INSIDE_THE_LOCK:•W2•·
•
INSIDE_THE_LOCK:·•2SPINNER:•
Q•··•SPINNER:
INSIDE_THE_LOCK:•W2•·
•·
INSIDE_THE_LOCK:•SPINNER:2•
Q•··•SPINNER:
INSIDE_THE_LOCK:•W2•·
•·
INSIDE_THE_LOCK:•SPINNER:2•Q
•··•
INSIDE_THE_LOCK:SPINNER:•2W•
·•·
INSIDE_THE_LOCK:•SPINNER:2•Q
•··•
INSIDE_THE_LOCK:SPINNER:•2W•

::EnterCriticalSection(m_pCS);
// Самые элементарные действия с общими ресурсами
::LeaveCriticalSection(m_pCS);

#include <iostream>
#include <thread>
#include <atomic>

class SpinLock
{
public:
    void lock()
    {
        while(lck.test_and_set(std::memory_order_acquire))
        {}
    }
    
    void unlock()
    {
        lck.clear(std::memory_order_release);
    }
    
private:
    std::atomic_flag lck = ATOMIC_FLAG_INIT;
};

//int mutex = 0;
SpinLock lock;

inline void Lock(int * flag) {
    
    int spins_count = 0;
    
//    __asm {
//    outer:
//        mov rbx,flag
//        mov eax,[rbx]
//        cmp eax,0
//        jne outer
//
//        xor ecx,ecx
//        xor eax, eax
//        mov rbx,flag
//    loop:
//        inc ecx
//        lock bts [rbx], eax   // lock + bts atomic test-and-set
//        jnc loop
//        mov spins_count,ecx
//    }
    
    lock.lock();
    
    // locked
    std::cout << "\nINSIDE_THE_LOCK:" << spins_count << "\n";
    
    lock.unlock();

//    __asm {
//        mov rbx,flag
//        xor eax,eax
//        mov [rbx],eax
//    }
}

void spinner(char * id) {
    while (true) {
        Lock(&mutex);
        // not locked
        std::cout << "·" << "SPINNER:" << id << "·";
    }
}

int main() {
    
    char * Q = "Q";
    char * W = "W";
    
    std::thread t1(spinner, Q);
    std::thread t2(spinner, W);
    
    while (true) {
        // not locked
        std::cout << "•";
    }
}

.LBB0_1:                                # =>This Inner Loop Header: Depth=1
        mov     al, 1
        xchg    byte ptr [rip + lock], al
        test    al, al
        jne     .LBB0_1

B>.LBB0_1:                                # =>This Inner Loop Header: Depth=1
B>        mov     al, 1
B>        xchg    byte ptr [rip + lock], al

Ну так это test_and_set превращается в такой атомарный обмен с единицей.
Можно попросить Clang показать, как это выглядит на уровне его LL-представления. Мне 4.0 выдал такое:
[code]
  %5 = atomicrmw xchg i8* getelementptr inbounds ({ { i8 } }, { { i8 } }* @lock, i64 0, i32 0, i32 0), i8 1 acquire

If a memory operand is referenced, the processor’s locking protocol is automatically implemented for the duration of the exchange operation, regardless of the presence or absence of the LOCK prefix or of the value of the IOPL. (See the LOCK prefix description in this chapter for more information on the locking protocol.)
This instruction is useful for implementing semaphores or similar data structures for process synchronization. (See “Bus Locking” in Chapter 8 of the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A, for more information on bus locking.)

Под Windows, например (VS2013), std::mutex реализован без использования вызовов WinAPI, почти так, как вы и описали, но spin блокировка крутится заданное число циклов (сейчас 4000) и уже по истечении этого времени квант потока отдается (он засыпает на pause). Фактически в С++ рантайм вынесены "кишки" стандартной critical section.

AG>>::EnterCriticalSection(m_pCS);
AG>>// Самые элементарные действия с общими ресурсами
AG>>::LeaveCriticalSection(m_pCS);
AG>>

#include <atomic>
 
class SpinLock
{
public:
    void lock()
    {
        while(lck.test_and_set(std::memory_order_acquire)) // здесь, возможно, придется подождать!
        {}
    }
 
    void unlock()
    {
        lck.clear(std::memory_order_release);
    }
 
private:
    std::atomic_flag lck = ATOMIC_FLAG_INIT;
};