On the Intel type of x86 processors including AMD, increasingly there are more CPU cores or processors running in parallel.

In the old days when there was a single processor, the operation:

++i; 

Would be thread safe because it was one machine instruction on a single processor. These days laptops have numerous CPU cores so that even single instruction operations aren't safe. What do you do? Do you need to wrap all operations in a mutex or semaphore? Well, maybe you don't need too.

Fortunately, the x86 has an instruction prefix that allows a few memory referencing instruction to execute on specific memory locations exclusively.

There are a few basic structures that can use this:

(for the GNU Compiler)

void atom_inc(volatile int *num)
{
        __asm__ __volatile__ ( "lock incl %0" : "=m" (*num));
}
void atom_dec(volatile int *num)
{
        __asm__ __volatile__ ( "lock decl %0" : "=m" (*num));
}
int atom_xchg(volatile int *m, int inval)
{
        register int val = inval;
        __asm__ __volatile__ ( "lock xchg %1,%0" : "=m" (*m), "=r" (val) : "1" (inval));
        return val;
}
void atom_add(volatile int *m, int inval)
{
        register int val = inval;
        __asm__ __volatile__ ( "lock add %1,%0" : "=m" (*m), "=r" (val) : "1" (inval));
}
void atom_sub(volatile int *m, int inval)
{
        register int val = inval;
        __asm__ __volatile__ ( "lock sub %1,%0" : "=m" (*m), "=r" (val) : "1" (inval));
}

For the Microsoft Compiler:

void atom_inc(volatile int *num)
{
        _asm
        {
                        mov     esi,    num
                lock    inc     DWORD PTR [esi]
        };
}
void atom_dec(volatile int *num)
{
        _asm
        {               mov     esi,    num
                lock    dec     DWORD PTR [esi]
        };
}
int atom_xchg(volatile int *m, int inval)
{
        _asm
        {
                        mov     eax,    inval
                        mov     esi,    m
                lock    xchg    eax,    DWORD PTR [esi]
                        mov     inval,  eax
        }
        return inval;
}
void atom_add(volatile int *num, int val)
{
        _asm
        {               mov     esi,    num
                        mov     eax,    val
                lock    add     DWORD PTR [esi], eax
        };
}
void atom_sub(volatile int *num, int val)
{
        _asm
        {               mov     esi,    num
                        mov     eax,    val
                lock    sub     DWORD PTR [esi], eax
        };
}

The lock prefix is not universally applied. It only works if all accesses to the locations also use lock. So, even though you use "lock" in one section of code, another section of code that just sets the value will not be locked out. Think of it as just a mutex.

Basic usage:

class poll
{
    int m_pollCount;
    ....
    ....

    void pollAdd()
    { 
        atom_inc(&m_pollCount);
    }
};

The above example increments a poll object count by one.