相关疑难解决方法(0)

如何组织结构中的成员以在对齐时浪费最少的空间?

[不是结构填充和包装的重复。这个问题是关于填充的方式和时间。这是关于如何处理它的信息。]

我刚刚意识到C ++中的对齐会浪费多少内存。考虑以下简单示例:

struct X
{
    int a;
    double b;
    int c;
};

int main()
{
    cout << "sizeof(int) = "                      << sizeof(int)                      << '\n';
    cout << "sizeof(double) = "                   << sizeof(double)                   << '\n';
    cout << "2 * sizeof(int) + sizeof(double) = " << 2 * sizeof(int) + sizeof(double) << '\n';
    cout << "but sizeof(X) = "                    << sizeof(X)                        << '\n';
}
Run Code Online (Sandbox Code Playgroud)

使用g ++时,程序将提供以下输出:

sizeof(int) = 4
sizeof(double) = 8
2 * sizeof(int) + sizeof(double) = 16
but …
Run Code Online (Sandbox Code Playgroud)

c++ optimization memory-alignment memory-layout struct-member-alignment

54
推荐指数
4
解决办法
3273
查看次数

L1缓存命中的周期/成本与x86上的Register相比?

我记得假设在我的架构类中L1缓存命中是1个周期(即与寄存器访问时间相同),但在现代x86处理器上实际上是这样吗?

L1缓存命中多少个周期?它与寄存器访问相比如何?

performance x86 cpu-architecture micro-optimization cpu-cache

27
推荐指数
2
解决办法
2万
查看次数

L2 TLB未命中后会发生什么?

我很难理解当翻译旁视缓冲区的前两个级别导致未命中时会发生什么?

我不确定特殊硬件电路中是否出现"页面行走",或者页表是否存储在L2/L3高速缓存中,或者它们是否只存在于主存储器中.

cpu performance x86 cpu-architecture tlb

19
推荐指数
1
解决办法
2135
查看次数

为什么CPU注册快速访问?

注册变量是一种众所周知的快速访问(register int i)方式.但为什么寄存器位于层次结构的顶层(寄存器,缓存,主存储器,辅助存储器)?访问寄存器如此之快的所有事情是什么?

cpu-architecture cpu-registers

17
推荐指数
2
解决办法
1万
查看次数

了解lfence对具有两个长依赖链的循环的影响,以增加长度

我正在玩这个答案的代码,稍微修改一下:

BITS 64

GLOBAL _start

SECTION .text

_start:
 mov ecx, 1000000

.loop:

 ;T is a symbol defined with the CLI (-DT=...)

 TIMES T imul eax, eax
 lfence
 TIMES T imul edx, edx


 dec ecx
jnz .loop

 mov eax, 60           ;sys_exit
 xor edi, edi
 syscall
Run Code Online (Sandbox Code Playgroud)

没有lfence我,我得到的结果与答案中的静态分析一致.

当我介绍一个单一 lfence我期望的CPU执行imul edx, edx的序列的第k个平行于迭代imul eax, eax的下一个(的序列K + 1个)迭代.
像这样的东西(调用一个的imul eax, eax序列和d的imul edx, edx一个): …

performance x86 assembly cpu-architecture perf

13
推荐指数
2
解决办法
472
查看次数

如何在一个8位字节中对四个2位位域求和?

我有四个2位位域存储在一个字节中.因此,每个位域可以表示0,1,2或3.例如,以下是前3个位域为零的4个可能值:

00 00 00 00 = 0 0 0 0
00 00 00 01 = 0 0 0 1
00 00 00 10 = 0 0 0 2
00 00 00 11 = 0 0 0 3
Run Code Online (Sandbox Code Playgroud)

我想要一种有效的方法来对四个位域进行求和.例如:

11 10 01 00 = 3 + 2 + 1 + 0 = 6
Run Code Online (Sandbox Code Playgroud)

现代Intel x64 CPU上的8位查找表需要4个周期才能从L1返回答案.似乎应该有一些方法来比这更快地计算答案.3个周期为6-12个简单位操作提供了空间.作为首发,简单的面具和换挡在Sandy Bridge上需要5个周期:

假设位字段是:d c b a,并且该掩码是:00 00 00 11

从艾拉帮助澄清:这假设a,b,c,和d是相同的,都被设置为初始byte.奇怪的是,我想我可以免费做到这一点.因为我每循环可以做2次加载,而不是加载byte一次,我可以加载它四次:a …

c optimization assembly bit-manipulation bit-fields

10
推荐指数
2
解决办法
2128
查看次数

x86 bsr/bsf如何具有固定的延迟,而不是数据依赖?它不像伪代码那样循环比特吗?

我正在试图分析一些x86二进制代码的"时序通道".我发布了一个问题来理解bsf/bsr操作码.

如此高级,这两个操作码可以被建模为"循环",它计算给定操作数的前导零和尾随零.该x86手册对这些操作码具有良好的形式化,如下所示:

IF SRC = 0
  THEN
    ZF ? 1;
    DEST is undefined;
  ELSE
    ZF ? 0;
    temp ? OperandSize – 1;
    WHILE Bit(SRC, temp) = 0
    DO
      temp ? temp - 1;
    OD;
    DEST ? temp;
FI;
Run Code Online (Sandbox Code Playgroud)

但令我惊讶的是,bsf/bsr指令似乎有固定的cpu周期.根据我在这里找到的一些文档:https://gmplib.org/~tege/x86-timing.pdf,似乎它们总是需要8个CPU周期来完成.

所以这是我的问题:

  1. 我确认这些指令有固定的cpu周期.换句话说,无论给出什么操作数,它们总是花费相同的时间来处理,并且没有"时序通道".我在英特尔的官方文档中找不到相应的规格.

  2. 那么为什么有可能呢?显然这是一个"循环"或某种程度,至少是高级别的.背后的设计决策是什么?CPU流水线更容易?

performance x86 assembly intel cpu-architecture

9
推荐指数
1
解决办法
412
查看次数

在 IvyBridge 上的指针追逐循环中,来自附近依赖商店的奇怪性能影响。添加额外的负载会加快速度吗?

首先,我在 IvyBridge 上进行了以下设置,我将在注释位置插入测量有效负载代码。前 8 个字节buf存储buf自身的地址,我用它来创建循环携带依赖:

section .bss
align   64
buf:    resb    64

section .text
global _start
_start:
    mov rcx,         1000000000
    mov qword [buf], buf
    mov rax,         buf
loop:
    ; I will insert payload here
    ; as is described below 

    dec rcx
    jne loop

    xor rdi,    rdi
    mov rax,    60
    syscall
Run Code Online (Sandbox Code Playgroud)

情况1:

我插入到有效载荷位置:

mov qword [rax+8],  8
mov rax,            [rax]
Run Code Online (Sandbox Code Playgroud)

perf显示循环为 5.4c/iter。有点理解,因为L1d延迟是4个周期。

案例2:

我颠倒了这两条指令的顺序:

mov rax,            [rax]
mov qword [rax+8],  8
Run Code Online (Sandbox Code Playgroud)

结果突然变成9c/iter。我不明白为什么。因为下一次迭代的第一条指令不依赖于当前迭代的第二条指令,所以这个设置应该和 case 1 没有区别。

我也用IACA工具对这两种情况进行静态分析,但是该工具不可靠,因为两种情况预测的结果都是5.71c/iter,与实验相矛盾。 …

x86 assembly micro-optimization microbenchmark micro-architecture

7
推荐指数
1
解决办法
393
查看次数

在64位指针中使用额外的16位

我读到64位机器实际上只使用48位地址(具体来说,我使用的是英特尔酷睿i7).

我希望额外的16位(位48-63)与地址无关,并将被忽略.但是当我尝试访问这样的地址时,我收到了一个信号EXC_BAD_ACCESS.

我的代码是:

int *p1 = &val;
int *p2 = (int *)((long)p1 | 1ll<<48);//set bit 48, which should be irrelevant
int v = *p2; //Here I receive a signal EXC_BAD_ACCESS.
Run Code Online (Sandbox Code Playgroud)

为什么会这样?有没有办法使用这16位?

这可用于构建更多缓存友好的链表.不是将8个字节用于下一个ptr,而是将8个字节用于密钥(由于对齐限制),可以将密钥嵌入到指针中.

64-bit pointers x86-64 memory-access

6
推荐指数
3
解决办法
4559
查看次数

复杂的寻址模式对于从内存加载是否有额外的开销?

这些加载指令之间的性能有差异吗mov?与简单的寻址模式相比,更复杂的寻址模式是否有额外的开销(延迟或吞吐量)?

# AT&T syntax                       # Intel syntax:
movq (%rsi), %rax                   mov  rax, [rsi]

movq (%rdi, %rsi), %rax             mov  rax, [rdi + rsi]

movq (%rdi, %rsi, 4), %rax          mov  rax, [rdi + rsi*4]
Run Code Online (Sandbox Code Playgroud)

performance x86 assembly micro-optimization

6
推荐指数
1
解决办法
1445
查看次数