Передача указателя от C до блока

Что касается вашего вопроса, то он довольно прост: просто измените заголовки функций, чтобы использовать volatile DWORD *resourceLock, и измените строки сборки, которые касаются resourceLock, чтобы использовать indirection:

mov ecx, dword ptr [resourceLock]
xchg eax, dword ptr [ecx]

и

mov ecx, dword ptr [resourceLock]
lock mov dword ptr [ecx], 1

Однако, обратите внимание, что у вас есть пара других проблем:

• Вы говорите, что разрабатываете это на Windows, но хотите перейти на Linux. Тем не менее, вы используете специфичную для MSVC встроенную сборку - при переходе на Linux она должна быть портирована на gcc-стиль (в частности, это подразумевает переход с синтаксиса Intel на синтаксис AT&T). Вам будет намного лучше разрабатывать с помощью gcc даже на Windows; это минимизирует боль при переносе (см. mingw для gcc для Windows).

• Грег Хьюгилл абсолютно прав насчет бесполезного вращения, останавливая блокировщика от получения процессора. Подумайте о том, чтобы уступить процессор, если вы слишком долго вращались.

• На мультипроцессоре x86 у вас вполне могут возникнуть проблемы с загрузкой памяти и хранением данных вокруг вашей блокировки - могут потребоваться инструкции по блокировке и разблокировке mfence.

На самом деле, если вы беспокоитесь о блокировке, это означает, что вы используете потоковое управление, что, вероятно, означает, что вы уже используете платформенные API для потокового управления. Поэтому используйте нативные примитивы синхронизации, а при переходе на Linux переключитесь на pthreads.

Если вы пишете это для Windows, вам следует серьезно подумать об использовании critical section объекта. Функции API критической секции оптимизированы таким образом, что они не перейдут в режим кернела, если в этом нет реальной необходимости, так что обычный случай отсутствия разногласий имеет очень мало накладных расходов.

Самая большая проблема с вашей спиновой блокировкой в том, что если вы работаете на одной процессорной системе и ждете блокировки, то вы используете все возможные циклы, и что бы ни удерживало блокировку, у вас даже не будет шанса запуститься до тех пор, пока не закончится ваше время и ядро не вытеснит ваш поток.

Использование критической секции будет более успешным, чем попытка откатить вашу собственную спиновую блокировку пользовательского режима.

Видимо, вы компилируете MSVC, используя встроенные блоки сборки в вашем C++ коде.

В качестве общего замечания, вам действительно следует использовать intrinsics компилятора, так как встроенная сборка не имеет будущего: она больше не поддерживается моими компиляторами MS при компиляции для x64.

Если вам нужны хорошо настроенные функции при сборке, вам придется реализовать их в отдельных файлах.

Вы должны использовать нечто подобное:

volatile LONG resourceLock = 1;

if(InterlockedCompareExchange(&resourceLock, 0, 1) == 1) {
    // success!
    // do something, and then
    resourceLock = 1;
} else {
    // failed, try again later
}

См. InterlockedCompareExchange.

Посмотрите документацию по компилятору, чтобы узнать, как распечатать сгенерированный язык ассемблера для функций.

Распечатайте ассемблерный язык для этой функции:

static void unLockResource(DWORD resourceLock )
{
  resourceLock = 0;
  return;
}

Это может не сработать, так как компилятор может оптимизировать функцию и удалить весь код. Необходимо изменить указатель на resourceLock, а затем заставить функцию установить блокировку. Распечатайте сборку этой рабочей функции.

Я уже предоставил рабочую версию, которая отвечала на вопрос оригинального плаката как о том, как получить параметры, передаваемые в ASM, так и о том, как заставить его замок работать корректно.

Многие другие ответы ставили под сомнение целесообразность использования ASM вообще и говорили о том, что следует использовать либо внутренние вызовы операционной системы, либо вызовы операционной системы на языке Си. Следующий ответ также работает и является C++ версией моего ответа на ASM. Там есть фрагмент ASM, который нужно использовать только в том случае, если ваша платформа не поддерживает InterlockedExchange().

class LockImpl
{
    // This is a simple SpinLock
    //  0 - in use / busy
    //  1 - free / available
public:
#if 1
    static DWORD MyInterlockedExchange(volatile DWORD *variable,DWORD newval)
    {
        // InterlockedExchange() uses LONG / He wants to use DWORD
        return((DWORD)InterlockedExchange(
            (volatile LONG *)variable,(LONG)newval));
    }
#else
    // You can use this if you don't have InterlockedExchange()
    // on your platform. Otherwise no ASM is required.
    static DWORD MyInterlockedExchange(volatile DWORD *variable,DWORD newval)
    {
        DWORD old;
        __asm 
        {
            mov     ebx, variable
            mov     eax, newval
            xchg    eax, [ebx]  ;// XCHG with BusLock
            mov     old, eax
        }
        return(old);
    }
#endif
    static void lockResource(volatile DWORD &resourceLock )
    {
        DWORD oldval;
        do 
        {
            while(0==resourceLock)
            {
                // Could have a yield, spin count, exponential 
                // backoff, OS CS fallback, etc. here
            }
            oldval=MyInterlockedExchange(&resourceLock,0);
        } while (0==oldval);
    }
    static void unLockResource(volatile DWORD &resourceLock)
    {
        // _ReadWriteBarrier() is a VC++ intrinsic that generates
        // no instructions / only prevents compiler reordering.
        // GCC uses __sync_synchronize() or __asm__ ( :::"memory" )
        _ReadWriteBarrier();
        resourceLock=1;
    }
};