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:
Diff options:
Comments:
0 Commit comments
0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
r43:b03203ec084a - - 2 files changed: 24 inserted, 10 deleted
@@ -378,150 +378,146 | |||||
|
378 |
|
378 | ||
|
379 | static void |
|
379 | static void |
|
380 | boxkeeper(void) |
|
380 | boxkeeper(void) |
|
381 | { |
|
381 | { |
|
382 | int syscall_count = 0; |
|
382 | int syscall_count = 0; |
|
383 | struct sigaction sa; |
|
383 | struct sigaction sa; |
|
384 |
|
384 | ||
|
385 | is_ptraced = 1; |
|
385 | is_ptraced = 1; |
|
386 | bzero(&sa, sizeof(sa)); |
|
386 | bzero(&sa, sizeof(sa)); |
|
387 | sa.sa_handler = signal_int; |
|
387 | sa.sa_handler = signal_int; |
|
388 | sigaction(SIGINT, &sa, NULL); |
|
388 | sigaction(SIGINT, &sa, NULL); |
|
389 | start_time = time(NULL); |
|
389 | start_time = time(NULL); |
|
390 | ticks_per_sec = sysconf(_SC_CLK_TCK); |
|
390 | ticks_per_sec = sysconf(_SC_CLK_TCK); |
|
391 | if (ticks_per_sec <= 0) |
|
391 | if (ticks_per_sec <= 0) |
|
392 | die("Invalid ticks_per_sec!"); |
|
392 | die("Invalid ticks_per_sec!"); |
|
393 |
|
393 | ||
|
394 | check_memory_usage(); |
|
394 | check_memory_usage(); |
|
395 |
|
395 | ||
|
396 | sa.sa_handler = signal_alarm; |
|
396 | sa.sa_handler = signal_alarm; |
|
397 | sigaction(SIGALRM, &sa, NULL); |
|
397 | sigaction(SIGALRM, &sa, NULL); |
|
398 | //alarm(1); |
|
398 | //alarm(1); |
|
399 |
|
399 | ||
|
400 | struct itimerval val; |
|
400 | struct itimerval val; |
|
401 | val.it_interval.tv_sec = 0; |
|
401 | val.it_interval.tv_sec = 0; |
|
402 | val.it_interval.tv_usec = 50000; |
|
402 | val.it_interval.tv_usec = 50000; |
|
403 | val.it_value.tv_sec = 0; |
|
403 | val.it_value.tv_sec = 0; |
|
404 | val.it_value.tv_usec = 50000; |
|
404 | val.it_value.tv_usec = 50000; |
|
405 | setitimer(ITIMER_REAL,&val,NULL); |
|
405 | setitimer(ITIMER_REAL,&val,NULL); |
|
406 |
|
406 | ||
|
407 | /* |
|
407 | /* |
|
408 | --- add alarm handler no matter what.. |
|
408 | --- add alarm handler no matter what.. |
|
409 | if (timeout) |
|
409 | if (timeout) |
|
410 | { |
|
410 | { |
|
411 | sa.sa_handler = signal_alarm; |
|
411 | sa.sa_handler = signal_alarm; |
|
412 | sigaction(SIGALRM, &sa, NULL); |
|
412 | sigaction(SIGALRM, &sa, NULL); |
|
413 | alarm(1); |
|
413 | alarm(1); |
|
414 | } |
|
414 | } |
|
415 | */ |
|
415 | */ |
|
416 |
|
416 | ||
|
417 | for(;;) |
|
417 | for(;;) |
|
418 | { |
|
418 | { |
|
419 | struct rusage rus; |
|
419 | struct rusage rus; |
|
420 | int stat; |
|
420 | int stat; |
|
421 | pid_t p; |
|
421 | pid_t p; |
|
422 |
|
422 | ||
|
423 | if (timer_tick) |
|
423 | if (timer_tick) |
|
424 | { |
|
424 | { |
|
425 | check_timeout(); |
|
425 | check_timeout(); |
|
|
426 | + check_memory_usage(); | ||
|
426 | timer_tick = 0; |
|
427 | timer_tick = 0; |
|
427 | } |
|
428 | } |
|
428 | p = wait4(box_pid, &stat, WUNTRACED, &rus); |
|
429 | p = wait4(box_pid, &stat, WUNTRACED, &rus); |
|
429 |
|
430 | ||
|
430 | - if(!WIFEXITED(stat)) { |
|
||
|
431 | - // printf("CHECKING\n"); |
|
||
|
432 | - check_memory_usage(); |
|
||
|
433 | - } |
|
||
|
434 | - |
|
||
|
435 | if (p < 0) |
|
431 | if (p < 0) |
|
436 | { |
|
432 | { |
|
437 | if (errno == EINTR) |
|
433 | if (errno == EINTR) |
|
438 | continue; |
|
434 | continue; |
|
439 | die("wait4: %m"); |
|
435 | die("wait4: %m"); |
|
440 | } |
|
436 | } |
|
441 | if (p != box_pid) |
|
437 | if (p != box_pid) |
|
442 | die("wait4: unknown pid %d exited!", p); |
|
438 | die("wait4: unknown pid %d exited!", p); |
|
443 | if (WIFEXITED(stat)) |
|
439 | if (WIFEXITED(stat)) |
|
444 | { |
|
440 | { |
|
445 | struct timeval total; |
|
441 | struct timeval total; |
|
446 | int wall; |
|
442 | int wall; |
|
447 | wall = time(NULL) - start_time; |
|
443 | wall = time(NULL) - start_time; |
|
448 | timeradd(&rus.ru_utime, &rus.ru_stime, &total); |
|
444 | timeradd(&rus.ru_utime, &rus.ru_stime, &total); |
|
449 |
|
445 | ||
|
450 | box_pid = 0; |
|
446 | box_pid = 0; |
|
451 | if (WEXITSTATUS(stat)) |
|
447 | if (WEXITSTATUS(stat)) |
|
452 | - fprintf(stderr,"Exited with error status %d.", WEXITSTATUS(stat)); |
|
448 | + fprintf(stderr,"Exited with error status %d.\n", WEXITSTATUS(stat)); |
|
453 | else if ((use_wall_clock ? wall : total.tv_sec) > timeout) |
|
449 | else if ((use_wall_clock ? wall : total.tv_sec) > timeout) |
|
454 | - fprintf(stderr,"Time limit exceeded."); |
|
450 | + fprintf(stderr,"Time limit exceeded.\n"); |
|
455 | else |
|
451 | else |
|
456 | // report OK and statistics |
|
452 | // report OK and statistics |
|
457 | fprintf(stderr,"OK\n"); |
|
453 | fprintf(stderr,"OK\n"); |
|
458 |
|
454 | ||
|
459 | fprintf(stderr,"%dr%.4lfu%.4lfs%dm\n", |
|
455 | fprintf(stderr,"%dr%.4lfu%.4lfs%dm\n", |
|
460 | wall, |
|
456 | wall, |
|
461 | (double) rus.ru_utime.tv_sec + |
|
457 | (double) rus.ru_utime.tv_sec + |
|
462 | ((double) rus.ru_utime.tv_usec/1000000.0), |
|
458 | ((double) rus.ru_utime.tv_usec/1000000.0), |
|
463 | (double) rus.ru_stime.tv_sec + |
|
459 | (double) rus.ru_stime.tv_sec + |
|
464 | ((double) rus.ru_stime.tv_usec/1000000.0), |
|
460 | ((double) rus.ru_stime.tv_usec/1000000.0), |
|
465 | max_mem_used); |
|
461 | max_mem_used); |
|
466 | /* |
|
462 | /* |
|
467 | (%.4lf sec real (%d), %d sec wall, %d syscalls, %d kb)\n", |
|
463 | (%.4lf sec real (%d), %d sec wall, %d syscalls, %d kb)\n", |
|
468 | (double) total.tv_sec + ((double)total.tv_usec / 1000000.0), |
|
464 | (double) total.tv_sec + ((double)total.tv_usec / 1000000.0), |
|
469 | (int) total.tv_usec, |
|
465 | (int) total.tv_usec, |
|
470 | wall, |
|
466 | wall, |
|
471 | syscall_count, |
|
467 | syscall_count, |
|
472 | max_mem_used); |
|
468 | max_mem_used); |
|
473 | */ |
|
469 | */ |
|
474 | exit(0); |
|
470 | exit(0); |
|
475 | } |
|
471 | } |
|
476 | if (WIFSIGNALED(stat)) |
|
472 | if (WIFSIGNALED(stat)) |
|
477 | { |
|
473 | { |
|
478 | box_pid = 0; |
|
474 | box_pid = 0; |
|
479 | - fprintf(stderr,"Caught fatal signal %d.", WTERMSIG(stat)); |
|
475 | + fprintf(stderr,"Caught fatal signal %d.\n", WTERMSIG(stat)); |
|
480 |
|
476 | ||
|
481 | struct timeval total; |
|
477 | struct timeval total; |
|
482 | int wall; |
|
478 | int wall; |
|
483 | wall = time(NULL) - start_time; |
|
479 | wall = time(NULL) - start_time; |
|
484 | timeradd(&rus.ru_utime, &rus.ru_stime, &total); |
|
480 | timeradd(&rus.ru_utime, &rus.ru_stime, &total); |
|
485 | fprintf(stderr,"%dr%.4lfu%.4lfs%dm\n", |
|
481 | fprintf(stderr,"%dr%.4lfu%.4lfs%dm\n", |
|
486 | wall, |
|
482 | wall, |
|
487 | (double) rus.ru_utime.tv_sec + |
|
483 | (double) rus.ru_utime.tv_sec + |
|
488 | ((double) rus.ru_utime.tv_usec/1000000.0), |
|
484 | ((double) rus.ru_utime.tv_usec/1000000.0), |
|
489 | (double) rus.ru_stime.tv_sec + |
|
485 | (double) rus.ru_stime.tv_sec + |
|
490 | ((double) rus.ru_stime.tv_usec/1000000.0), |
|
486 | ((double) rus.ru_stime.tv_usec/1000000.0), |
|
491 | max_mem_used); |
|
487 | max_mem_used); |
|
492 | exit(0); |
|
488 | exit(0); |
|
493 | } |
|
489 | } |
|
494 | if (WIFSTOPPED(stat)) |
|
490 | if (WIFSTOPPED(stat)) |
|
495 | { |
|
491 | { |
|
496 | int sig = WSTOPSIG(stat); |
|
492 | int sig = WSTOPSIG(stat); |
|
497 | if (sig == SIGTRAP) |
|
493 | if (sig == SIGTRAP) |
|
498 | { |
|
494 | { |
|
499 | struct user u; |
|
495 | struct user u; |
|
500 | static int stop_count = -1; |
|
496 | static int stop_count = -1; |
|
501 | if (ptrace(PTRACE_GETREGS, box_pid, NULL, &u) < 0) |
|
497 | if (ptrace(PTRACE_GETREGS, box_pid, NULL, &u) < 0) |
|
502 | die("ptrace(PTRACE_GETREGS): %m"); |
|
498 | die("ptrace(PTRACE_GETREGS): %m"); |
|
503 | stop_count++; |
|
499 | stop_count++; |
|
504 | if (!stop_count) /* Traceme request */ |
|
500 | if (!stop_count) /* Traceme request */ |
|
505 | log(">> Traceme request caught\n"); |
|
501 | log(">> Traceme request caught\n"); |
|
506 | else if (stop_count & 1) /* Syscall entry */ |
|
502 | else if (stop_count & 1) /* Syscall entry */ |
|
507 | { |
|
503 | { |
|
508 | log(">> Syscall %3ld (%08lx,%08lx,%08lx) ", u.regs.orig_eax, u.regs.ebx, u.regs.ecx, u.regs.edx); |
|
504 | log(">> Syscall %3ld (%08lx,%08lx,%08lx) ", u.regs.orig_eax, u.regs.ebx, u.regs.ecx, u.regs.edx); |
|
509 | syscall_count++; |
|
505 | syscall_count++; |
|
510 | if (!valid_syscall(&u)) |
|
506 | if (!valid_syscall(&u)) |
|
511 | { |
|
507 | { |
|
512 | /* |
|
508 | /* |
|
513 | * Unfortunately, PTRACE_KILL kills _after_ the syscall completes, |
|
509 | * Unfortunately, PTRACE_KILL kills _after_ the syscall completes, |
|
514 | * so we have to change it to something harmless (e.g., an undefined |
|
510 | * so we have to change it to something harmless (e.g., an undefined |
|
515 | * syscall) and make the program continue. |
|
511 | * syscall) and make the program continue. |
|
516 | */ |
|
512 | */ |
|
517 | unsigned int sys = u.regs.orig_eax; |
|
513 | unsigned int sys = u.regs.orig_eax; |
|
518 | u.regs.orig_eax = 0xffffffff; |
|
514 | u.regs.orig_eax = 0xffffffff; |
|
519 | if (ptrace(PTRACE_SETREGS, box_pid, NULL, &u) < 0) |
|
515 | if (ptrace(PTRACE_SETREGS, box_pid, NULL, &u) < 0) |
|
520 | die("ptrace(PTRACE_SETREGS): %m"); |
|
516 | die("ptrace(PTRACE_SETREGS): %m"); |
|
521 | die("Forbidden syscall %d.", sys); |
|
517 | die("Forbidden syscall %d.", sys); |
|
522 | } |
|
518 | } |
|
523 | } |
|
519 | } |
|
524 | else /* Syscall return */ |
|
520 | else /* Syscall return */ |
|
525 | log("= %ld\n", u.regs.eax); |
|
521 | log("= %ld\n", u.regs.eax); |
|
526 | ptrace(PTRACE_SYSCALL, box_pid, 0, 0); |
|
522 | ptrace(PTRACE_SYSCALL, box_pid, 0, 0); |
|
527 | } |
|
523 | } |
@@ -1,23 +1,41 | |||||
|
1 | #include <stdio.h> |
|
1 | #include <stdio.h> |
|
2 | #include <stdlib.h> |
|
2 | #include <stdlib.h> |
|
3 | #include <unistd.h> |
|
3 | #include <unistd.h> |
|
|
4 | + #include <sys/time.h> | ||
|
|
5 | + #include <time.h> | ||
|
|
6 | + #include <sys/resource.h> | ||
|
4 |
|
7 | ||
|
5 | int main() |
|
8 | int main() |
|
6 | { |
|
9 | { |
|
7 | int a,b; |
|
10 | int a,b; |
|
8 |
|
11 | ||
|
9 | int c=0; |
|
12 | int c=0; |
|
10 |
|
13 | ||
|
11 | scanf("%d %d",&a,&b); |
|
14 | scanf("%d %d",&a,&b); |
|
12 | printf("%d\n",a+b); |
|
15 | printf("%d\n",a+b); |
|
13 |
|
16 | ||
|
14 | - sleep(1); |
|
17 | + struct rusage ru; |
|
15 |
|
18 | ||
|
16 | - c = 0; |
|
19 | + while(1) { |
|
|
20 | + c++; | ||
|
|
21 | + b+=c; | ||
|
17 | while(c<1000000000) { |
|
22 | while(c<1000000000) { |
|
18 | c++; |
|
23 | c++; |
|
19 | b+=c; |
|
24 | b+=c; |
|
20 | } |
|
25 | } |
|
|
26 | + getrusage(RUSAGE_SELF,&ru); | ||
|
|
27 | + if((ru.ru_utime.tv_sec + ru.ru_stime.tv_sec)>=1) | ||
|
|
28 | + break; | ||
|
|
29 | + } | ||
|
|
30 | + printf("%d\n",b); | ||
|
|
31 | + c=0; | ||
|
|
32 | + while(c<100000000) { | ||
|
|
33 | + c++; | ||
|
|
34 | + b+=c; | ||
|
|
35 | + } | ||
|
|
36 | + if(b==10) | ||
|
|
37 | + printf("hello\n"); | ||
|
|
38 | + | ||
|
21 | exit(0); |
|
39 | exit(0); |
|
22 | } |
|
40 | } |
|
23 |
|
41 |
You need to be logged in to leave comments.
Login now