【编程珠玑（续）】第一章 性能监视工具

一，计算素数

第一个程序：如果整数n，从2开始到n-1都不能整除则为素数。注意，n=2时一定是素数的判断

#include <iostream>
using namespace std;
int prime(int n)
{   
        int i;
        for (i = 2; i < n; i++)
                if(n%i == 0)
                        return 0;
        return 1;
}
int main()
{
    int i,n;
    n=1000;
    for(i = 2; i <= n; i++)
      if (prime(i))
          cout<<i<<" ";
}

第二个程序：只需要从2到sqrt(n)不能整除就可以

#include <iostream>
#include <cmath>
using namespace std;

int root(int n)  
{ 
    return (int) sqrt((float) n);  
} 
int prime(int n)
{   
        int i;
        for (i = 2; i < root(n); i++)  //每次循环都要调用 root（）函数，可以申请一个变量，band = root(n)放到前面
                if(n%i == 0)
                        return 0;
        return 1;
}
int main()
{
    int i,n;
    n=1000;
    for(i = 2; i <= n; i++)
      if (prime(i))
          cout<<i<<" ";
} 

第三个程序：通过对被2、3和5整除的特殊检验，避免了近3/4的开方运算。语句计数表明，被2整除的性质大约把一半的输入归入合数，被3整除把剩余输入的1/3归入合数，被5整除再把剩下的这些数的1/5归入合数。其次，只考虑奇数作为可能的因子，在剩余的数中避免了大约一半的整除检验。它比程序P3大约快两倍，但是也比P3的错误更多。

#include <iostream>
#include <cmath>
using namespace std;

int root(int n)  
{ 
    return (int) sqrt((float) n);  
} 
int prime(int n)
{
        int i, bound;
        if (n % 2 == 0)
               return 0;
        if (n % 3 == 0)
               return 0;
        if (n % 5 == 0)
               return 0;
        bound = root(n);
        for (i = 7; i <= bound; i = i+2)
              if (n % i == 0)
                    return 0;
          return 1;
}
int main()
{
    int i,n;
    n=1000;
    for(i = 2; i <= n; i++)
      if (prime(i))
          cout<<i<<" ";
} 

以上程序，没有将素数：2，3，5检查出来

改进后程序如下：

#include <iostream>
#include <cmath>
using namespace std;

int root(int n)  
{ 
    return (int) sqrt((float) n);  
} 
int prime(int n)
{
        int i, bound;
        if (n % 2 == 0)
               return (n==2); //如果是2则返回 1 否则返回 0
        if (n % 3 == 0)
               return (n==3);
        if (n % 5 == 0)
               return (n==5);
        bound = root(n);
        for (i = 7; i <= bound; i = i+2)
              if (n % i == 0)
                    return 0;
          return 1;
}
int main()
{
    int i,n;
    n=1000;
    for(i = 2; i <= n; i++)
      if (prime(i))
          cout<<i<<" ";
} 

第四个程序：将费时的开方运算替换为 乘法，将第三个程序稍加调整

关键代码：

#include <iostream>
using namespace std;
 
int prime(int n)
{
        int i, bound;
        if (n % 2 == 0)
               return (n==2);
        if (n % 3 == 0)
               return (n==3);
        if (n % 5 == 0)
               return (n==5);

        for (i = 7; i*i <= n; i = i+2)
              if (n % i == 0)
                    return 0;
          return 1;
}
int main()
{
    int i,n;
    n=1000;
    for(i = 2; i <= n; i++)
      if (prime(i))
          cout<<i<<" ";
}

二，性能检测工具

在linux系统下：

find . -name "*.c" |xargs wc -l
time — 执行命令并计时

time find . -name "*.c" |xargs wc -l // 统计执行命令时间

real 0m33.748s
user 0m0.772s
sys 0m1.044s

1）实际时间(real time): 从command命令行开始执行到运行终止的消逝时间；

2）用户CPU时间(user CPU time): 命令执行完成花费的用户CPU时间，即命令在用户态中执行时间总和；

3）系统CPU时间(system CPU time): 命令执行完成花费的系统CPU时间，即命令在核心态中执行时间总和。

其中，用户CPU时间和系统CPU时间之和为CPU时间，即命令占用CPU执行的时间总和。实际时间要大于CPU时间，因为Linux是多任务操作系统，往往在执行一条命令时，系统还要处理其它任务。

另一个需要注意的问题是即使每次执行相同命令，但所花费的时间也是不一样，其花费时间是与系统运行相关的。

代码的性能检测，统计每个函数调用次数。额可以检测哪个函数占用大量CPU时间，从而有效更改程序。

三，习题

2）实现简单的埃氏筛法（Sieve of Eratosthenes）来计算所有小于n的素数。这个程序的主要数据结构是一个n比特的数组，初始值都为真。每发现一个素数时，数组中所有这个素数的倍数就设置为假。下一个素数就是数组中下一个为真的比特。

答案：下面的C程序实现了埃氏筛法来计算所有小于n的素数。其基本数据结构是n比特数组x，初始值全部为1。每发现一个素数，数组中所有它的倍数都设为0。下一个素数就是数组中的下一个取值为1的比特位。性能监视表明小于100000的素数有9592个，算法进行了大概2.57N次赋值。一般地，算法进行NloglogN次赋值；算法分析中涉及到答案1.1中的素数密度和调和数。下面是加上性能监视后的代码：

#include <iostream>
using namespace std;
 
int main()  
{    
    int i, p, n;  
    char x[100002];  
    n = 100000;  
    for (i = 1; i <= n; i++)  
             x[i] = 1;  
     x[1] = 0;  //1不是素数
     x[n+1] = 1;  
     p = 2;  
     while (p <= n) 
     {  
            cout<<p<<" "; 
            for (i = 2*p; i <= n; i = i+p)  
                  x[i] = 0;  
            do  
                 p++;  
             while (x[p] == 0);  //得到第一个标记为1的数，为素数
      }  
} 

3） 一个简单的用于语句计数的性能监视工具每执行一个语句就增加一次计数。满足于更少的计数器可以同时减少监视程序的内存需求和运行时间。例如，可以给程序流图中的每个基本块关联一个计数器。也可以利用"基尔霍夫第一定律"进一步减少计数器的数量：如果你有一个if-then-else语句的计数器以及一个then分支语句的计数器，那么就不需要else分支语句的计数器了。