评测机
思路
通过父进程启动一个子进程，子进程运行用户提交的代码。通过父进程监控子进程使用的内存，时间等计算机资源，最后对子进程生成的答案与正确答案进行比对。
第一步：生成一个进程
用户提交的代码可能会编译不通过，这时需要将编译报错信息返回给用户。我在编译的makefile命令后加这一句make >err.txt 2>&1将编译报错的信息输出到一个文件内
函数fork
一个现有的进程可以调用fork函数创建一个新进程。
#include<unistd.h>
pid_t fork(void);
子进程和父进程继续执行fork调用之后的指令。子进程是父进程的副本。子进程获得父进程数据空间、堆、栈的副本，父子进程并不共享。父子进程共享正文段。
例子：
#include <iostream>
#include <unistd.h>
#include <sys/types.h> // 提供类型 pid_t 的定义
#include <sys/wait.h>
#include <sys/resource.h>
int main()
{
pid_t pid = fork();
if(pid < 0) {
std::cout << "error" << std::endl;
exit(0);
} else if(pid == 0) {
std::cout << "in child: now id = " << getpid() << std::endl; //子进程id
std::cout << "in child: father id = " << getppid() << std::endl; //父进程id
} else if(pid > 0) {
std::cout << "in father: child id = " << pid << std::endl; //子进程id
std::cout << "in father: now id = " << getpid() << std::endl; //父进程id
}
return 0;
}
第二歩：执行用户的代码
当我们调用fork函数后，生成的子进程执行的代码与父进程一样这不是我们想要的。
这时我们可以调用exec函数，该进程执行的程序完全替换为新程序，而新程序从其main函数开始执行。替换了当前进程的正文段、数据段、堆段和栈段。
| exec |
|---|
int execl(const char *pathname,const char *agr0,.../*(char*)0*/); |
int execv(const char *pathname,char *cosnt agrv[] |
int execle(const char *pathname,const char *agr0,.../*(char*)0,char *const envp[]*/); |
int execve(const char *pathname,char *const agrv[],char *const envp[]) |
int execlp(const char *filename,const char *arg0,.../*(char*)0*/); |
int execvp(const char *filename,char* const agrv[] |
int fexecve(int fd,char *const agrv[],char *const envp[] |
详见《UNIX环境高级编程》第八章第十节
#include <bits/stdc++.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/resource.h>
//bash为相对路径
void start_bash(std::string bash) {
char *c_bash = new char[bash.length() + 1];
strcpy(c_bash, bash.c_str());
char* const child_args[] = { c_bash, NULL };
execv(child_args[0], child_args); //调用exec
delete []c_bash;
}
int main()
{
pid_t pid = fork();
if(pid < 0) {
std::cout << "error" << std::endl;
exit(0);
} else if(pid == 0) {
std::cout << "in child" << getppid() << std::endl;
start_bash(std::string("test2"));
} else if(pid > 0) {
std::cout << "in father" << getpid() << std::endl;
}
return 0;
}
第三步：限制子进程的资源使用
获得子进程运行时间
获取当前系统时间：std::chrono::system_clock::now();
返回的类型std::chrono::system_clock::time_point
得到运行时间的代码
using namespace std::chrono;
system_clock::time_point begin_time,end_time;
begin_time = system_clock::now(); //获取运行前时间
std::cout << "start"<<std::endl;
for (int i=0; i<100000000; ++i)
int num =i;
std::cout << "end"<<std::endl;
end_time = system_clock::now(); //获取运行后时间
duration<double> time_span = duration_cast<duration<double>>(end_time - begin_time);
std::cout << "run time = " << time_span.count() << " seconds."<< std::endl;
用户所提交的代码有可能会需要非常长的时间甚至根本就是死循环。当用户的程序超出所规定时间的时候应该主动关闭进程。
下面介绍两个函数getrlimit/setrlimit
#include<sys/resource.h>
int getrlimit(int resource,struct rlimit *rlptr)
int setrlimit(int resource,const struct rlimit *rlptr)
struct rlimit{
rlim_t rlim_cur; //软限值
rlim_t rlim_max; //硬限值
}
在更改资源限制时，须遵循下列 3 条规则。
（1）任何一个进程都可将一个软限制值更改为小于或等于其硬限制值。
（2）任何一个进程都可降低其硬限制值，但必须不小于其软限制值。这种降低对普通用户而言是不可逆的。
（3）只有超级用户进程可以提高硬限制值。
详见《UNIX环境高级编程》第七章第十一节
在子进程中加入以下测试的代码：
rlimit limit;
limit.rlim_cur = limit.rlim_max = 1; //设置资源限制参数
setrlimit(RLIMIT_CPU , &limit); //设置资源限制
int i = 0;
while(1) {
i++;
}
可以观察到程序在运行大约1s后被终止，但是父进程如何知道？
当一个进程正常或异常终止时，内核就向其父进程发送SIGCHLD信号。父进程可以选择忽略它，或者调用信号处理函数处理。
pid_t wait3(int *status,int options,struct rusage *rusage);
pid_t wait4(pid_t pid,int *status,int options,struct rusage *rusage);
wait3() 和 wait4() 函数除了可以获得子进程状态信息外，还可以获得子进程的资源使用信息，这些信息是通过参数 rusage 得到的。而 wait3() 与 wait4() 之间的区别是，wait3() 等待所有进程，而 wait4() 可以根据 pid 的值选择要等待的子进程，参数 pid 的意义与 waitpid() 函数的一样。
struct rusage的定义
struct rusage {
struct timeval ru_utime; // user time used
struct timeval ru_stime; // system time used
long ru_maxrss; // maximum resident set size
long ru_ixrss; // integral shared memory size
long ru_idrss; // integral unshared data size
long ru_isrss; // integral unshared stack size
long ru_minflt; // page reclaims
long ru_majflt; // page faults
long ru_nswap;// swaps
long ru_inblock; // block input operations
long ru_oublock; // block output operations
long ru_msgsnd; // messages sent
long ru_msgrcv; //messages received
long ru_nsignals; // signals received
long ru_nvcsw; // voluntary context switches
long ru_nivcsw; // involuntary context switches
};
通过wait4()得到结构体rusage可以获得子进程运行的信息
获得子进程运行时间
auto use_time = use.ru_utime.tv_sec*1000+use.ru_utime.tv_usec/1000 + use.ru_stime.tv_sec*1000+use.ru_stime.tv_usec/1000;
获得进程最大使用内存
liunx关于文件描述的文件存在 /proc/进程号/status 的文件内，通过不停读取文件内VmPeak: 内存使用量 的信息可以得到该进程的实时内存使用量，此外依旧通过setrlimit()来限制内存使用量。
static long get_proc_mem(unsigned int pid){
char file_name[64]={0};
FILE *fd;
char line_buff[512]={0};
sprintf(file_name,"/proc/%d/status",pid);
//std::cout<<file_name<<std::endl;
fd =fopen(file_name,"r");
if(nullptr == fd){
return 0;
}
char name[64];
long long vmrss = 0;
for (int i=0; i<17-1;i++){
fgets(line_buff,sizeof(line_buff),fd);
}
fgets(line_buff,sizeof(line_buff),fd);
sscanf(line_buff,"%s %d",name,&vmrss);
fclose(fd);
return vmrss;
}
第四步：获取子进程结束的状态
用户的进程可能不会正常的结束。
当我们调用的wait4(pid_t pid,int *status,int options,struct rusage *rusage)函数，其中第二个参数status是代表进程结束的状态。当子进程结束后会向父进程发送信号
| 序号 | 信号 | 作用 |
|---|---|---|
| 1 | SIGHUP | 本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。 |
| 2 | SIGINT | 程序终止(interrupt)信号,在用户键入INTR字符(通常是Ctrl-C)时发出，用于通知前台进程组终止进程。 |
| 3 | SIGQUIT | 和SIGINT类似, 但由QUIT字符(通常是Ctrl-/)来控制.进程在因收到SIGQUIT退出时会产生core文件, 在这个意义上类似于一个程序错误信号。 |
| 4 | SIGILL | 执行了非法指令. 通常是因为可执行文件本身出现错误, 或者试图执行数据段.堆栈溢出时也有可能产生这个信号。 |
| 5 | SIGTRAP | 由断点指令或其它trap指令产生. 由debugger使用。 |
| 6 | SIGABRT | 调用abort函数生成的信号。 |
| 7 | SIGBUS | 非法地址, 包括内存地址对齐(alignment)出错。比如访问一个四个字长的整数, 但其地址不是4的倍数。它与SIGSEGV的区别在于后者是由于对合法存储地址的非法访问触发的(如访问不属于自己存储空间或只读存储空间)。 |
| 8 | SIGFPE | 在发生致命的算术运算错误时发出. 不仅包括浮点运算错误,还包括溢出及除数为0等其它所有的算术的错误。 |
| 9 | SIGKILL | 用来立即结束程序的运行.本信号不能被阻塞、处理和忽略。如果管理员发现某个进程终止不了，可尝试发送这个信号。 |
| 10 | SIGUSR1 | 留给用户使用 |
| 11 | SIGSEGV | 试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据. |
| 12 | SIGUSR2 | 留给用户使用 |
| 13 | SIGPIPE | 管道破裂。这个信号通常在进程间通信产生，比如采用FIFO(管道)通信的两个进程，读管道没打开或者意外终止就往管道写，写进程会收到SIGPIPE信号。此外用Socket通信的两个进程，写进程在写Socket的时候，读进程已经终止。 |
| 14 | SIGALRM | 时钟定时信号, 计算的是实际的时间或时钟时间. alarm函数使用该信号. |
| 15 | SIGTERM | 程序结束(terminate)信号,与SIGKILL不同的是该信号可以被阻塞和处理。通常用来要求程序自己正常退出，shell命令kill缺省产生这个信号。如果进程终止不了，我们才会尝试SIGKILL。 |
| 16 | SIGCHLD | 子进程结束时, 父进程会收到这个信号。如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情况我们应该避免(父进程或者忽略S |
| 18 | SIGCONT | 让一个停止(stopped)的进程继续执行. 本信号不能被阻塞.可以用一个handler来让程序在由stopped状态变为继续执行时完成特定的工作. 例如, 重新显示提示符 |
| 19 | SIGSTOP | 停止(stopped)进程的执行. 注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执行. 本信号不能被阻塞, 处理或忽略. |
| 20 | SIGTSTP | 停止进程的运行, 但该信号可以被处理和忽略.用户键入SUSP字符时(通常是Ctrl-Z)发出这个信号 |
| 21 | SIGTTIN | 当后台作业要从用户终端读数据时, 该作业中的所有进程会收到SIGTTIN信号.缺省时这些进程会停止执行. |
| 22 | SIGTTOU | 类似于SIGTTIN, 但在写终端(或修改终端模式)时收到. |
| 23 | SIGURG | 有"紧急"数据或out-of-band数据到达socket时产生. |
| 24 | SIGXCPU | 超过CPU时间资源限制. 这个限制可以由getrlimit/setrlimit来读取/改变。 |
| 25 | SIGXFSZ | 当进程企图扩大文件以至于超过文件大小资源限制。 |
| 26 | SIGVTALRM | 虚拟时钟信号. 类似于SIGALRM, 但是计算的是该进程占用的CPU时间. |
| 27 | SIGPROF | 类似于SIGALRM/SIGVTALRM, 但包括该进程用的CPU时间以及系统调用的时间. |
| 28 | SIGWINCH | 窗口大小改变时发出. |
| 29 | SIGIO | 文件描述符准备就绪, 可以开始进行输入/输出操作. |
| 30 | SIGPWR | Power failure |
| 31 | SIGSYS | 非法的系统调用。 |
下面是我用来判断各种状态的代码
if(WIFSIGNALED(status)){
printf("child killed by %d
status = %d
", WTERMSIG(status),status);
switch (WTERMSIG(status)){
case SIGXCPU:
case SIGKILL: //超出时间限制
std::cout<<"TLE"<<std::endl;
result.result = JudgeResult ::TLE;
break;
case SIGXFSZ: //输出超出限制
std::cout<<"OLE"<<std::endl;
result.result = JudgeResult ::OLE;
break;
case SIGSEGV: //全局数组超过限制
case SIGABRT: //申请堆内存失败
result.result = JudgeResult ::MLE;
std::cout<<"MLE"<<std::endl;
break;
default:{ //运行错误
result.result = JudgeResult ::RE;
std::cout<<"RE"<<std::endl;
}
}
}