cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r164:447fdbbeac2c` public

parent | child

Description:

change memory resolution in report to kbytes

Commit status:

[Not Reviewed]

References:

algo

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r164:447fdbbeac2c - Mon, 15 Sep 2014 15:54:56 - 3 files changed: 4 inserted, 4 deleted

lib/test_request_helper.rb ¶ +1 -1

                   begin
                     FileUtils.ln_s(src, des)
                   rescue NotImplementedError
                     FileUtils.cp(src,des)
                   end
                 end
                 def self.call_and_log(error_message)
                   begin
                     yield
                   rescue
                     msg = "ERROR: #{error_message}"
                     raise msg
                   end
                 end
                 #
                 # A TestRequestRoomMaker is a helper object for Engine
                 # - finds grading room: in user_result_dir/(user)/test_request/ ...
                 # - prepare problem configuration for grading --- basically it copy
                 #   all config files, and copy user's input into the testcase
                 #   directory.  First, it finds the template from problem template
                 #   directory; if it can't find a template, it'll use the template
                 #   from default template.
                 class TestRequestRoomMaker
                   def initialize
                     @config = Grader::Configuration.get_instance
                   end
                   def produce_grading_room(test_request)
                     grading_room = grading_room_dir(test_request)
                     FileUtils.mkdir_p(grading_room)
                     #
                     # Also copy additional submitted file to this directory as well.
                     # The program would see this file only if it is copied
                     #    to the sandbox directory later.  The run script should do it.
                     #
                     if FileTest.exists?("#{test_request.input_file_name}.files")
                       FileUtils.cp_r("#{test_request.input_file_name}.files/.",
                                      "#{grading_room}")
                     end
                     grading_room
                   end
                   def find_problem_home(test_request)
                     problem_name = test_request.problem_name
                     template_dir = "#{@config.test_request_problem_templates_dir}/" + problem_name
                     raise "Test Request: error template not found" if !File.exists?(template_dir)
                     problem_home = problem_home_dir(test_request)
                     FileUtils.mkdir_p(problem_home)
                     copy_problem_template(template_dir,problem_home)
                     link_input_file(test_request,problem_home)
                     problem_home
                   end
                   def save_source(test_request,source_name)
                     dir = self.produce_grading_room(test_request)
                     submission = test_request.submission
                     f = File.open("#{dir}/#{source_name}","w")
                     f.write(submission.source)
                     f.close
                   end
                   def clean_up(test_request)
                     problem_home = problem_home_dir(test_request)
                     remove_data_files(problem_home)
                   end
                   protected
                   def grading_room_dir(test_request)
                     problem_name = test_request.problem_name
                     user = test_request.user
                     grading_room = "#{@config.user_result_dir}" +
                       "/#{user.login}/test_request" +
                       "/#{problem_name}/#{test_request.id}"
                     grading_room
                   end
                   def problem_home_dir(test_request)
                     problem_name = test_request.problem_name
                     user = test_request.user
                     "#{@config.user_result_dir}" +
                       "/#{user.login}/test_request/#{problem_name}"
                   end
                   def copy_problem_template(template_dir,problem_home)
                     Grader::call_and_log("Test Request: cannot copy problem template") {
                       FileUtils.cp_r("#{template_dir}/.","#{problem_home}")
                     }
                   end
                   def link_input_file(test_request, problem_home)
                     input_fname = "#{test_request.input_file_name}"
                     if !File.exists?(input_fname)
                       raise "Test Request: input file not found."
                     end
                     input_fname_problem_home = "#{problem_home}/test_cases/1/input-1.txt"
                     if File.exists?(input_fname_problem_home)
                       FileUtils.rm([input_fname_problem_home], :force => true)
                     end
                     Grader::link_or_copy("#{input_fname}", "#{input_fname_problem_home}")
                   end
                   def remove_data_files(problem_home)
                     if File.exists?("#{problem_home}/test_cases/1/input-1.txt")
                       Grader::call_and_log("Test Request: cannot remove data files") {
                         FileUtils.rm Dir.glob("#{problem_home}/test_cases/1/*")
                       }
                     end
                   end
                 end
                 class TestRequestReporter
                   def initialize
                     @config = Grader::Configuration.get_instance
                   end
                   def report(test_request,test_result_dir)
                     save_result(test_request,read_result(test_result_dir))
                   end
                   def report_error(test_request, msg)
                     save_result(test_request, {:running_stat => {
                                     :msg => "#{msg}",
                                     :running_time => nil,
                                     :exit_status => "Some error occured. Program did not run",
                                     :memory_usage => nil
                                   }})
                   end
                   protected
                   def read_result(test_result_dir)
                     # TODO:
                     cmp_msg_fname = "#{test_result_dir}/compiler_message"
                     cmp_file = File.open(cmp_msg_fname)
                     cmp_msg = cmp_file.read
                     cmp_file.close
                     result_file_name = "#{test_result_dir}/1/result"
                     if File.exists?(result_file_name)
                       output_file_name = "#{test_result_dir}/1/output.txt"
                       results = []
                       File.open("#{test_result_dir}/1/result") do |f|
                         results = f.readlines
                       end
                       stat = extract_running_stat(results)
                       return {
                         :output_file_name => output_file_name,
                         :running_stat => stat,
                         :comment => "",
                         :cmp_msg => cmp_msg}
                     else
                       return {
                         :running_stat => nil,
                         :comment => "Compilation error",
                         :cmp_msg => cmp_msg}
                     end
                   end
                   def extract_running_stat(results)
                     running_stat_line = results[-1]
                     # extract exit status line
                     run_stat = ""
                     if !(/[Cc]orrect/.match(results[0]))
                       run_stat = results[0].chomp
                     else
                       run_stat = 'Program exited normally'
                     end
                     # extract running time
                     if res = /r(.*)u(.*)s/.match(running_stat_line)
                       seconds = (res[1].to_f + res[2].to_f)
                       time_stat = "Time used: #{seconds} sec."
                     else
                       seconds = nil
                       time_stat = "Time used: n/a sec."
                     end
                     # extract memory usage
-            -       if res = /s(.*)m/.match(running_stat_line)
+            +       if res = /s(.*)kbytes/.match(running_stat_line)
                       memory_used = res[1].to_i
                     else
                       memory_used = -1
                     end
                     return {
                       :msg => "#{run_stat}\n#{time_stat}",
                       :running_time => seconds,
                       :exit_status => run_stat,
                       :memory_usage => memory_used
                     }
                   end
                   def save_result(test_request,result)
                     if result[:output_file_name]!=nil
                       test_request.output_file_name = link_output_file(test_request,
                                                                        result[:output_file_name])
                     end
                     test_request.graded_at = Time.now
                     test_request.compiler_message = (result[:cmp_msg] or '')
                     test_request.grader_comment = (result[:comment] or '')
                     if result[:running_stat]!=nil
                       test_request.running_stat = (result[:running_stat][:msg] or '')
                       test_request.running_time = (result[:running_stat][:running_time] or nil)
                       test_request.exit_status = result[:running_stat][:exit_status]
                       test_request.memory_usage = result[:running_stat][:memory_usage]
                     else
                       test_request.running_stat = ''
                     end
                     test_request.save
                   end
                   protected
                   def link_output_file(test_request, fname)
                     target_file_name = random_output_file_name(test_request.user,
                                                                test_request.problem)
                     FileUtils.mkdir_p(File.dirname(target_file_name))
                     Grader::link_or_copy("#{fname}", "#{target_file_name}")
                     return target_file_name
                   end
                   def random_output_file_name(user,problem)
                     problem_name = TestRequest.name_of(problem)
                     begin
                       tmpname =  "#{@config.test_request_output_base_dir}" +
                         "/#{user.login}/#{problem_name}/#{rand(10000)}"
                     end while File.exists?(tmpname)
                     tmpname
                   end
                 end
               end

std-script/box64-new.c ¶ +2 -2

               /*
                *	A Simple Sandbox for Moe
                *
                *	(c) 2001--2010 Martin Mares <mj@ucw.cz>
                */
               #define _LARGEFILE64_SOURCE
               #define _GNU_SOURCE
               /* Generated automatically by ./configure, please don't touch manually. */
               #define CONFIG_BOX_KERNEL_AMD64 1
               #define CONFIG_BOX_USER_AMD64 1
               #define CONFIG_DIR "cf"
               #define CONFIG_DIRECT_IO 1
               #define CONFIG_ISOLATE_BOX_DIR "/tmp/box"
               #define CONFIG_ISOLATE_CGROUP_ROOT "/sys/fs/cgroup"
               #define CONFIG_ISOLATE_FIRST_GID 60000
               #define CONFIG_ISOLATE_FIRST_UID 60000
               #define CONFIG_ISOLATE_NUM_BOXES 100
               #define CONFIG_LARGE_FILES 1
               #define CONFIG_LFS 1
               #define CONFIG_LINUX 1
               #define CONFIG_LOCAL 1
               #define CONFIG_UCW_PARTMAP_IS_MMAP 1
               #define CONFIG_UCW_PERL 1
               #define CONFIG_UCW_POOL_IS_MMAP 1
               #define CONFIG_UCW_RADIX_SORTER_BITS 10
               #define CONFIG_UCW_SHELL_UTILS 1
               #define CPU_64BIT_POINTERS 1
               #define CPU_ALLOW_UNALIGNED 1
               #define CPU_AMD64 1
               #define CPU_ARCH "default"
               #define CPU_LITTLE_ENDIAN 1
               #define CPU_PAGE_SIZE 4096
               #define CPU_STRUCT_ALIGN 8
               #define CWARNS_OFF " -Wno-pointer-sign"
               #define HAVE_ASCII_DOC "none"
               #define INSTALL_BIN_DIR "bin"
               #define INSTALL_CONFIG_DIR "cf"
               #define INSTALL_DOC_DIR "share/doc"
               #define INSTALL_INCLUDE_DIR "include"
               #define INSTALL_LIB_DIR "lib"
               #define INSTALL_LOG_DIR "log"
               #define INSTALL_MAN_DIR "share/man"
               #define INSTALL_PERL_DIR "lib/perl5"
               #define INSTALL_PKGCONFIG_DIR "lib/pkgconfig"
               #define INSTALL_PREFIX
               #define INSTALL_RUN_DIR "run"
               #define INSTALL_SBIN_DIR "sbin"
               #define INSTALL_SHARE_DIR "share"
               #define INSTALL_STATE_DIR "lib"
               #define INSTALL_USR_PREFIX
               #define INSTALL_VAR_PREFIX
               #define SHERLOCK_VERSION "3.99.2"
               #define SHERLOCK_VERSION_CODE 3099002
               #define SONAME_PREFIX "lib/"
               #define UCW_VERSION "3.99.2"
               #define UCW_VERSION_CODE 3099002
               #include <errno.h>
               #include <stdio.h>
               #include <fcntl.h>
               #include <stdlib.h>
               #include <string.h>
               #include <stdarg.h>
               #include <stdint.h>
               #include <unistd.h>
               #include <getopt.h>
               #include <time.h>
               #include <sys/wait.h>
               #include <sys/user.h>
               #include <sys/time.h>
               #include <sys/ptrace.h>
               #include <sys/signal.h>
               #include <sys/sysinfo.h>
               #include <sys/resource.h>
               #include <sys/utsname.h>
               //#include <linux/ptrace.h>
               #if defined(CONFIG_BOX_KERNEL_AMD64) && !defined(CONFIG_BOX_USER_AMD64)
               #include <asm/unistd_32.h>
               #define NATIVE_NR_execve 59		/* 64-bit execve */
               #else
               #include <asm/unistd.h>
               #define NATIVE_NR_execve __NR_execve
               #endif
               #define NONRET __attribute__((noreturn))
               #define UNUSED __attribute__((unused))
               #define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(a[0]))
               static int filter_syscalls;		/* 0=off, 1=liberal, 2=totalitarian */
               static int timeout;			/* milliseconds */
               static int wall_timeout;
               static int extra_timeout;
               static int pass_environ;
               static int file_access;
               static int verbose;
               static int memory_limit;
               static int stack_limit;
               static char *redir_stdin, *redir_stdout, *redir_stderr;
               static char *set_cwd;
               static pid_t box_pid;
               static int is_ptraced;
               static volatile int timer_tick;
               static struct timeval start_time;
               static int ticks_per_sec;
               static int exec_seen;
               static int partial_line;
               static int mem_peak_kb;
               static int total_ms, wall_ms, sys_ms;
               static void die(char *msg, ...) NONRET;
               static void sample_mem_peak(void);
               /*** Meta-files ***/
               static FILE *metafile;
               static void
               meta_open(const char *name)
               {
                 if (!strcmp(name, "-"))
                   {
                     metafile = stdout;
                     return;
                   }
                 metafile = fopen(name, "w");
                 if (!metafile)
                   die("Failed to open metafile '%s'",name);
               }
               static void
               meta_close(void)
               {
                 if (metafile && metafile != stdout)
                   fclose(metafile);
               }
               static void __attribute__((format(printf,1,2)))
               meta_printf(const char *fmt, ...)
               {
                 if (!metafile)
                   return;
                 va_list args;
                 va_start(args, fmt);
                 vfprintf(metafile, fmt, args);
                 va_end(args);
               }
               static void print_running_stat(double wall_time,
               			double user_time,
               			double system_time,
               			int mem_usage)
               {
                 //total is user
                 //wall is wall
                 //
-            -   fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dm\n",
+            +   fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dkbytes\n",
               	  wall_time, user_time, system_time, mem_usage);
               }
               static void
               final_stats(struct rusage *rus)
               {
                 struct timeval total, now, wall;
                 timeradd(&rus->ru_utime, &rus->ru_stime, &total);
                 total_ms = total.tv_sec*1000 + total.tv_usec/1000;
                 gettimeofday(&now, NULL);
                 timersub(&now, &start_time, &wall);
                 wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
                 sys_ms = rus->ru_stime.tv_sec * 1000 + rus->ru_stime.tv_usec / 1000;
                 meta_printf("time:%d.%03d\n", total_ms/1000, total_ms%1000);
                 meta_printf("time-wall:%d.%03d\n", wall_ms/1000, wall_ms%1000);
                 meta_printf("mem:%llu\n", (unsigned long long) mem_peak_kb * 1024);
               }
               /*** Messages and exits ***/
               static void NONRET
               box_exit(int rc)
               {
                 if (box_pid > 0)
                   {
                     sample_mem_peak();
                     if (is_ptraced)
               	ptrace(PTRACE_KILL, box_pid);
                     kill(-box_pid, SIGKILL);
                     kill(box_pid, SIGKILL);
                     meta_printf("killed:1\n");
                     struct rusage rus;
                     int p, stat;
                     do
               	p = wait4(box_pid, &stat, 0, &rus);
                     while (p < 0 && errno == EINTR);
                     if (p < 0)
               	fprintf(stderr, "UGH: Lost track of the process (%m)\n");
                     else {
               	final_stats(&rus);
                     }
                   }
                 print_running_stat(
                       (double)wall_ms/1000,
                       (double)total_ms/1000,
                       (double)sys_ms/1000,
-            -         (mem_peak_kb + 1023) / 1024);
+            +         mem_peak_kb);
                 meta_close();
                 exit(rc);
               }
               static void
               flush_line(void)
               {
                 if (partial_line)
                   fputc('\n', stderr);
                 partial_line = 0;
               }
               /* Report an error of the sandbox itself */
               static void NONRET __attribute__((format(printf,1,2)))
               die(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 flush_line();
                 char buf[1024];
                 vsnprintf(buf, sizeof(buf), msg, args);
                 meta_printf("status:XX\nmessage:%s\n", buf);
                 fputs(buf, stderr);
                 fputc('\n', stderr);
                 box_exit(2);
               }
               /* Report an error of the program inside the sandbox */
               static void NONRET __attribute__((format(printf,1,2)))
               err(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 flush_line();
                 if (msg[0] && msg[1] && msg[2] == ':' && msg[3] == ' ')
                   {
                     meta_printf("status:%c%c\n", msg[0], msg[1]);
                     msg += 4;
                   }
                 char buf[1024];
                 vsnprintf(buf, sizeof(buf), msg, args);
                 meta_printf("message:%s\n", buf);
                 fputs(buf, stderr);
                 fputc('\n', stderr);
                 box_exit(1);
               }
               /* Write a message, but only if in verbose mode */
               static void __attribute__((format(printf,1,2)))
               msg(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 if (verbose)
                   {
                     int len = strlen(msg);
                     if (len > 0)
                       partial_line = (msg[len-1] != '\n');
                     vfprintf(stderr, msg, args);
                     fflush(stderr);
                   }
                 va_end(args);
               }
               static void *
               xmalloc(size_t size)
               {
                 void *p = malloc(size);
                 if (!p)
                   die("Out of memory");
                 return p;
               }
               /*** Syscall rules ***/
               static const char * const syscall_names[] = {
               /* Syscall table automatically generated by mk-syscall-table */
               /* 0 */ [ __NR_read ] = "read",
               /* 1 */ [ __NR_write ] = "write",
               /* 2 */ [ __NR_open ] = "open",
               /* 3 */ [ __NR_close ] = "close",
               /* 4 */ [ __NR_stat ] = "stat",
               /* 5 */ [ __NR_fstat ] = "fstat",
               /* 6 */ [ __NR_lstat ] = "lstat",
               /* 7 */ [ __NR_poll ] = "poll",
               /* 8 */ [ __NR_lseek ] = "lseek",
               /* 9 */ [ __NR_mmap ] = "mmap",
               /* 10 */ [ __NR_mprotect ] = "mprotect",
               /* 11 */ [ __NR_munmap ] = "munmap",
               /* 12 */ [ __NR_brk ] = "brk",
               /* 13 */ [ __NR_rt_sigaction ] = "rt_sigaction",
               /* 14 */ [ __NR_rt_sigprocmask ] = "rt_sigprocmask",
               /* 15 */ [ __NR_rt_sigreturn ] = "rt_sigreturn",
               /* 16 */ [ __NR_ioctl ] = "ioctl",
               /* 17 */ [ __NR_pread64 ] = "pread64",
               /* 18 */ [ __NR_pwrite64 ] = "pwrite64",
               /* 19 */ [ __NR_readv ] = "readv",
               /* 20 */ [ __NR_writev ] = "writev",
               /* 21 */ [ __NR_access ] = "access",
               /* 22 */ [ __NR_pipe ] = "pipe",
               /* 23 */ [ __NR_select ] = "select",
               /* 24 */ [ __NR_sched_yield ] = "sched_yield",
               /* 25 */ [ __NR_mremap ] = "mremap",
               /* 26 */ [ __NR_msync ] = "msync",
               /* 27 */ [ __NR_mincore ] = "mincore",
               /* 28 */ [ __NR_madvise ] = "madvise",
               /* 29 */ [ __NR_shmget ] = "shmget",
               /* 30 */ [ __NR_shmat ] = "shmat",
               /* 31 */ [ __NR_shmctl ] = "shmctl",
               /* 32 */ [ __NR_dup ] = "dup",
               /* 33 */ [ __NR_dup2 ] = "dup2",
               /* 34 */ [ __NR_pause ] = "pause",
               /* 35 */ [ __NR_nanosleep ] = "nanosleep",
               /* 36 */ [ __NR_getitimer ] = "getitimer",
               /* 37 */ [ __NR_alarm ] = "alarm",
               /* 38 */ [ __NR_setitimer ] = "setitimer",
               /* 39 */ [ __NR_getpid ] = "getpid",
               /* 40 */ [ __NR_sendfile ] = "sendfile",
               /* 41 */ [ __NR_socket ] = "socket",
               /* 42 */ [ __NR_connect ] = "connect",
               /* 43 */ [ __NR_accept ] = "accept",
               /* 44 */ [ __NR_sendto ] = "sendto",
               /* 45 */ [ __NR_recvfrom ] = "recvfrom",
               /* 46 */ [ __NR_sendmsg ] = "sendmsg",
               /* 47 */ [ __NR_recvmsg ] = "recvmsg",
               /* 48 */ [ __NR_shutdown ] = "shutdown",
               /* 49 */ [ __NR_bind ] = "bind",
               /* 50 */ [ __NR_listen ] = "listen",
               /* 51 */ [ __NR_getsockname ] = "getsockname",
               /* 52 */ [ __NR_getpeername ] = "getpeername",
               /* 53 */ [ __NR_socketpair ] = "socketpair",
               /* 54 */ [ __NR_setsockopt ] = "setsockopt",
               /* 55 */ [ __NR_getsockopt ] = "getsockopt",
               /* 56 */ [ __NR_clone ] = "clone",
               /* 57 */ [ __NR_fork ] = "fork",
               /* 58 */ [ __NR_vfork ] = "vfork",
               /* 59 */ [ __NR_execve ] = "execve",
               /* 60 */ [ __NR_exit ] = "exit",
               /* 61 */ [ __NR_wait4 ] = "wait4",
               /* 62 */ [ __NR_kill ] = "kill",
               /* 63 */ [ __NR_uname ] = "uname",
               /* 64 */ [ __NR_semget ] = "semget",
               /* 65 */ [ __NR_semop ] = "semop",
               /* 66 */ [ __NR_semctl ] = "semctl",
               /* 67 */ [ __NR_shmdt ] = "shmdt",
               /* 68 */ [ __NR_msgget ] = "msgget",
               /* 69 */ [ __NR_msgsnd ] = "msgsnd",
               /* 70 */ [ __NR_msgrcv ] = "msgrcv",
               /* 71 */ [ __NR_msgctl ] = "msgctl",
               /* 72 */ [ __NR_fcntl ] = "fcntl",
               /* 73 */ [ __NR_flock ] = "flock",
               /* 74 */ [ __NR_fsync ] = "fsync",
               /* 75 */ [ __NR_fdatasync ] = "fdatasync",
               /* 76 */ [ __NR_truncate ] = "truncate",
               /* 77 */ [ __NR_ftruncate ] = "ftruncate",
               /* 78 */ [ __NR_getdents ] = "getdents",
               /* 79 */ [ __NR_getcwd ] = "getcwd",
               /* 80 */ [ __NR_chdir ] = "chdir",
               /* 81 */ [ __NR_fchdir ] = "fchdir",
               /* 82 */ [ __NR_rename ] = "rename",
               /* 83 */ [ __NR_mkdir ] = "mkdir",
               /* 84 */ [ __NR_rmdir ] = "rmdir",
               /* 85 */ [ __NR_creat ] = "creat",
               /* 86 */ [ __NR_link ] = "link",
               /* 87 */ [ __NR_unlink ] = "unlink",
               /* 88 */ [ __NR_symlink ] = "symlink",
               /* 89 */ [ __NR_readlink ] = "readlink",
               /* 90 */ [ __NR_chmod ] = "chmod",
               /* 91 */ [ __NR_fchmod ] = "fchmod",
               /* 92 */ [ __NR_chown ] = "chown",
               /* 93 */ [ __NR_fchown ] = "fchown",
               /* 94 */ [ __NR_lchown ] = "lchown",
               /* 95 */ [ __NR_umask ] = "umask",
               /* 96 */ [ __NR_gettimeofday ] = "gettimeofday",
               /* 97 */ [ __NR_getrlimit ] = "getrlimit",
               /* 98 */ [ __NR_getrusage ] = "getrusage",
               /* 99 */ [ __NR_sysinfo ] = "sysinfo",
               /* 100 */ [ __NR_times ] = "times",
               /* 101 */ [ __NR_ptrace ] = "ptrace",
               /* 102 */ [ __NR_getuid ] = "getuid",
               /* 103 */ [ __NR_syslog ] = "syslog",
               /* 104 */ [ __NR_getgid ] = "getgid",
               /* 105 */ [ __NR_setuid ] = "setuid",
               /* 106 */ [ __NR_setgid ] = "setgid",
               /* 107 */ [ __NR_geteuid ] = "geteuid",
               /* 108 */ [ __NR_getegid ] = "getegid",
               /* 109 */ [ __NR_setpgid ] = "setpgid",
               /* 110 */ [ __NR_getppid ] = "getppid",
               /* 111 */ [ __NR_getpgrp ] = "getpgrp",
               /* 112 */ [ __NR_setsid ] = "setsid",

std-script/grade ¶ +1 -1

               #!/usr/bin/env ruby
               CORRECT_MARK = 'P'
               INCORRECT_MARK = '-'
               TIMEOUT_MARK = 'T'
               RUN_ERROR_MARK = 'x'
               def log(str='')
                 if ENV['TALKATIVE']!=nil
                   puts str
                 end
                 if ENV['GRADER_LOGGING']!=nil
                   log_fname = ENV['GRADER_LOGGING']
                   fp = File.open(log_fname,"a")
                   fp.puts("grade: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               def char_comment(comment)
                 if comment =~ /[Ii]ncorrect/
                   INCORRECT_MARK
                 elsif comment =~ /[Cc]orrect/
                   CORRECT_MARK
                 elsif comment =~ /[Tt]ime/
                   TIMEOUT_MARK
                 elsif res = /^[Cc]omment:(.*)$/.match(comment)
                   res[1]
                 else
                   RUN_ERROR_MARK  # these are run time errors
                 end
               end
               def extract_time(t)
                 puts "TIME: #{t}"
-            -   if (result=/^(.*)r(.*)u(.*)s(.*)m/.match(t))
+            +   if (result=/^(.*)r(.*)u(.*)s(.*)kbytes/.match(t))
                   {:real => result[1], :user => result[2], :sys => result[3], :mem => result[4]}
                 else
                   #{:real => 0, :user => 0, :sys => 0}
                   #puts "ERROR READING RUNNING TIME: #{t}"
                   raise "Error reading running time: #{t}"
                 end
               end
               problem_home = ENV['PROBLEM_HOME']
               require "#{problem_home}/script/test_dsl.rb"
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               if problem.well_formed? == false
                 log "The problem specification is not well formed."
                 exit(127)
               end
               all_score = 0
               all_comment = ''
               peak_memory = -1
               max_runtime = -1
               (1..(problem.runs.length-1)).each do |k|
                 log "grade run #{k}"
                 run = problem.runs[k]
                 run_score = nil
                 run_comment = ''
                 run_comment_short = ''
                 run.tests.each do |test_num|
                   result_file_name = "#{test_num}/result"
                   if not File.exists?(result_file_name)
                     run_comment += "result file for test #{test_num} not found\n"
                     run_comment_short += RUN_ERROR_MARK
                     log "Cannot find the file #{test_num}/result!"
                   else
                     result_file = File.new(result_file_name, "r")
                     result_file_lines = result_file.readlines
                     if result_file_lines.length>=3
                       current_run_score = result_file_lines[1].to_i
                       run_comment += result_file_lines[0]
                       run_comment_short += char_comment(result_file_lines[0].chomp)
                       #update max runtime & memory
                       run_stat = extract_time result_file_lines[2]
                       peak_memory = [peak_memory,run_stat[:mem].to_i].max
                       max_runtime = [max_runtime,run_stat[:user].to_f + run_stat[:sys].to_f].max
                     else
                       current_run_score = 0
                       run_comment += "result file for test #{test_num} error\n"
                       run_comment_short += RUN_ERROR_MARK
                       log "Error in #{test_num}/result!"
                     end
                     # the score of this run should be the minimum of the score for
                     #   each test case
                     if (run_score==nil) or (run_score>current_run_score)
                       run_score = current_run_score
                     end
                     result_file.close
                   end
                 end
                 run_result_file = File.new("result-#{k}", "w")
                 run_result_file.write run_score
                 run_result_file.write "\n"
                 run_result_file.close
                 run_comment_file = File.new("comment-#{k}", "w")
                 run_comment_file.write "#{run_comment}\n"
                 run_comment_file.close
                 all_score = all_score + run_score
                 # append comment for test run with many test cases
                 if run.tests.length > 1
                   run_comment_short = '[' + run_comment_short + ']'
                 end
                 all_comment += run_comment_short
               end
               result_file = File.new("result", "w")
               result_file.write all_score
               result_file.write "\n"
               result_file.close
               comment_file = File.new("comment", "w")
               comment_file.write "#{all_comment}\n"
               comment_file.close
               File.open("run_stat","w") do |file|
                 file.puts max_runtime
                 file.puts peak_memory
               end
               log "score = #{all_score}\ncomment = #{all_comment}"
               log "max_runtime = #{max_runtime}\npeak_memory = #{peak_memory}"

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

r164:447fdbbeac2c - Mon, 15 Sep 2014 15:54:56 - 3 files changed: 4 inserted, 4 deleted

Sign in to your account

Commit r164:447fdbbeac2c public

Author

r164:447fdbbeac2c - Mon, 15 Sep 2014 15:54:56 - 3 files changed: 4 inserted, 4 deleted

Commit `r164:447fdbbeac2c` public