c - 限制c中函数的执行时间

Question

我想在不停止整个程序的情况下限制纯 C 中函数的执行。

我相信 stackoverflow.com 上与此最接近的是该线程的最后一条评论：如何限制 C/POSIX 中函数的执行时间？

有人说在函数之后使用 setjmp 和 longjm 来限制时间，但是线程死了。

有没有人知道这是否真的可能？

干杯

Answer 1

我可以看到两个选项，第一个是每隔几行代码检查一次时间，return如果它太多，但我认为这不是一个好主意。

其次，您可以使用线程。同时运行两个函数，一个计时另一个，如果时间太大则杀死第一个。现在我很确定 windows 和 Linux 有不同的库来创建线程，所以你可以尝试使用一个可以在所有平台上工作的库，比如http://openmp.org/wp/。

我一般不太熟悉该库和线程，但我希望它有所帮助

Answer 2

尽管发布我的解决方案可能会有所帮助。它是这篇文章http://cboard.cprogramming.com/c-programming/148363-limit-execution-time-function.html和此处找到的 IPC TPL 示例的组合：https ://github.com/troydhanson /tpl/blob/master/doc/examples.txt。

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <stdbool.h>
#include <string.h>
#include "tpl.h"

//This example contains two different parts:
        //1) The alarm is a execution timer for the function doWork
        //2) There is a need, that if the execution exits correctly, that the chid value of i, that we are modifying be passes

typedef struct TEST_STRUCT
{
        int i;
        double sum;
} testStruct;

int doWork(testStruct * ts)
{
        int y;
        for(y=0; y<3; y++)
        {
                sleep(1);
                printf("Working: %d\n", ts->i);
                ts->i++;
                ts->sum += (double)ts->i;
        }
        return 0;
}
int main()
{

        testStruct * ts = (testStruct *)(calloc(1, sizeof(testStruct)));
        ts->i = 7;
        ts->sum = 4.0;

        tpl_node *tn;
        int fd[2];
        pipe(fd);
        int y;
        for(y=0; y<10; y++)
        {
                pid_t childPID = fork();
                if (childPID==0)
                {
                        unsigned secsLeft;
                        alarm(10);
                        doWork(ts);

                        printf("\t->%d\n", ts->i);
                        printf("\t->%p\n", (void*) &ts->i);

                        tn = tpl_map("S(if)", ts);
                        tpl_pack( tn, 0 );
                        tpl_dump( tn, TPL_FD, fd[1]);
                        tpl_free( tn );

                        secsLeft = alarm(0);
                        exit(0);
                }
                else
                {
                        //IMPORTANT TO PUT IT HERE: In case the buffer is too big, TPL_DUMP will wait until it can send another and hang
                        tn = tpl_map( "S(if)", ts );
                        tpl_load( tn, TPL_FD, fd[0]);

                        int status;
                        wait(&status);

                        if(WIFSIGNALED(status))
                        {
                                // child was interrupted
                                if (WTERMSIG(status) == SIGALRM)
                                {
                                        printf("Interrupted\n");
                                        // child interrupted by alarm signal
                                }
                                else
                                {
                                        printf("Should not happend\n");
                                         // child interrupted by another signal
                                }
                        }
                        else
                        {
                                tpl_unpack(tn,0);
                                tpl_free( tn );

                                printf("\t->%d\n", ts->i);
                                printf("\t->%p\n", (void*) &ts->i);
                                printf("Success\n");
                        }
                }
        }
        return 0;
}

基本上，我们分叉程序，孩子执行任务，父母等待孩子完成。孩子包含一个警报，如果为真，则向父母发出信号，表明它以这种方式存在。如果完成（如本例所示），子进程将对象函数作为 TPL 缓冲区发送给父进程。