永利平台娱乐处理器时间或频率,//计时需要用到

2020-01-05 19:23 来源:未知

/**************************************************
*    Functions developed by zhong yunde.           *
*   filename    : test_readfile.cpp                  *
*    creat time    : 2008/05/08                      *
*   功能:测试文件读取模式(用于程序优化)          *
**************************************************/

黑客编程教程(十三)多线程DOS程序

转自:

①本质区别
time(NULL)是指返回从1970年1.1日(元旦)午夜0点到现在的秒数 实际时间
clock clock是进程使用的cpu时间,作用不大。 处理器时间或频率,

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <time.h>

#include<winsock2.h>

转自

②返回值区别
time()得到的是秒做单位的
clock()得到的是毫秒做单位的, 因此通常 (double)clock()/CLOCKS_PER_SEC

#define XSIZE 2592
#define YSIZE 1944
#define IMGSIZE XSIZE*YSIZE
typedef struct RGB {
    unsigned char r;
    unsigned char g;
    unsigned char b;
} RGB;

#include<stdio.h>

 

time (null) 计算计算机的时间
clock 常粗略的计算任务的执行速度

struct RGB in[IMGSIZE];
unsigned char out[IMGSIZE];

#include <time.h>                           //计时需要用到的头文件

一)ANSI clock函数 

③宏解释

// 彩色图象转黑白图象
void calc_lum1(void)
{
    for(unsigned long i=0;i<IMGSIZE;i++)
    {
        double r,g,b,y;
        r=in[i].r; g=in[i].g; b=in[i].b;
        y=0.299*r+0.587*g+0.114*b;
        out[i]=(unsigned char)y;    
    }
}

#pragma comment(lib,"ws2_32.lib")

1)概述:
clock 函数的返回值类型是clock_t,它除以CLOCKS_PER_SEC来得出时间,一般用两次clock函数来计算进程自身运行的时间.

define CLK_TCK CLOCKS_PER_SEC

CLOCKS_PER_SEC,它用来表示一秒钟会有多少个时钟计时单元,其定义如下:

void calc_lum2(void)
{
    for(unsigned long i=0;i<IMGSIZE;i++)
    {
        double r,g,b,y;
        r=in[i].r; g=in[i].g; b=in[i].b;
        y=(long)(r*1224+g*2404+b*467)>>12;
        out[i]=(unsigned char)y;    
    }
}

 

ANSI clock有三个问题:
1)如果超过一个小时,将要导致溢出.
2)函数clock没有考虑CPU被子进程使用的情况.
3)也不能区分用户空间和内核空间.

define CLOCKS_PER_SEC ((clock_t)1000)

可以看到每过千分之一秒(1毫秒),调用clock()函数返回的值就加1。
可以使用公式clock()/CLOCKS_PER_SEC来计算一个进程自身的运行时间。例如:
void elapsed_time()
{
printf("Elapsed time:%u secs.n",clock()/CLOCKS_PER_SEC);
}

time()
主要用来获取当前的系统时间,返回的结果是一个time_t类型,其值表示从UTC(Coordinated Universal Time)时间1970年1月1日00:00:00(称为UNIX系统的Epoch时间)到当前时刻的秒数。然后调用localtime函数将 time_t所表示的UTC时间转换为本地时间(我们是+8区,比UTC多8个小时)并转成struct tm类型,该类型的各数据成员分别表示年月日时分秒。

④ 实用
clock()实用
测量程序的运行时间

// 查表数组
register unsigned char D[256],F[256],E[256];
void table_init()
{
    for(short i=0;i<256;i++)
    {
        D[i]=(i*1224)>>12;
        E[i]=(i*2404)>>12;
        F[i]=(i*467)>>12;  
    }
}
void calc_lum3(void)
{
    for(long i=0;i<IMGSIZE;i++)
    {
        unsigned char r,g,b;
        r=D[in[i].r];  g=E[in[i].g]; b=F[in[i].b];  //查表
        out[i] = r+g+b ;
    }
}

#include <time.h> //计时需要用到的头文件

所以clock函数在linux系统上变得没有意义.

include “stdio.h”

inline void calc_lum5(void)
{
    for(long i=0;i<IMGSIZE;i++)
    {
        unsigned char r,g,b;
        r=D[in[i].r];  g=E[in[i].g]; b=F[in[i].b];  //查表
        out[i] = r+g+b;    
    }
}

clock_t start,end; //程序运行的起始和结束时间

2)测试
编写test1.c程序,测试采用clock函数的输出与time程序的区别.

include “stdlib.h”

// 双核处理
void calc_lum4(void)
{
    for(long i=0;i<IMGSIZE;i += 2)
    {
        double r,g,b,y,  r1,g1,b1,y1;
        // ALU1
        r=D[in[i].r];  g=E[in[i].g]; b=F[in[i].b];  //查表
        y=(long)(r+g+b)>>12;
        out[i]=(unsigned char)y;
        // ALU2
        r1=D[in[i+1].r];  g1=E[in[i+1].g]; b1=F[in[i+1].b];  //查表
        y1=(long)(r1+g1+b1);
        out[i]=(unsigned char)y1;
    }
}

float costtime; //程序耗时

vi test1.c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

include “time.h”

int main(void)
{
long i = 10000000L;
clock_t start, finish;
double duration;
/* 测量一个事件持续的时间/
printf( "Time to do %ld empty loops is ", i );
start = clock();
while( i-- ) ;/
注意这行后面有个分号*/
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf( "%f secondsn", duration );
system("pause");
return 0;
}
这是一个求时间差的程序,那么为什么要除以CLOCKS_PER_SEC呢?  这是因为clock()是以毫秒为单位,要正确输出时间差需要把它换成秒,因此需要除以CLOCKS_PER_SEC。  clock()函数计算出来的是硬件滴答的数目,不是毫秒。在TC2.0中硬件每18.2个滴答是一秒,在VC++6.0中硬件每1000个滴答是一 秒。
上面我们看到时钟计时单元的长度为1毫秒,那么计时的精度也为1毫秒,那么我们可不可以通过改变CLOCKS_PER_SEC的定义,通过把它定义的大一些,从而使计时精度更高呢?通过尝试,你会发现这样是不行的。在标准C/C++中,最小的计时单位是一毫秒。
下面是一个更为简单的例子:

int main()
{

void usage(void)

int main( void )
{
   long i=1000L;
   clock_t start, finish;
   double  duration;
   printf( "Time to do %ld empty loops is ", i );
   start = clock();
   while (--i){
    system("cd");
   }
   finish = clock();
   duration = (double)(finish - start) / CLOCKS_PER_SEC;
   printf( "%f secondsn", duration );
   return 0;
}

include <stdio.h>

    char *filein = "Bretagneg.raw";
    char *fileout = "Black.raw";
    clock_t start_time,end_time;
    FILE *IN=NULL, *OUT=NULL;
    unsigned long i=0;

{

gcc test1.c -o test1

include <time.h>

int main()
{
int n = 10000000;
while(n--);
printf("%fn",clock()/(double)CLOCKS_PER_SEC);
return 0;
}
在VC++6.0中可以用CLK_TCK替换CLOCKS_PER_SEC。

time 实用
while(n>0)
{
long t = time(NULL)
t += 1;
while(t<time(NULL));
cout<<t/CLOCKS_PER_SEC<<endl;
n--;
}

    if ( NULL==(IN=fopen(filein, "rb"))) {
        fprintf(stderr, "Failed to open %s for reading !!n", filein);
        return -1;
    }
    
    if ( NULL==(OUT=fopen(fileout, "wb")) ) {
        fprintf(stderr, "Failed to open %s for reading !!n", fileout);
        return -1;
    }

printf("tusage: tcpscan RemoteIP StartPort-EndPortn");

time ./test1
Time to do 1000 empty loops is 0.180000 seconds

    // 方式一 : 整体读取 ,指针赋值
    fseek(IN,0,SEEK_SET);
    start_time=clock();
    unsigned char *image=(unsigned char *)malloc(sizeof(RGB)*IMGSIZE);
    fread(image,sizeof(RGB)*IMGSIZE,1,IN);
    for (i=0;i<IMGSIZE;i++)
    {
        in[i].r = *(image++);//image[3*i];
        in[i].g = *(image++);//image[3*i+1];
        in[i].b = *(image++);//image[3*i+2];
    }
    image -= sizeof(RGB)*IMGSIZE;
    free(image); image =NULL;
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)n",(float)(end_time-start_time)/CLOCKS_PER_SEC);

printf("tExample: tcpscan 192.168.1.1 80-100n");

real    0m3.492s
user    0m0.512s
sys     0m2.972s

    // 方式二 : 整体读取 ,数组赋值(竟然比上面指针方式好!)
    fseek(IN,0,SEEK_SET);
    start_time=clock();
    image=(unsigned char *)malloc(sizeof(RGB)*IMGSIZE);
    fread(image,sizeof(RGB)*IMGSIZE,1,IN);
    for (i=0;i<IMGSIZE;i++)
    {
        in[i].r = image[3*i];
        in[i].g = image[3*i+1];
        in[i].b = image[3*i+2];
    }
    free(image); image =NULL;
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)n",(float)(end_time-start_time)/CLOCKS_PER_SEC);
    
    // 方式三 : 一个个读取,效果最差
    fseek(IN,0,SEEK_SET);
    start_time=clock();
    for (i=0;i<IMGSIZE;i++)
    {
        in[i].r = fgetc(IN);
        in[i].g = fgetc(IN);
        in[i].b = fgetc(IN);
    }
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)nn",(float)(end_time-start_time)/CLOCKS_PER_SEC);
    
    // 方式一 :直接套用浮点公式
    start_time=clock();
    calc_lum1();
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)n",(float)(end_time-start_time)/CLOCKS_PER_SEC);
    
    // 方式二 :转化为定点公式
永利平台娱乐,    start_time=clock();
    calc_lum2();
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)n",(float)(end_time-start_time)/CLOCKS_PER_SEC);
    
    table_init(); // 初始化表格

}

3)总结:
(1)程序调用 system("cd");,这里主要是系统模式子进程的消耗,test1程序不能体现这一点.
(2)0.180000 seconds秒的消耗是两次clock()函数调用除以CLOCKS_PER_SEC.
(3)clock()函数返回值是一个相对时间,而不是绝对时间.
(4)CLOCKS_PER_SEC是系统定义的宏,由GNU标准库定义为1000000.

    start_time=clock();
    calc_lum3();
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)n",(float)(end_time-start_time)/CLOCKS_PER_SEC);
    
    start_time=clock();
    calc_lum5(); // 只有一个ALU 却使用双核模式则可能反而降速
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)n",(float)(end_time-start_time)/CLOCKS_PER_SEC);
    
    start_time=clock();
    calc_lum4(); // 只有一个ALU 却使用双核模式则可能反而降速
    end_time=clock();
    printf("the Time of Transform=%6.5f(sec)n",(float)(end_time-start_time)/CLOCKS_PER_SEC);
    
    
    fwrite(out, 1, IMGSIZE, OUT);
    printf("n completely n");

 

二)times()时间函数

    return 0;
}

int main(int argc,char **argv)

1)概述:

//! 结论 :了解机器结构,编写和硬件对应的程序
/************************************************************
* 1 :文件读取建议整体读取,即使这样需要额外数据重排操作,
*    但是内存处理相对硬盘文件读写速度很快
* 2 :并非所有浮点操作转成定点操作,速度就能提高,如上由于PC机
*    有存在硬件浮点处理器,因此浮点操作不一定比定点慢
*************************************************************/

{

原型如下:
clock_t times(struct tms *buf);

char *host;

tms结构体如下:
strace tms{
 clock_t tms_utime;
 clock_t tms_stime;
 clock_t tms_cutime;
 clock_t tms_cstime;
}

int startport,endport;

注释:
tms_utime记录的是进程执行用户代码的时间.
tms_stime记录的是进程执行内核代码的时间.
tms_cutime记录的是子进程执行用户代码的时间.
tms_cstime记录的是子进程执行内核代码的时间.

    char *p;

2)测试:

if(argc!=3)

vi test2.c
#include <sys/times.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

TAG标签:
版权声明:本文由永利平台娱乐发布于永利平台娱乐,转载请注明出处:永利平台娱乐处理器时间或频率,//计时需要用到