Question

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

现在，当我首先在另一个选项卡中执行program2（具有空的while循环以保持终止）时，然后运行program1并测量访问时间以读取该数组的所有元素。令我惊讶的是，与之前只有Program1执行的情况相比，我获得了8000ticks。

看起来只有program1执行时才需要花费更多时间来读取数组，而有2个程序时，program1正在执行与之前相同的任务，而program2通过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;    
}

PROGRAM1

   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 ?

根据我的理解，当program1单独使用CPU时，读取数组所需的时间必须少于Program1和program2使用CPU的时间。

我在哪里犯错误？我有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 ?

以下是有关修改后的共享库的新问题

当没有program2时，则睡眠访问时间（t4 / t6）与之前的访问时间（t3 / t5，进入睡眠状态）相比更高。我可以说，这是由于Mysticial所解释的从睡眠中唤醒CPU吗？
现在，如果program2在另一个标签中运行，则睡眠访问时间（t4 / t6）与之前的访问时间（t3 / t5，进入睡眠状态之前）相比更低。我q（1）和q（2）的原因是矛盾的。从睡眠中醒来后获得较低访问时间的原因是什么（t4
为什么t2<t1 and t3<t2不能保持为真，因为共享库已经加载到内存和缓存中。这是由于PAGE SWAPPING吗？

我在linux下使用gcc。任何帮助理解这一点将受到高度赞赏。提前谢谢。

Answer 1

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

在原始基准测试中，每个只运行一次迭代。因此，基准测试的运行时间不足以“平均”所有随机性。

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

当你同时运行两个程序时（首先从program2开始），program2会提前将CPU从节能状态中拉出来。因此，当你运行program1时，这个预热惩罚没有实现。

一旦循环基准测试需要更长的时间，这个预热惩罚变得无关紧要，你终于看到了代码的预期稳态性能。（program1本身更快）

与单个进程方案相比，多进程方案中的访问时间意外较低

1 个答案: