cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r43:b03203ec084a` public

parent | child

Description:

[grader] better test case for timeout, changed where check_mem_usage is called to reduce inefficiency git-svn-id: http://theory.cpe.ku.ac.th/grader/judge/trunk/scripts@167 6386c4cd-e34a-4fa8-8920-d93eb39b512e

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r43:b03203ec084a - Mon, 07 Apr 2008 17:46:30 - 2 files changed: 25 inserted, 11 deleted

std-script/box.cc ¶ +4 -8

                   case __NR_fcntl64:
                   case __NR_mmap:
                   case __NR_munmap:
                   case __NR_ioctl:
                   case __NR_uname:
                   case 252:
                   case 243:
                     return 1;
                     //    case __NR_time:
                   case __NR_alarm:
                     //    case __NR_pause:
                   case __NR_signal:
                   case __NR_fchmod:
                   case __NR_sigaction:
                   case __NR_sgetmask:
                   case __NR_ssetmask:
                   case __NR_sigsuspend:
                   case __NR_sigpending:
                   case __NR_getrlimit:
                   case __NR_getrusage:
                   case __NR_gettimeofday:
                   case __NR_select:
                   case __NR_readdir:
                   case __NR_setitimer:
                   case __NR_getitimer:
                   case __NR_sigreturn:
                   case __NR_mprotect:
                   case __NR_sigprocmask:
                   case __NR_getdents:
                   case __NR_getdents64:
                   case __NR__newselect:
                   case __NR_fdatasync:
                   case __NR_mremap:
                   case __NR_poll:
                   case __NR_getcwd:
                   case __NR_nanosleep:
                   case __NR_rt_sigreturn:
                   case __NR_rt_sigaction:
                   case __NR_rt_sigprocmask:
                   case __NR_rt_sigpending:
                   case __NR_rt_sigtimedwait:
                   case __NR_rt_sigqueueinfo:
                   case __NR_rt_sigsuspend:
                   case __NR_mmap2:
                   case __NR__sysctl:
                     return (filter_syscalls == 1);
                   case __NR_times:
                     return allow_times;
                   case __NR_kill:
                     if (u->regs.ebx == box_pid)
               	die("Commited suicide by signal %d.", (int)u->regs.ecx);
                     return 0;
                   default:
                     return 0;
                   }
               }
               static void
               signal_alarm(int unused UNUSED)
               {
                 /* Time limit checks are synchronous, so we only schedule them there. */
                 timer_tick = 1;
                 //NOTE: do not use alarm, changed to setitimer for precision
                 //  alarm(1);
               }
               static void
               signal_int(int unused UNUSED)
               {
                 /* Interrupts are fatal, so no synchronization requirements. */
                 die("Interrupted.");
               }
               static void
               check_timeout(void)
               {
                 int sec;
                 if (use_wall_clock)
                   sec = time(NULL) - start_time;
                 else
                   {
                     char buf[4096], *x;
                     int c, utime, stime;
                     static int proc_status_fd;
                     if (!proc_status_fd)
               	{
               	  sprintf(buf, "/proc/%d/stat", (int) box_pid);
               	  proc_status_fd = open(buf, O_RDONLY);
               	  if (proc_status_fd < 0)
               	    die("open(%s): %m", buf);
               	}
                     lseek(proc_status_fd, 0, SEEK_SET);
                     if ((c = read(proc_status_fd, buf, sizeof(buf)-1)) < 0)
               	die("read on /proc/$pid/stat: %m");
                     if (c >= (int) sizeof(buf) - 1)
               	die("/proc/$pid/stat too long");
                     buf[c] = 0;
                     x = buf;
                     while (*x && *x != ' ')
               	x++;
                     while (*x == ' ')
               	x++;
                     if (*x++ != '(')
               	die("proc syntax error 1");
                     while (*x && (*x != ')' || x[1] != ' '))
               	x++;
                     while (*x == ')' || *x == ' ')
               	x++;
                     if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
               	die("proc syntax error 2");
                     //printf("%s - %d\n",x,ticks_per_sec);
                     sec = (utime + stime + ticks_per_sec-1)/ticks_per_sec;
                   }
                 if (verbose > 1)
                   fprintf(stderr, "[timecheck: %d seconds]\n", sec);
                 if (sec > timeout) {
                   die_report("Time limit exceeded.");
                 }
               }
               int max_mem_used = 0;
               static void
               check_memory_usage()
               {
                 char proc_fname[100];
                 sprintf(proc_fname,"/proc/%d/statm",box_pid);
                 //printf("proc fname: %s\n",proc_fname);
                 FILE *fp = fopen(proc_fname,"r");
                 if(fp!=NULL) {
                   char line[1000];
                   fgets(line,999,fp);
                   //printf("%s\n",line);
                   int m;
                   if(sscanf(line,"%d",&m)==1)
                     if(m>max_mem_used)
               	max_mem_used = m;
                   fclose(fp);
                 }
               }
               static void
               boxkeeper(void)
               {
                 int syscall_count = 0;
                 struct sigaction sa;
                 is_ptraced = 1;
                 bzero(&sa, sizeof(sa));
                 sa.sa_handler = signal_int;
                 sigaction(SIGINT, &sa, NULL);
                 start_time = time(NULL);
                 ticks_per_sec = sysconf(_SC_CLK_TCK);
                 if (ticks_per_sec <= 0)
                   die("Invalid ticks_per_sec!");
                 check_memory_usage();
                 sa.sa_handler = signal_alarm;
                 sigaction(SIGALRM, &sa, NULL);
                 //alarm(1);
                 struct itimerval val;
                 val.it_interval.tv_sec = 0;
                 val.it_interval.tv_usec = 50000;
                 val.it_value.tv_sec = 0;
                 val.it_value.tv_usec = 50000;
                 setitimer(ITIMER_REAL,&val,NULL);
                 /*
                   --- add alarm handler no matter what..
                 if (timeout)
                   {
                     sa.sa_handler = signal_alarm;
                     sigaction(SIGALRM, &sa, NULL);
                     alarm(1);
                   }
                 */
                 for(;;)
                   {
                     struct rusage rus;
                     int stat;
                     pid_t p;
                     if (timer_tick)
               	{
               	  check_timeout();
+            + 	  check_memory_usage();
               	  timer_tick = 0;
               	}
                     p = wait4(box_pid, &stat, WUNTRACED, &rus);
-            -       if(!WIFEXITED(stat)) {
-            - 	//	printf("CHECKING\n");
-            - 	check_memory_usage();
-            -       }
+            -
                     if (p < 0)
               	{
               	  if (errno == EINTR)
               	    continue;
               	  die("wait4: %m");
               	}
                     if (p != box_pid)
               	die("wait4: unknown pid %d exited!", p);
                     if (WIFEXITED(stat))
               	{
               	  struct timeval total;
               	  int wall;
               	  wall = time(NULL) - start_time;
               	  timeradd(&rus.ru_utime, &rus.ru_stime, &total);
               	  box_pid = 0;
               	  if (WEXITSTATUS(stat))
-            - 	    fprintf(stderr,"Exited with error status %d.", WEXITSTATUS(stat));
+            + 	    fprintf(stderr,"Exited with error status %d.\n", WEXITSTATUS(stat));
               	  else if ((use_wall_clock ? wall : total.tv_sec) > timeout)
-            - 	    fprintf(stderr,"Time limit exceeded.");
+            + 	    fprintf(stderr,"Time limit exceeded.\n");
               	  else
               	    // report OK and statistics
               	    fprintf(stderr,"OK\n");
               	  fprintf(stderr,"%dr%.4lfu%.4lfs%dm\n",
               		  wall,
               		  (double) rus.ru_utime.tv_sec +
               		  ((double) rus.ru_utime.tv_usec/1000000.0),
               		  (double) rus.ru_stime.tv_sec +
               		  ((double) rus.ru_stime.tv_usec/1000000.0),
               		  max_mem_used);
               /*
               	  (%.4lf sec real (%d), %d sec wall, %d syscalls, %d kb)\n",
               		  (double) total.tv_sec + ((double)total.tv_usec / 1000000.0),
               		  (int) total.tv_usec,
               		  wall,
               		  syscall_count,
               		  max_mem_used);
               */
               	  exit(0);
               	}
                     if (WIFSIGNALED(stat))
               	{
               	  box_pid = 0;
-            - 	  fprintf(stderr,"Caught fatal signal %d.", WTERMSIG(stat));
+            + 	  fprintf(stderr,"Caught fatal signal %d.\n", WTERMSIG(stat));
               	  struct timeval total;
               	  int wall;
               	  wall = time(NULL) - start_time;
               	  timeradd(&rus.ru_utime, &rus.ru_stime, &total);
               	  fprintf(stderr,"%dr%.4lfu%.4lfs%dm\n",
               		  wall,
               		  (double) rus.ru_utime.tv_sec +
               		  ((double) rus.ru_utime.tv_usec/1000000.0),
               		  (double) rus.ru_stime.tv_sec +
               		  ((double) rus.ru_stime.tv_usec/1000000.0),
               		  max_mem_used);
               	  exit(0);
               	}
                     if (WIFSTOPPED(stat))
               	{
               	  int sig = WSTOPSIG(stat);
               	  if (sig == SIGTRAP)
               	    {
               	      struct user u;
               	      static int stop_count = -1;
               	      if (ptrace(PTRACE_GETREGS, box_pid, NULL, &u) < 0)
               		die("ptrace(PTRACE_GETREGS): %m");
               	      stop_count++;
               	      if (!stop_count)			/* Traceme request */
               		log(">> Traceme request caught\n");
               	      else if (stop_count & 1)		/* Syscall entry */
               		{
               		  log(">> Syscall %3ld (%08lx,%08lx,%08lx) ", u.regs.orig_eax, u.regs.ebx, u.regs.ecx, u.regs.edx);
               		  syscall_count++;
               		  if (!valid_syscall(&u))
               		    {
               		      /*
               		       * Unfortunately, PTRACE_KILL kills _after_ the syscall completes,
               		       * so we have to change it to something harmless (e.g., an undefined
               		       * syscall) and make the program continue.
               		       */
               		      unsigned int sys = u.regs.orig_eax;
               		      u.regs.orig_eax = 0xffffffff;
               		      if (ptrace(PTRACE_SETREGS, box_pid, NULL, &u) < 0)
               			die("ptrace(PTRACE_SETREGS): %m");
               		      die("Forbidden syscall %d.", sys);
               		    }
               		}
               	      else					/* Syscall return */
               		log("= %ld\n", u.regs.eax);
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
               	    }
               	  else if (sig != SIGSTOP && sig != SIGXCPU && sig != SIGXFSZ)
               	    {
               	      log(">> Signal %d\n", sig);
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, sig);
               	    }
               	  else
               	    die("Received signal %d.", sig);
               	}
                     else
               	die("wait4: unknown status %x, giving up!", stat);
                   }
               }
               static void
               box_inside(int argc, char **argv)
               {
                 struct rlimit rl;
                 char *args[argc+1];
                 char *env[1] = { NULL };
                 memcpy(args, argv, argc * sizeof(char *));
                 args[argc] = NULL;
                 if (set_cwd && chdir(set_cwd))
                   die("chdir: %m");
                 if (redir_stdin)
                   {
                     close(0);
                     if (open(redir_stdin, O_RDONLY) != 0)
               	die("open(\"%s\"): %m", redir_stdin);
                   }
                 if (redir_stdout)
                   {
                     close(1);
                     if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
               	die("open(\"%s\"): %m", redir_stdout);
                   }
                 dup2(1, 2);
                 setpgrp();
                 if (memory_limit)
                   {
                     rl.rlim_cur = rl.rlim_max = memory_limit * 1024;
                     if (setrlimit(RLIMIT_AS, &rl) < 0)
               	die("setrlimit: %m");
                   }
                 rl.rlim_cur = rl.rlim_max = 64;
                 if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
                   die("setrlimit: %m");
                 if (filter_syscalls && ptrace(PTRACE_TRACEME) < 0)
                   die("ptrace(PTRACE_TRACEME): %m");
                 execve(args[0], args, (pass_environ ? environ : env));
                 die("execve(\"%s\"): %m", args[0]);
               }
               static void
               usage(void)
               {
                 fprintf(stderr, "Invalid arguments!\n");
                 printf("\
               Usage: box [<options>] -- <command> <arguments>\n\
               \n\
               Options:\n\
               -a <level>\tSet file access level (0=none, 1=cwd, 2=/etc,/lib,..., 3=whole fs, 9=no checks; needs -f)\n\
               -c <dir>\tChange directory to <dir> first\n\
               -e\t\tPass full environment of parent process\n\
               -f\t\tFilter system calls (-ff=very restricted)\n\
               -i <file>\tRedirect stdin from <file>\n\
               -m <size>\tLimit address space to <size> KB\n\
               -o <file>\tRedirect stdout to <file>\n\
               -t <time>\tStop after <time> seconds\n\
               -T\t\tAllow syscalls for measuring run time\n\
               -v\t\tBe verbose\n\
               -w\t\tMeasure wall clock time instead of run time\n\
               ");
                 exit(1);
               }
               int
               main(int argc, char **argv)
               {
                 int c;
                 uid_t uid;
                 while ((c = getopt(argc, argv, "a:c:efi:m:o:t:Tvw")) >= 0)
                   switch (c)
                     {
                     case 'a':
               	file_access = atol(optarg);
               	break;
                     case 'c':
               	set_cwd = optarg;
               	break;
                     case 'e':
               	pass_environ = 1;
               	break;
                     case 'f':
               	filter_syscalls++;
               	break;
                     case 'i':
               	redir_stdin = optarg;
               	break;
                     case 'm':
               	memory_limit = atol(optarg);
               	break;
                     case 'o':
               	redir_stdout = optarg;
               	break;
                     case 't':
               	timeout = atol(optarg);
               	break;
                     case 'T':
               	allow_times++;
               	break;
                     case 'v':
               	verbose++;
               	break;
                     case 'w':
               	use_wall_clock = 1;
               	break;
                     default:
               	usage();
                     }
                 if (optind >= argc)
                   usage();
                 uid = geteuid();
                 if (setreuid(uid, uid) < 0)
                   die("setreuid: %m");
                 box_pid = fork();
                 if (box_pid < 0)
                   die("fork: %m");
                 if (!box_pid)
                   box_inside(argc-optind, argv+optind);
                 else
                   boxkeeper();
                 die("Internal error: fell over edge of the world");
               }

test/data/test2_1-5sec.c ¶ +21 -3

               #include <stdio.h>
               #include <stdlib.h>
               #include <unistd.h>
+            + #include <sys/time.h>
+            + #include <time.h>
+            + #include <sys/resource.h>
               int main()
               {
                 int a,b;
                 int c=0;
                 scanf("%d %d",&a,&b);
                 printf("%d\n",a+b);
-            -   sleep(1);
+            +   struct rusage ru;
-            -   c = 0;
-            -   while(c<1000000000) {
+            +   while(1) {
+            +     c++;
+            +     b+=c;
+            +     while(c<1000000000) {
+            +       c++;
+            +       b+=c;
+            +     }
+            +     getrusage(RUSAGE_SELF,&ru);
+            +     if((ru.ru_utime.tv_sec + ru.ru_stime.tv_sec)>=1)
+            +       break;
+            +   }
+            +   printf("%d\n",b);
+            +   c=0;
+            +   while(c<100000000) {
                   c++;
                   b+=c;
                 }
+            +   if(b==10)
+            +     printf("hello\n");
+            +
                 exit(0);
               }

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r43:b03203ec084a - Mon, 07 Apr 2008 17:46:30 - 2 files changed: 25 inserted, 11 deleted

Sign in to your account

Commit r43:b03203ec084a public

Author

r43:b03203ec084a - Mon, 07 Apr 2008 17:46:30 - 2 files changed: 25 inserted, 11 deleted

Commit `r43:b03203ec084a` public