c - 与单进程场景​​相比，多进程场景中的访问时间意外减少

Question

我正在从 program1 访问一个共享库(共享数组数据结构)并找到读取该数组所有元素的访问时间。我得到了大约 17000 个滴答声，而只有 Program1 单独执行。

现在，当我首先在另一个选项卡中执行 program2(具有空的 while 循环以防止它终止)时，然后运行 ​​program1 并测量访问时间以读取该数组的所有元素。令我惊讶的是，与之前仅执行 Program1 的场景相比，我现在得到了 8000 个滴答声。

看起来当只有程序 1 正在执行时，与有 2 个程序相比，读取数组需要更多时间，程序 1 正在执行与之前相同的任务，而程序 2 通过 while 循环使 CPU 保持忙碌。预期的是存在 program1 的访问时间更长，而实际结果恰恰相反。

为什么会这样？

这是共享库

#include <stdio.h> 
static const int DATA[1024]={1 ,2 ,3,.....1024];
inline void foo(void)
{
    int j, k=0,count=0;

    for(j=0;j<1024;j++)
      {
        k=DATA[j];
      }

    k+=0;    
}

程序 1

   int main(void)
    {    
    foo();

    start=timer();
    foo();
    end=timer();
    printf("Time1=%llu\n",end-start);    

    start=timer();
    foo();
    end=timer();
    printf("Time2=%llu\n",end-start);    


    start=timer();
    foo();
    end=timer();
    printf("Time3=%llu\n",end-start); 
    sleep(1);

    start=timer();
    foo();
    end=timer();
    printf("after sleep(1)\n");
    printf("Time4=%llu\n",end-start);    

    start=timer();
    foo();
    end=timer();
    printf("Time5=%llu\n",end-start);    

    sleep(2); 
    start=timer();
    foo();
    end=timer();
    printf("after sleep(2)\n");
    printf("Time6=%llu\n",end-start);    

    return 0;
    }

程序2

   int main(void)
    {
    while(1)
        {}        
    return 0;
    }

CASE1(只有 Program1 正在运行)

输出

Time1=17918
Time2=17672  
Time3=17816  

after sleep(1)
**Time4= 20716 ** // Is it due to wake up from sleep mode ?
Time5=17722

after sleep(2)
**Time6=20910** // Is it due to wake up from sleep mode ?

CASE1(程序2先运行，然后程序1开始运行)

输出

Time1 =7483  
Time2=7205
Time3=7399

after sleep(1)
**Time4= 8734 ** // Is it due to wake up from sleep mode ?
Time5=7326

after sleep(2)
**Time6=9070** // Is it due to wake up from sleep mode ?

根据我的理解，当 CPU 由程序 1 单独使用时，读取数组所需的时间必须少于 CPU 由程序 1 和程序 2 使用时。

我哪里出错了？我有 i7 机器，只有一个核心，超线程被禁用，ASLR 被禁用。

编辑 1:

根据 Mysticial 的建议，我的 CPU 在只有 program1 时进入省电模式，因此 CPU 进入省电模式然后从省电模式唤醒它需要更长的访问时间。所以他的建议是多次访问DATA数组。

这是我修改过的共享库。 Program1 和 Program2 保持不变。

#include <stdio.h> 
static const int DATA[1024]={1 ,2 ,3,.....1024];
inline void foo(void)
{
    int j, k=0,count=0;
  while(count++<10000)
  {  
    for(j=0;j<1024;j++)
      {
        k=DATA[j];
      }
   }  
    k+=0;    
}

现在输出如下

CASE1(只有 Program1 正在运行)

输出

Time1=75186246
Time2=77570299 
Time3=80548529 

after sleep(1)
**Time4= 92608363 ** // Is it due to wake up from sleep mode ?
Time5=75616487

after sleep(2)
**Time6=97021338** // Is it due to wake up from sleep mode ?

CASE1(程序2先运行，然后程序1开始运行)

输出

Time1 =139337099 
Time2=155801957
Time3=146586856

after sleep(1)
**Time4= 130558062 ** // Why lower access time after sleep mode ?
Time5=145250551 // Time5 is expected lower than Time4 as other run . Why lower here ?

after sleep(2)
**Time6=130940183** // Again Why lower access time after sleep mode ?

这是我关于修改共享库的新问题

1. 当没有程序 2 时，与之前的访问时间(t3/t5，休眠前)相比， sleep 后访问时间 (t4/t6) 更高。我可以说，这是由于 Mysticial 解释的将 CPU 从 sleep 中唤醒吗？

2. 现在，program2 在另一个选项卡中运行， sleep 后访问时间 (t4/t6) 与之前的访问时间(t3/t5，进入休眠前)相比更低。我的 q(1) 和 q(2) 矛盾的原因。从 sleep 中醒来后访问时间变短的原因是什么(t4 < t3)？虽然我在 sleep 后获得了更长的访问时间，但没有多次访问 DATA 数组(原始共享库)。

3. 为什么 t2<t1 and t3<t2并非总是如此，因为共享库已经加载到内存和缓存中。是因为 PAGE SWAPPING 吗？

我在 linux 下使用 gcc。任何有助于理解这一点的帮助将不胜感激。提前致谢。

Answer 1

这是我推测的答案，似乎已在评论中得到证实:

在最初的基准测试中，您只运行每个迭代的一个迭代。因此基准测试运行的时间不够长，无法“平均掉”所有随机性。

当你自己运行program1时，它需要将CPU从省电状态唤醒。这需要时间，并且可能导致运行时间更长。

当您同时运行两个程序时(首先从 program2 开始)，program2 会提前将 CPU 踢出省电状态。所以当你运行 program1 时，这个预热惩罚没有实现。

---

一旦您循环基准测试需要更长的时间，这种预热惩罚就变得微不足道，您最终会看到代码的预期稳态性能。 (程序 1 本身更快)