将指针从 C 传递到程序集

Question

我想在我的 C/C++ 程序中使用带有原子交换汇编指令的“_test_and_set lock”汇编语言实现。

class LockImpl 
{
  public:
  static void lockResource(DWORD resourceLock )
  {
    __asm 
    {
      InUseLoop:  mov     eax, 0;0=In Use
                  xchg    eax, resourceLock
                  cmp     eax, 0
                  je      InUseLoop
    }

  }

  static void unLockResource(DWORD resourceLock )
  {
    __asm 
    {
      mov resourceLock , 1 
    }   

  }
};

这可行，但这里有一个错误。

问题是我想传递 DWORD * resourceLock 而不是 DWORD resourceLock。

所以问题是如何将指针从 C/C++ 传递给程序集并将其取回。 ?

提前致谢。

问候， -杰。

附：这样做是为了避免用户空间和内核空间之间的上下文切换。

Answer 1

如果您正在为 Windows 编写此代码，您应该认真考虑使用 critical section 对象。临界区 API 函数经过优化，除非确实需要，否则它们不会转换到内核模式，因此正常情况下没有争用的开销很小。

自旋锁的最大问题是，如果您在单个 CPU 系统上并且正在等待锁，那么您将使用所有可以使用的周期，而持有锁的任何东西都不会有机会运行，直到您的时间片结束并且内核抢占您的线程。

使用临界区将比尝试滚动您自己的用户模式自旋锁更成功。

Answer 2

就您的实际问题而言，这很简单：只需将函数头更改为使用volatile DWORD *resourceLock，并将接触resourceLock 的装配线更改为使用间接：

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 语法）。即使在 Windows 上使用 gcc 开发，你也会好多；这将最大限度地减少迁移的痛苦（请参阅 mingw for gcc for Windows）。

• Greg Hewgill 关于无用旋转、阻止锁持有者获取 CPU 是绝对正确的。如果您旋转的时间过长，请考虑让出 CPU。

• 在多处理器 x86 上，您可能会遇到内存加载和存储围绕您的锁重新排序的问题 - 可能需要锁定和解锁过程中的 mfence 指令。

  李>

---

真的，如果您担心锁定，这意味着您正在使用线程，这可能意味着您已经在使用特定于平台的线程 API。因此，请使用本机同步原语，并在切换到 Linux 时切换到 pthreads 版本。

Answer 3

显然，您正在使用 C++ 代码中的内联汇编块使用 MSVC 进行编译。

一般来说，你应该真正使用compiler intrinsics，因为内联汇编没有未来：在为 x64 编译时，我的 MS 编译器不再支持它。

如果您需要在汇编中对函数进行微调，则必须在单独的文件中实现它们。

Answer 4

问题中原始版本的主要问题是它需要使用寄存器间接寻址并获取引用（或指针参数）而不是锁定DWORD的按值参数。

这是适用于 Visual C++ 的有效解决方案。 编辑： 我已与作者离线工作，我们已验证此答案中的代码在他的测试工具中正确工作。

但如果您使用的是 Windows，则应该使用 Interlocked API（即 InterlockedExchange）。

编辑：正如 CAF 所指出的，lock xchg 不是必需的，因为 xchg 会自动声明 BusLock。

我还添加了一个更快的版本，它在尝试执行 xchg 之前执行非锁定读取。这显着减少了内存接口上的 BusLock 争用。通过对长时间持有的锁进行退避（yield then sleep），算法可以加快很多（在有争议的多线程情况下）。对于单线程 CPU 的情况，使用在持有锁上立即休眠的 OS 锁将是最快的。

class LockImpl
{
    // This is a simple SpinLock
    //  0 - in use / busy
    //  1 - free / available
public:
    static void lockResource(volatile DWORD &resourceLock )
    {
        __asm 
        {
            mov     ebx, resourceLock
InUseLoop:
            mov     eax, 0           ;0=In Use
            xchg    eax, [ebx]
            cmp     eax, 0
            je      InUseLoop
        }

    }

    static void lockResource_FasterVersion(DWORD &resourceLock )
    {
        __asm 
        {
            mov     ebx, resourceLock
InUseLoop:
            mov     eax, [ebx]    ;// Read without BusLock 
            cmp     eax, 0
            je      InUseLoop     ;// Retry Read if Busy

            mov     eax, 0
            xchg    eax, [ebx]    ;// XCHG with BusLock
            cmp     eax, 0
            je      InUseLoop     ;// Retry if Busy
        }
    }

    static void unLockResource(volatile DWORD &resourceLock)
    {
        __asm 
        {
            mov     ebx, resourceLock
            mov     [ebx], 1 
        }       

    }
};

// A little testing code here
volatile DWORD aaa=1;
void test()
{
 LockImpl::lockResource(aaa);
 LockImpl::unLockResource(aaa);
}

Answer 5

你应该使用这样的东西：

volatile LONG resourceLock = 1;

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

见InterlockedCompareExchange。

Answer 6

查看您的编译器文档以了解如何为函数打印生成的汇编语言。

打印此函数的汇编语言：

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

这可能不起作用，因为编译器可以优化函数并删除所有代码。您应该更改上述函数以将指针传递给resourceLock，然后让该函数设置锁。打印这个工作函数的汇编。

Answer 7

我已经提供了一个工作版本，它回答了原始发布者关于如何获取 ASM 中传递的参数以及如何让他的锁正常工作的问题。

许多其他答案都质疑使用 ASM 是否明智，并提到应该使用内部函数或 C OS 调用。以下内容也适用，并且是我的 ASM 答案的 C++ 版本。那里有一个 ASM 的 sn-p，只有在您的平台不支持 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;
    }
};