c - 扩展装配中 cmpxchg16b 的不可能约束

Question

我正在尝试用我的C代码编写内联汇编来执行比较和交换操作。我的代码是:

typedef struct node {
    int data;
    struct node * next;
    struct node * backlink;
    int flag;
    int mark;
} node_lf;

typedef struct searchfrom {
    node_lf * current;
    node_lf * next;
} return_sf;

typedef struct csArg {
    node_lf * node;
    int mark;
    int flag;
} cs_arg;

typedef struct return_tryFlag {
    node_lf * node;
    int result;
} return_tf;

static inline node_lf cs(node_lf * address, cs_arg *old_val, cs_arg *new_val)
{
    node_lf value = *address;
    __asm__ __volatile__("lock; cmpxchg16b %0; setz %1;"
                         :"=m"(*(volatile node_lf *)address),
                          "=q"(value)
                         :"m"(*(volatile node_lf *)address),
                          "a"(old_val->mark), "d"(old_val->flag),
                          "b"(new_val->mark), "c"(new_val->flag)
                         :"memory");
    return value;
}

GCC 在编译代码时出现此错误:

linkedlist.c: In function 'cs': linkedlist.c:45:3: error: impossible constraint in 'asm' __asm__ __volatile__("lock; cmpxchg16b %0; setz %1;":"=m"(*(volatile node_lf

我的代码有什么问题吗？我该如何解决这个问题？

我正在尝试实现与此代码等效的内容:

node_lf cs (node_lf * address, cs_arg *old_val, cs_arg *new_val ) { 
    node_lf value = *address; 
    if (value.next == old_val->node && value.mark == old_val->mark && 
        value.flag == old_val->flag) { 
        address->next = new_val->node; 
        address->mark = new_val->mark; 
        address->flag = new_val->flag; 
    } 
    return value; 
}

Answer 1

那么，让我们来尝试一下。

开始之前的几点:

1. 使用内联汇编不是一个好主意。它很难编写、很难正确编写、很难维护、无法移植到其他编译器或平台等。除非这是一个赋值要求，否则不要这样做。
2. 执行 cmpxchg 操作时，要比较/交换的字段必须是连续的。所以如果你想对 next 进行操作, flag和mark在单个操作中，它们在结构中必须彼此相邻。
3. 执行 cmpxchg 操作时，字段必须在适当大小的边界上对齐。例如，如果您计划在 16 字节上进行操作，则数据必须在 16 字节边界上对齐。 gcc 提供了多种方法来做到这一点，从 aligned attribute ，到_mm_malloc。
4. 使用 __sync_bool_compare_and_swap(比内联汇编更好的选择)时，必须将数据类型转换为适当大小的整数。
5. 我假设您的平台是 x64。

2 和 3 需要对结构的场序进行一些更改。请注意，我没有尝试更改 searchfrom或return_tryFlag ，因为我不确定它们的用途。

因此，考虑到这些事情，这就是我的想法:

#include <stdio.h>
#include <memory.h>

typedef struct node {
    struct node * next;
    int mark;
    int flag;

    struct node * backlink;
    int data;
} node_lf;

typedef struct csArg {
    node_lf * node;
    int mark;
    int flag;
} cs_arg;

bool cs3(node_lf * address, cs_arg *old_val, cs_arg *new_val) { 

    return __sync_bool_compare_and_swap((unsigned __int128 *)address,
                                        *(unsigned __int128 *)old_val,
                                        *(unsigned __int128 *)new_val);
}

void ShowIt(void *v)
{
   unsigned long long *ull = (unsigned long long *)v;
   printf("%p:%p", *ull, *(ull + 1));
}

int main()
{
   cs_arg oldval, newval;
   node n;

   memset(&oldval, 0, sizeof(oldval));
   memset(&newval, 0, sizeof(newval));
   memset(&n, 0, sizeof(node));

   n.mark = 3;
   newval.mark = 4;

   bool b;

   do {
      printf("If "); ShowIt(&n); printf(" is "); ShowIt(&oldval); printf(" change to "); ShowIt(&newval);
      b = cs3(&n, &oldval, &newval);
      printf(". Result %d\n", b);

      if (b)
         break;
      memcpy(&oldval, &n, sizeof(cs_arg));
   } while (1);  
}

当你退出循环时，oldval 将是之前的内容(必须如此，否则 cas 会失败，我们将再次循环)，而 newval 将是实际写入的内容。请注意，如果这确实是多线程的，则不能保证 newval 与 n 的当前内容相同，因为另一个线程可能已经出现并再次更改了它。

对于输出，我们得到:

If 0000000000000000:0000000000000003 is 0000000000000000:0000000000000000 change to 0000000000000000:0000000000000000. Result 0
If 0000000000000000:0000000000000003 is 0000000000000000:0000000000000003 change to 0000000000000000:0000000000000000. Result 1

请注意，cas(正确!)在第一次尝试时失败，因为“旧”值与“当前”值不匹配。

虽然使用汇编程序可能可以为您节省一两条指令，但在可读性、可维护性、可移植性等方面的胜利几乎肯定是值得的。

如果由于某种原因您必须使用内联asm，您仍然需要重新排序您的结构，并且关于对齐的观点仍然有效。您还可以查看https://stackoverflow.com/a/37825052/2189500 。它只使用 8 个字节，但概念是相同的。