times（）返回的struct tms值均为零或负

我试图在C编程中实现times（）函数

我使用的是

struct tms

结构，它由以下字段组成：tms_utime，tms_cutime， tms_时间和tms_时间

为了在我的程序中实现times（）函数，我执行以下操作：

在分叉并创建子进程之前，我调用times函数（在父进程中）

我创建一个管道，当我在子流程中时，我将开始结构的时间传递给管道

子级执行一个简单的

ls-l

命令

当孩子完成执行时，父亲第二次调用times（）函数

times(&end_tms);

不幸的是，结束时间都是零！奇怪，但我不知道为什么

在我的课程中，我不了解的一些事情有：

1） 在第一个

printfs

中，结构启动的时间为负数。为什么呢？ 2） 当我运行程序时，为什么每次都得到零？我做错了什么

我的计划如下：

提前谢谢

---

#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（）{
printf（“测试”）；
int fd[2]；//两个指针
整数字节；
字符字符串[]=“你好，世界！\n”；
字符读取缓冲区[80]；
结构tms启动\u tms；
结构tms end_tms；
时钟开始、结束；
使用双cpu时间；
管道（fd）；
//一旦我们建立了管道，我们就把孩子交给他们
pid_t childpid；
pid_t pid_waitpid；
//新修改！！！fork（）之前的调用次数！！！
时间（和启动时间）；
//它们返回负值，但为什么？？？
printf（“测试启动\u tms.tms\u utime=%f\n\n”，启动\u tms.tms\u utime）；
printf（“测试启动\u tms.tms\u执行时间=%f\n\n”，启动\u tms.tms\u执行时间）；
printf（“测试开始\u tms.tms\u时间=%f\n\n”，开始\u tms.tms\u时间）；
if（（childpid=fork（））=-1）
{
佩罗尔（“福克”）；
出口（1）；
}
if（childpid==0）
{
/*子进程关闭管道的输入端*/
关闭（fd[0]）；
/*调用时间函数*/
/*时间（和启动时间）*/
//删除！！！！
//写入（fd[1]，string，（strlen（string）+1））；
写入（fd[1]，&start_tms.tms_cutime，sizeof（clock_t））；
写入（fd[1]，&start_tms.tms_utime，sizeof（clock_t））；
写入（fd[1]，&start_tms.tms_stime，sizeof（clock_t））；
//执行/bin/ls
execl（“/bin/ls”、“/bin/ls”、“-r”、“-t”、“-l”、（char*）0）；
出口（0）；
}
其他的
{
/*父进程关闭管道的输出端*/
关闭（fd[1]）；
/*新修改，等待孩子*/
if（（pid_waitpid=waitpid（childpid，NULL，0））=-1）
{
佩罗（“waitpid”）；
出口（1）；
}
/*捕获结束时间的调用时间*/
时间（和结束时间）；
/*定义t1、t2和变量*/
时钟t1、t2、t3；
//删除！！！！
//nbytes=读取（fd[0]，读取缓冲区，sizeof（读取缓冲区））；
读取（fd[0]，&t1，sizeof（clock_t））；
读取（fd[0]，&t2，大小（时钟时间））；
读取（fd[0]，&t3，大小（时钟））；
printf（“收到的字符串：%s\n\n”，readbuffer）；
printf（“测试t1=%f\n\n”，t1）；
printf（“测试结束\u tms.tms\u utime=%f\n\n”，结束\u tms.tms\u utime）；
printf（“测试结束\u tms.tms\u执行时间=%f\n\n”，结束\u tms.tms\u执行时间）；
printf（“测试结束\u tms.tms\u时间=%f\n\n”，结束\u tms.tms\u时间）；
/*计算时间，不幸返回零，但为什么*/
双cpu_time=end_tms.tms_cutime-t1；
double utime=end_tms.tms_utime-t2；
双时间=结束时间\tms.tms\u时间-t3；
//不幸的是printfs返回零，但为什么？？？
printf（“cpu时间%f\n\n”，cpu\u时间）；
printf（“cpu Utime%f\n\n”，Utime）；
printf（“cpu时间%f\n\n”，时间）；
}
}

你的逻辑很奇怪。您在子系统中执行的写入操作只是复制父系统在

start\u tms

中已经可用的数据，因此不需要整个管道的读/写操作

其次，

clock\u t

不是浮点类型，而是整数类型。您不能使用

%f

打印它。使用

%jd

和

intmax\u t

在

printf

s中保持安全

您缺少waitpid的

#include

。因此，打开编译器警告，并阅读它们

这里有一个C99版本的代码在这里工作：

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <inttypes.h>
#include <sys/wait.h>
#include <sys/times.h>
#include <sys/types.h>

int main() {
    struct tms start_tms;
    struct tms end_tms;

    //once we have established the pipeline we fork the child
    pid_t   childpid;

    times(&start_tms);

    printf("Test start_tms.tms_utime = %jd\n\n",  (intmax_t)start_tms.tms_utime);
    printf("Test start_tms.tms_cutime = %jd\n\n", (intmax_t)start_tms.tms_cutime);
    printf("Test start_tms.tms_stime = %jd\n\n",  (intmax_t)start_tms.tms_stime);
    printf("Test start_tms.tms_cstime = %jd\n\n",  (intmax_t)start_tms.tms_cstime);


    if((childpid = fork()) == -1)
    {
        perror("fork");
        exit(1);
    }

    if(childpid == 0)
    {
        //execute /bin/ls
        execl("/bin/ls", "/bin/ls", "-R", "-t", "-l", (char *) 0);
        exit(0);
    }
    else
    {
        /* Parent process */

        /* NEW MODIFICATION, wait for the child!!! */
        if (waitpid(childpid,NULL,0) == -1)
        {
            perror("waitpid");
            exit(1);
        }

        /* call times for capturing end times */
        times(&end_tms);

        printf("Test end_tms.tms_utime = %jd\n\n",end_tms.tms_utime);
        printf("Test end_tms.tms_cutime = %jd\n\n",end_tms.tms_cutime);
        printf("Test end_tms.tms_stime = %jd\n\n",end_tms.tms_stime);
        printf("Test end_tms.tms_cstime = %jd\n\n",end_tms.tms_cstime);

        /* Calculate times, unfortunately return zero, but why??? */
        clock_t cpu_time = end_tms.tms_cutime - start_tms.tms_cutime;
        clock_t utime = end_tms.tms_utime - start_tms.tms_utime;
        clock_t stime = end_tms.tms_stime - start_tms.tms_stime;
        clock_t cstime = end_tms.tms_cstime - start_tms.tms_cstime;

        //Unfortunately printfs return zero, but why???
        printf("cpu time %jd\n\n",  (intmax_t)cpu_time);
        printf("cpu Utime %jd\n\n", (intmax_t)utime);
        printf("cpu Stime %jd\n\n", (intmax_t)stime);
        printf("cpu CStime %jd\n\n", (intmax_t)cstime);
    }
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（）{
结构tms启动\u tms；
结构tms end_tms；
//一旦我们建立了管道，我们就把孩子交给他们
pid_t childpid；
时间（和启动时间）；
printf（“测试启动\u tms.tms\u utime=%jd\n\n”，（intmax\u t）启动\u tms.tms\u utime）；
printf（“Test start_tms.tms_cutime=%jd\n\n”，（intmax_t）start_tms.tms_cutime）；
printf（“测试启动\u tms.tms\u时间=%jd\n\n”，（intmax\u t）启动\u tms.tms\u时间）；
printf（“测试启动\u tms.tms\u cstime=%jd\n\n”，（intmax\u t）启动\u tms.tms\u cstime）；
if（（childpid=fork（））=-1）
{
佩罗尔（“福克”）；
出口（1）；
}
if（childpid==0）
{
//执行/bin/ls
execl（“/bin/ls”、“/bin/ls”、“-R”、“-t”、“-l”、（char*）0）；
出口（0）；
}
其他的
{
/*父进程*/
/*新修改，等待孩子*/
if（waitpid（childpid，NULL，0）=-1）
{
佩罗（“waitpid”）；
出口（1）；
#include <sys/times.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main() {

printf("test\n");

int     fd[2]; //two pointers
int nbytes;
char    string[] = "Hello, world!\n";
char    readbuffer[80];
struct tms start_tms;
struct tms end_tms;
clock_t start, end;
double cpu_time_used;

pipe(fd);

//once we have established the pipeline we fork the child
pid_t   childpid;
pid_t pid_waitpid;

//NEW MODIFICATION!!! call times before fork()!!!
times(&start_tms);

//they return negative values, but why???
printf("Test start_tms.tms_utime = %f\n\n",start_tms.tms_utime);
printf("Test start_tms.tms_cutime = %f\n\n",start_tms.tms_cutime);
printf("Test start_tms.tms_stime = %f\n\n",start_tms.tms_stime);


if((childpid = fork()) == -1)
            {
                    perror("fork");
                    exit(1);
            }

if(childpid == 0)
            {

                    /* Child process closes up input side of pipe */
                     close(fd[0]);

                   /* call times function */ 
                   /*times(&start_tms);*/


                      //REMOVED!!!!
                    //write(fd[1], string, (strlen(string)+1));
                    write(fd[1], &start_tms.tms_cutime, sizeof(clock_t));
                    write(fd[1], &start_tms.tms_utime, sizeof(clock_t));
                    write(fd[1], &start_tms.tms_stime, sizeof(clock_t));

                     //execute /bin/ls
                    execl("/bin/ls", "/bin/ls", "-r", "-t", "-l", (char *) 0);

                    exit(0);


            }
else
            {
                    /* Parent process closes up output side of pipe */
                    close(fd[1]);

                    /* NEW MODIFICATION, wait for the child!!! */
                     if( (pid_waitpid  = waitpid(childpid,NULL,0) ) == -1)
                    {
                             perror("waitpid");
                             exit(1);
                     }



                    /* call times for capturing end times */
                    times(&end_tms);

                    /* define t1, t2, variables */
                    clock_t t1,t2,t3;


                     //REMOVED!!!!
                    //nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
                    read(fd[0], &t1, sizeof(clock_t));
                    read(fd[0], &t2, sizeof(clock_t));
                    read(fd[0], &t3, sizeof(clock_t));

                    printf("Received string: %s\n\n", readbuffer);
                    printf("Test t1 = %f\n\n",t1);
                    printf("Test end_tms.tms_utime = %f\n\n",end_tms.tms_utime);
                    printf("Test end_tms.tms_cutime = %f\n\n",end_tms.tms_cutime);
                    printf("Test end_tms.tms_stime = %f\n\n",end_tms.tms_stime);

                    /* Calculate times, unfortunately return zero, but why??? */
                    double cpu_time = end_tms.tms_cutime - t1;
                    double utime = end_tms.tms_utime - t2;
                    double stime = end_tms.tms_stime - t3;

                    //Unfortunately printfs return zero, but why???
                    printf("cpu time %f\n\n",cpu_time);
                    printf("cpu Utime %f\n\n",utime);
                    printf("cpu Stime %f\n\n",stime);


}

}

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <inttypes.h>
#include <sys/wait.h>
#include <sys/times.h>
#include <sys/types.h>

int main() {
    struct tms start_tms;
    struct tms end_tms;

    //once we have established the pipeline we fork the child
    pid_t   childpid;

    times(&start_tms);

    printf("Test start_tms.tms_utime = %jd\n\n",  (intmax_t)start_tms.tms_utime);
    printf("Test start_tms.tms_cutime = %jd\n\n", (intmax_t)start_tms.tms_cutime);
    printf("Test start_tms.tms_stime = %jd\n\n",  (intmax_t)start_tms.tms_stime);
    printf("Test start_tms.tms_cstime = %jd\n\n",  (intmax_t)start_tms.tms_cstime);


    if((childpid = fork()) == -1)
    {
        perror("fork");
        exit(1);
    }

    if(childpid == 0)
    {
        //execute /bin/ls
        execl("/bin/ls", "/bin/ls", "-R", "-t", "-l", (char *) 0);
        exit(0);
    }
    else
    {
        /* Parent process */

        /* NEW MODIFICATION, wait for the child!!! */
        if (waitpid(childpid,NULL,0) == -1)
        {
            perror("waitpid");
            exit(1);
        }

        /* call times for capturing end times */
        times(&end_tms);

        printf("Test end_tms.tms_utime = %jd\n\n",end_tms.tms_utime);
        printf("Test end_tms.tms_cutime = %jd\n\n",end_tms.tms_cutime);
        printf("Test end_tms.tms_stime = %jd\n\n",end_tms.tms_stime);
        printf("Test end_tms.tms_cstime = %jd\n\n",end_tms.tms_cstime);

        /* Calculate times, unfortunately return zero, but why??? */
        clock_t cpu_time = end_tms.tms_cutime - start_tms.tms_cutime;
        clock_t utime = end_tms.tms_utime - start_tms.tms_utime;
        clock_t stime = end_tms.tms_stime - start_tms.tms_stime;
        clock_t cstime = end_tms.tms_cstime - start_tms.tms_cstime;

        //Unfortunately printfs return zero, but why???
        printf("cpu time %jd\n\n",  (intmax_t)cpu_time);
        printf("cpu Utime %jd\n\n", (intmax_t)utime);
        printf("cpu Stime %jd\n\n", (intmax_t)stime);
        printf("cpu CStime %jd\n\n", (intmax_t)cstime);
    }
}