【问题标题】:C How can I avoid dereferencing the same variable multiple times?C 如何避免多次取消引用同一个变量?
【发布时间】:2011-10-21 17:47:24
【问题描述】:

我有一个结构数组,我有一些函数将使用这些结构的几个成员。我想避免在每一行中取消引用。我认为会有一些方法可以在某个内存位置声明一个变量......就像:

someStruct &myStruct = arrayOfStructs[i];
myStruct.x = foo+bar*myStruct.y*myStruct.w;
//Instead of myStruct->x = foo+bar*myStruct->y*myStruct->w;
//It would/should even be possible to access the members in a similar way:
int &x = &myStruct.x;
x = x+4*y+2*z;
//This should avoid overhead of dereferencing the pointer, and offsetting to the member
//by just accessing that particular address of memory as though it was where the variable
//had always been.

这段示例代码可能有助于解释:

#define NUM_BIGSTRUCTS 10000

typedef struct {
  int a,b,c;
  float d,e,f;
} bigStruct;

bigStruct* arrayOfStructs;

void foo() {
  for(int i=0; i<NUM_BIGSTRUCTS; i++) {
    bigStruct* temp = arrayOfStructs[i];
    temp->f = (temp->d+temp->e)*((float)temp->a+temp->e);
    //more similar, with conditionals, etc...
    //actually I've got nested loops, and a very very large array
    //so any gains per inner loop would decrease my number of instructions exponentially

    //So, if I could declare a bigStruct and set its address to the location of a bigStruct in the array
    //then I could avoid a dereference every time I access a member of that bigStruct
    //Leaving just the member access overhead... which could be handled in a similar manner
    //if possible, and when appropriate
  }
}

int main(int argx, char** argv) {
  arrayOfStructs = g_new0(bigStruct,NUM_BIGSTRUCTS); //Allocate and 0 memory for simplicity

  foo();

  return 0;
}

我从来没有在 SO 上取得过巨大的成功,所以希望我解释了我想要做的事情。我正在使用 C99 顺便说一句,考虑到 c 的低级性质,我相信这是可能的。

[编辑] 看起来我正在寻找来自 C++ 的“参考”,但对于 C。即便如此,它们只允许赋值一次(初始化),这在我的示例中不起作用。我决定依靠编译器来优化对同一段内存的多次访问。

谢谢, 詹姆斯纽曼

【问题讨论】:

  • @cnicular 我认为根本不需要任何开销。我查看了通过优化 GCC 和 Clang 等编译器生成的汇编代码,我从未想过“嘿,这个偏移量计算了两次,我可以在手写汇编中做得更好”。我对其他构造也有过这样的想法,我认为(我知道在实践中不会发生的潜在别名阻止了编译器进行优化)。
  • 为什么要取消引用?查看此 SO 帖子:stackoverflow.com/questions/1329096/…
  • 这是相对的。所涉及的算法是 O(N^2),集合涉及数十万个对象,几个复杂的方程涉及每个对象的几个成员。最重要的是,这是用于交互式模拟,所以我每秒至少执行 60 次,并增加了绘图和用户输入的额外开销。这是当前的瓶颈,并且将始终存在于此应用程序中。
  • @James Newman 阅读编译器生成的程序集。有一个最小的指令序列来做你想做的事情,你的编译器可能找到了它。使情况复杂化只会让你远离这个最佳状态。
  • @pascal-cuoq 我认为编译器可能会很好地优化这类事情,但我没有检查过。我会尽力做到这一点。

标签: c pointers c99 dereference


【解决方案1】:

您正在尝试编译器优化比您手动执行的效果要好得多的事情。此外,C99 没有您尝试在示例中定义它们的方式(特别是 C++ 取消引用声明)的这些引用结构,如果您也变得非常庞大和深入,我建议您重新考虑您的算法。如果你试图引入一些临时变量和更多的内存来做引用,你会让你的生活变得更艰难。

例如,如果您查看:

struct some_struct {
        int a;
        struct {
                float f;
                double d;
        } s;
};

struct some_struct array[10000];

int process1(struct some_struct *r) {
#define R (*r)
        R.a+= 1;
        R.s.f = R.s.f/2;
        R.s.d = ( R.s.d + R.s.f ) * 2;
}

int process2(struct some_struct *r) {
        r->a+= 1;
        r->s.f = r->s.f/2;
        r->s.d = ( r->s.d + r->s.f ) * 2;
}

int doit() {
        int i;
        for (i = 0; i < sizeof(array)/sizeof(struct some_struct); i++ ) {
                struct some_struct *r = &array[i]; /* via reference */
                process1(r);
                process2(r);
        }
}

process1 和 process2 在 x86_64 平台上使用 gcc -O2 生成相同的程序集输出:

        .file   "foo.c"
        .text
        .p2align 4,,15
        .globl  process1
        .type   process1, @function
process1:
.LFB11:
        .cfi_startproc
        movss   .LC0(%rip), %xmm0
        addl    $1, (%rdi)
        mulss   8(%rdi), %xmm0
        movss   %xmm0, 8(%rdi)
        unpcklps        %xmm0, %xmm0
        cvtps2pd        %xmm0, %xmm0
        addsd   16(%rdi), %xmm0
        addsd   %xmm0, %xmm0
        movsd   %xmm0, 16(%rdi)
        ret
        .cfi_endproc
.LFE11:
        .size   process1, .-process1
        .p2align 4,,15
        .globl  process2
        .type   process2, @function
process2:
.LFB12:
        .cfi_startproc
        movss   .LC0(%rip), %xmm0
        addl    $1, (%rdi)
        mulss   8(%rdi), %xmm0
        movss   %xmm0, 8(%rdi)
        unpcklps        %xmm0, %xmm0
        cvtps2pd        %xmm0, %xmm0
        addsd   16(%rdi), %xmm0
        addsd   %xmm0, %xmm0
        movsd   %xmm0, 16(%rdi)
        ret
        .cfi_endproc
.LFE12:
        .size   process2, .-process2
        .p2align 4,,15
        .globl  doit
        .type   doit, @function
doit:
.LFB13:
        .cfi_startproc
        xorl    %edx, %edx

        movss   .LC0(%rip), %xmm2
        .p2align 4,,10
        .p2align 3
.L4:
        leaq    (%rdx,%rdx,2), %rax
        addq    $1, %rdx
        leaq    array(,%rax,8), %rax
        movss   8(%rax), %xmm1
        addl    $2, (%rax)
        mulss   %xmm2, %xmm1
        cmpq    $10000, %rdx
        unpcklps        %xmm1, %xmm1
        cvtps2pd        %xmm1, %xmm0
        mulss   %xmm2, %xmm1
        addsd   16(%rax), %xmm0
        movss   %xmm1, 8(%rax)
        unpcklps        %xmm1, %xmm1
        cvtps2pd        %xmm1, %xmm1
        addsd   %xmm0, %xmm0
        addsd   %xmm1, %xmm0
        addsd   %xmm0, %xmm0
        movsd   %xmm0, 16(%rax)
        jne     .L4
        rep
        ret
        .cfi_endproc
.LFE13:
        .size   doit, .-doit
        .comm   array,240000,32
        .section        .rodata.cst4,"aM",@progbits,4
        .align 4
.LC0:
        .long   1056964608
        .ident  "GCC: (GNU) 4.6.1"
        .section        .note.GNU-stack,"",@progbits

【讨论】:

  • 好吧,我想我就别管它了。但是,您的示例似乎没有显示我正在尝试做的事情。你的过程 1 和 2 做同样的事情......我似乎在网上找到了像我在上面做的那样做的参考,但正如你所说的那样使用 C++。由于您提供了一些信息,因此我将保留更长的时间,然后投票给您的答案。作为一个说明,对于一个如此专注于提出特定问题的网站,我似乎从未得到具体的答案。我提出问题,以便了解我的所有选项,然后比较它们的表现......
  • 嗨,James,我不太确定您要做什么,我只是举了一个示例,使用相同的操作演示了引用代码与取消引用代码。编译器在计算结构引用和内存数学方面遇到了很多麻烦,并且在优化任何冗余方面做得很好。您可以做的最好的事情是对您的生产代码进行简单的实现,并使用 times 实用程序来确定它是如何执行的。如果你想弄清楚 GCC 如何优化特定代码段的单元测试,你可以使用 -S 标志来生成汇编程序。
  • 啊,但如果我只有一个选项可用,它生成的程序集并不重要。 ;) 不是 (*R).a 与 R->a 完全相同吗?
  • 呵呵 :-) 当然...我的意思是您可以尝试各种方法来处理数据并查看程序集输出以查看您更喜欢哪一种。
【解决方案2】:

但是..没有开销可谈!

您正在尝试做的实际上是增加开销。

我认为你需要了解你不应该针对一种语言工作,而应该使用它;否则,就好像您正试图用锤子将方形钉穿过圆孔。

【讨论】:

  • 好吧,我不知道在 c 中是否可行。据我所知,该语言有一个构建的结构,我不知道这个特定的操作。
【解决方案3】:

你的想法不会为你节省任何东西。指针让您可以使用非本地内存。根据定义,你的数组中的结构很远,你不能在很远的地方声明一个局部变量——那会是矛盾的。

当你说int &amp;x = &amp;myStruct.x; 时,你混淆了两个想法:

  • 局部变量:你可以很容易

        int x = temp->x
        //work with x...
        temp->x = x
    

    好处是,当您使用它时,您正在使用与您亲近的东西。 缺点是来回复制,但确实可能有问题。

  • 指针:另一种方式是

       int *x = &temp->x
       //work with x, like you would a pointer
    

    但是,这真的没有太大帮助,因为这与到处使用temp-&gt;x 没有太大区别。 (除非可能清楚)。考虑数组: 假设你有以下代码:

      int array[25];
      array[3] = array[2] + array[3];
      array[7] = array[3]*array[7] + array[3]<<7;
    

    你建议把它改成这样:

     int array[25]
     int *a = &array[3], *b=&array[2], *c=&array[7];
     *a = *b+*a;
     *c = (*a)*(*c) + *a<<7;
    

    它可能更具可读性,但生成的代码可能是相似的,重要的是,您使用遥远的内存完全相同的次数

【讨论】:

  • 取决于编译器优化...如果编译器按原样处理您的代码,那么在一个示例中会更多地对数组进行索引。
  • gcc -O0 on SPARC 在两个版本的阵列上显示 5 次加载和 2 次存储。
  • gcc -O2 仅显示 3 次加载,表明编译器已经擅长防止无关的取消引用。
  • 我怀疑 -O0 会阻止所有优化的发生。即在示例中使用常量进行索引。 叹息 你会认为我的问题是关于编译器优化有多好......我知道它们很好。从这个问题开始,我偷看了我的代码的反汇编。使用 O2,我有大量重复的负载->完全相同地址的偏移量。 -O3 很棒。地狱,即使是 sqrt 在 -O0 中也有函数开销,并且在 -O3 中被优化到只有一个 sqrtss。然而,这就是我的观点。我们完全依赖编译器优化。
  • -O0 -O3 我的项目中 simple 函数的 Asm 转储。
【解决方案4】:

我认为您正在寻找placement new 运算符,但那是C++,而不是C。

除此之外,我同意其他人的观点——别管它。

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2022-08-18
    • 2012-02-19
    • 2015-05-31
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多