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:
Raw Diff | Patch Diff | Download Diff | Show whitespace | Increase context
Comments:
0 Commit comments 0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
Side by Side Unified
Expand All Files Collapse All Files Wide Mode Diff
Add another comment
Browse Files

r164:447fdbbeac2c - - 3 files changed: 4 inserted, 4 deleted

Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -105,150 +105,150
105 105 end
106 106
107 107 def link_input_file(test_request, problem_home)
108 108 input_fname = "#{test_request.input_file_name}"
109 109 if !File.exists?(input_fname)
110 110 raise "Test Request: input file not found."
111 111 end
112 112
113 113 input_fname_problem_home = "#{problem_home}/test_cases/1/input-1.txt"
114 114 if File.exists?(input_fname_problem_home)
115 115 FileUtils.rm([input_fname_problem_home], :force => true)
116 116 end
117 117
118 118 Grader::link_or_copy("#{input_fname}", "#{input_fname_problem_home}")
119 119 end
120 120
121 121 def remove_data_files(problem_home)
122 122 if File.exists?("#{problem_home}/test_cases/1/input-1.txt")
123 123 Grader::call_and_log("Test Request: cannot remove data files") {
124 124 FileUtils.rm Dir.glob("#{problem_home}/test_cases/1/*")
125 125 }
126 126 end
127 127 end
128 128
129 129 end
130 130
131 131 class TestRequestReporter
132 132 def initialize
133 133 @config = Grader::Configuration.get_instance
134 134 end
135 135
136 136 def report(test_request,test_result_dir)
137 137 save_result(test_request,read_result(test_result_dir))
138 138 end
139 139
140 140 def report_error(test_request, msg)
141 141 save_result(test_request, {:running_stat => {
142 142 :msg => "#{msg}",
143 143 :running_time => nil,
144 144 :exit_status => "Some error occured. Program did not run",
145 145 :memory_usage => nil
146 146 }})
147 147 end
148 148
149 149 protected
150 150 def read_result(test_result_dir)
151 151 # TODO:
152 152 cmp_msg_fname = "#{test_result_dir}/compiler_message"
153 153 cmp_file = File.open(cmp_msg_fname)
154 154 cmp_msg = cmp_file.read
155 155 cmp_file.close
156 156
157 157 result_file_name = "#{test_result_dir}/1/result"
158 158
159 159 if File.exists?(result_file_name)
160 160 output_file_name = "#{test_result_dir}/1/output.txt"
161 161 results = []
162 162 File.open("#{test_result_dir}/1/result") do |f|
163 163 results = f.readlines
164 164 end
165 165 stat = extract_running_stat(results)
166 166
167 167 return {
168 168 :output_file_name => output_file_name,
169 169 :running_stat => stat,
170 170 :comment => "",
171 171 :cmp_msg => cmp_msg}
172 172 else
173 173 return {
174 174 :running_stat => nil,
175 175 :comment => "Compilation error",
176 176 :cmp_msg => cmp_msg}
177 177 end
178 178 end
179 179
180 180 def extract_running_stat(results)
181 181 running_stat_line = results[-1]
182 182
183 183 # extract exit status line
184 184 run_stat = ""
185 185 if !(/[Cc]orrect/.match(results[0]))
186 186 run_stat = results[0].chomp
187 187 else
188 188 run_stat = 'Program exited normally'
189 189 end
190 190
191 191 # extract running time
192 192 if res = /r(.*)u(.*)s/.match(running_stat_line)
193 193 seconds = (res[1].to_f + res[2].to_f)
194 194 time_stat = "Time used: #{seconds} sec."
195 195 else
196 196 seconds = nil
197 197 time_stat = "Time used: n/a sec."
198 198 end
199 199
200 200 # extract memory usage
201 - if res = /s(.*)m/.match(running_stat_line)
201 + if res = /s(.*)kbytes/.match(running_stat_line)
202 202 memory_used = res[1].to_i
203 203 else
204 204 memory_used = -1
205 205 end
206 206
207 207 return {
208 208 :msg => "#{run_stat}\n#{time_stat}",
209 209 :running_time => seconds,
210 210 :exit_status => run_stat,
211 211 :memory_usage => memory_used
212 212 }
213 213 end
214 214
215 215 def save_result(test_request,result)
216 216 if result[:output_file_name]!=nil
217 217 test_request.output_file_name = link_output_file(test_request,
218 218 result[:output_file_name])
219 219 end
220 220 test_request.graded_at = Time.now
221 221 test_request.compiler_message = (result[:cmp_msg] or '')
222 222 test_request.grader_comment = (result[:comment] or '')
223 223 if result[:running_stat]!=nil
224 224 test_request.running_stat = (result[:running_stat][:msg] or '')
225 225 test_request.running_time = (result[:running_stat][:running_time] or nil)
226 226 test_request.exit_status = result[:running_stat][:exit_status]
227 227 test_request.memory_usage = result[:running_stat][:memory_usage]
228 228 else
229 229 test_request.running_stat = ''
230 230 end
231 231 test_request.save
232 232 end
233 233
234 234 protected
235 235 def link_output_file(test_request, fname)
236 236 target_file_name = random_output_file_name(test_request.user,
237 237 test_request.problem)
238 238 FileUtils.mkdir_p(File.dirname(target_file_name))
239 239 Grader::link_or_copy("#{fname}", "#{target_file_name}")
240 240 return target_file_name
241 241 end
242 242
243 243 def random_output_file_name(user,problem)
244 244 problem_name = TestRequest.name_of(problem)
245 245 begin
246 246 tmpname = "#{@config.test_request_output_base_dir}" +
247 247 "/#{user.login}/#{problem_name}/#{rand(10000)}"
248 248 end while File.exists?(tmpname)
249 249 tmpname
250 250 end
251 251
252 252 end
253 253
254 254 end
Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -67,242 +67,242
67 67 #include <unistd.h>
68 68 #include <getopt.h>
69 69 #include <time.h>
70 70 #include <sys/wait.h>
71 71 #include <sys/user.h>
72 72 #include <sys/time.h>
73 73 #include <sys/ptrace.h>
74 74 #include <sys/signal.h>
75 75 #include <sys/sysinfo.h>
76 76 #include <sys/resource.h>
77 77 #include <sys/utsname.h>
78 78 //#include <linux/ptrace.h>
79 79
80 80 #if defined(CONFIG_BOX_KERNEL_AMD64) && !defined(CONFIG_BOX_USER_AMD64)
81 81 #include <asm/unistd_32.h>
82 82 #define NATIVE_NR_execve 59 /* 64-bit execve */
83 83 #else
84 84 #include <asm/unistd.h>
85 85 #define NATIVE_NR_execve __NR_execve
86 86 #endif
87 87
88 88 #define NONRET __attribute__((noreturn))
89 89 #define UNUSED __attribute__((unused))
90 90 #define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(a[0]))
91 91
92 92 static int filter_syscalls; /* 0=off, 1=liberal, 2=totalitarian */
93 93 static int timeout; /* milliseconds */
94 94 static int wall_timeout;
95 95 static int extra_timeout;
96 96 static int pass_environ;
97 97 static int file_access;
98 98 static int verbose;
99 99 static int memory_limit;
100 100 static int stack_limit;
101 101 static char *redir_stdin, *redir_stdout, *redir_stderr;
102 102 static char *set_cwd;
103 103
104 104 static pid_t box_pid;
105 105 static int is_ptraced;
106 106 static volatile int timer_tick;
107 107 static struct timeval start_time;
108 108 static int ticks_per_sec;
109 109 static int exec_seen;
110 110 static int partial_line;
111 111
112 112 static int mem_peak_kb;
113 113 static int total_ms, wall_ms, sys_ms;
114 114
115 115 static void die(char *msg, ...) NONRET;
116 116 static void sample_mem_peak(void);
117 117
118 118 /*** Meta-files ***/
119 119
120 120 static FILE *metafile;
121 121
122 122 static void
123 123 meta_open(const char *name)
124 124 {
125 125 if (!strcmp(name, "-"))
126 126 {
127 127 metafile = stdout;
128 128 return;
129 129 }
130 130 metafile = fopen(name, "w");
131 131 if (!metafile)
132 132 die("Failed to open metafile '%s'",name);
133 133 }
134 134
135 135 static void
136 136 meta_close(void)
137 137 {
138 138 if (metafile && metafile != stdout)
139 139 fclose(metafile);
140 140 }
141 141
142 142 static void __attribute__((format(printf,1,2)))
143 143 meta_printf(const char *fmt, ...)
144 144 {
145 145 if (!metafile)
146 146 return;
147 147
148 148 va_list args;
149 149 va_start(args, fmt);
150 150 vfprintf(metafile, fmt, args);
151 151 va_end(args);
152 152 }
153 153
154 154
155 155 static void print_running_stat(double wall_time,
156 156 double user_time,
157 157 double system_time,
158 158 int mem_usage)
159 159 {
160 160 //total is user
161 161 //wall is wall
162 162 //
163 - fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dm\n",
163 + fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dkbytes\n",
164 164 wall_time, user_time, system_time, mem_usage);
165 165 }
166 166
167 167 static void
168 168 final_stats(struct rusage *rus)
169 169 {
170 170 struct timeval total, now, wall;
171 171 timeradd(&rus->ru_utime, &rus->ru_stime, &total);
172 172 total_ms = total.tv_sec*1000 + total.tv_usec/1000;
173 173 gettimeofday(&now, NULL);
174 174 timersub(&now, &start_time, &wall);
175 175 wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
176 176 sys_ms = rus->ru_stime.tv_sec * 1000 + rus->ru_stime.tv_usec / 1000;
177 177
178 178 meta_printf("time:%d.%03d\n", total_ms/1000, total_ms%1000);
179 179 meta_printf("time-wall:%d.%03d\n", wall_ms/1000, wall_ms%1000);
180 180 meta_printf("mem:%llu\n", (unsigned long long) mem_peak_kb * 1024);
181 181 }
182 182
183 183 /*** Messages and exits ***/
184 184
185 185 static void NONRET
186 186 box_exit(int rc)
187 187 {
188 188 if (box_pid > 0)
189 189 {
190 190 sample_mem_peak();
191 191 if (is_ptraced)
192 192 ptrace(PTRACE_KILL, box_pid);
193 193 kill(-box_pid, SIGKILL);
194 194 kill(box_pid, SIGKILL);
195 195 meta_printf("killed:1\n");
196 196
197 197 struct rusage rus;
198 198 int p, stat;
199 199 do
200 200 p = wait4(box_pid, &stat, 0, &rus);
201 201 while (p < 0 && errno == EINTR);
202 202 if (p < 0)
203 203 fprintf(stderr, "UGH: Lost track of the process (%m)\n");
204 204 else {
205 205 final_stats(&rus);
206 206 }
207 207 }
208 208 print_running_stat(
209 209 (double)wall_ms/1000,
210 210 (double)total_ms/1000,
211 211 (double)sys_ms/1000,
212 - (mem_peak_kb + 1023) / 1024);
212 + mem_peak_kb);
213 213 meta_close();
214 214 exit(rc);
215 215 }
216 216
217 217 static void
218 218 flush_line(void)
219 219 {
220 220 if (partial_line)
221 221 fputc('\n', stderr);
222 222 partial_line = 0;
223 223 }
224 224
225 225 /* Report an error of the sandbox itself */
226 226 static void NONRET __attribute__((format(printf,1,2)))
227 227 die(char *msg, ...)
228 228 {
229 229 va_list args;
230 230 va_start(args, msg);
231 231 flush_line();
232 232 char buf[1024];
233 233 vsnprintf(buf, sizeof(buf), msg, args);
234 234 meta_printf("status:XX\nmessage:%s\n", buf);
235 235 fputs(buf, stderr);
236 236 fputc('\n', stderr);
237 237 box_exit(2);
238 238 }
239 239
240 240 /* Report an error of the program inside the sandbox */
241 241 static void NONRET __attribute__((format(printf,1,2)))
242 242 err(char *msg, ...)
243 243 {
244 244 va_list args;
245 245 va_start(args, msg);
246 246 flush_line();
247 247 if (msg[0] && msg[1] && msg[2] == ':' && msg[3] == ' ')
248 248 {
249 249 meta_printf("status:%c%c\n", msg[0], msg[1]);
250 250 msg += 4;
251 251 }
252 252 char buf[1024];
253 253 vsnprintf(buf, sizeof(buf), msg, args);
254 254 meta_printf("message:%s\n", buf);
255 255 fputs(buf, stderr);
256 256 fputc('\n', stderr);
257 257 box_exit(1);
258 258 }
259 259
260 260 /* Write a message, but only if in verbose mode */
261 261 static void __attribute__((format(printf,1,2)))
262 262 msg(char *msg, ...)
263 263 {
264 264 va_list args;
265 265 va_start(args, msg);
266 266 if (verbose)
267 267 {
268 268 int len = strlen(msg);
269 269 if (len > 0)
270 270 partial_line = (msg[len-1] != '\n');
271 271 vfprintf(stderr, msg, args);
272 272 fflush(stderr);
273 273 }
274 274 va_end(args);
275 275 }
276 276
277 277 static void *
278 278 xmalloc(size_t size)
279 279 {
280 280 void *p = malloc(size);
281 281 if (!p)
282 282 die("Out of memory");
283 283 return p;
284 284 }
285 285
286 286 /*** Syscall rules ***/
287 287
288 288 static const char * const syscall_names[] = {
289 289
290 290 /* Syscall table automatically generated by mk-syscall-table */
291 291
292 292 /* 0 */ [ __NR_read ] = "read",
293 293 /* 1 */ [ __NR_write ] = "write",
294 294 /* 2 */ [ __NR_open ] = "open",
295 295 /* 3 */ [ __NR_close ] = "close",
296 296 /* 4 */ [ __NR_stat ] = "stat",
297 297 /* 5 */ [ __NR_fstat ] = "fstat",
298 298 /* 6 */ [ __NR_lstat ] = "lstat",
299 299 /* 7 */ [ __NR_poll ] = "poll",
300 300 /* 8 */ [ __NR_lseek ] = "lseek",
301 301 /* 9 */ [ __NR_mmap ] = "mmap",
302 302 /* 10 */ [ __NR_mprotect ] = "mprotect",
303 303 /* 11 */ [ __NR_munmap ] = "munmap",
304 304 /* 12 */ [ __NR_brk ] = "brk",
305 305 /* 13 */ [ __NR_rt_sigaction ] = "rt_sigaction",
306 306 /* 14 */ [ __NR_rt_sigprocmask ] = "rt_sigprocmask",
307 307 /* 15 */ [ __NR_rt_sigreturn ] = "rt_sigreturn",
308 308 /* 16 */ [ __NR_ioctl ] = "ioctl",
Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -1,132 +1,132
1 1 #!/usr/bin/env ruby
2 2
3 3 CORRECT_MARK = 'P'
4 4 INCORRECT_MARK = '-'
5 5 TIMEOUT_MARK = 'T'
6 6 RUN_ERROR_MARK = 'x'
7 7
8 8 def log(str='')
9 9 if ENV['TALKATIVE']!=nil
10 10 puts str
11 11 end
12 12 if ENV['GRADER_LOGGING']!=nil
13 13 log_fname = ENV['GRADER_LOGGING']
14 14 fp = File.open(log_fname,"a")
15 15 fp.puts("grade: #{Time.new.strftime("%H:%M")} #{str}")
16 16 fp.close
17 17 end
18 18 end
19 19
20 20 def char_comment(comment)
21 21 if comment =~ /[Ii]ncorrect/
22 22 INCORRECT_MARK
23 23 elsif comment =~ /[Cc]orrect/
24 24 CORRECT_MARK
25 25 elsif comment =~ /[Tt]ime/
26 26 TIMEOUT_MARK
27 27 elsif res = /^[Cc]omment:(.*)$/.match(comment)
28 28 res[1]
29 29 else
30 30 RUN_ERROR_MARK # these are run time errors
31 31 end
32 32 end
33 33
34 34 def extract_time(t)
35 35 puts "TIME: #{t}"
36 - if (result=/^(.*)r(.*)u(.*)s(.*)m/.match(t))
36 + if (result=/^(.*)r(.*)u(.*)s(.*)kbytes/.match(t))
37 37 {:real => result[1], :user => result[2], :sys => result[3], :mem => result[4]}
38 38 else
39 39 #{:real => 0, :user => 0, :sys => 0}
40 40 #puts "ERROR READING RUNNING TIME: #{t}"
41 41 raise "Error reading running time: #{t}"
42 42 end
43 43 end
44 44
45 45 problem_home = ENV['PROBLEM_HOME']
46 46 require "#{problem_home}/script/test_dsl.rb"
47 47 load "#{problem_home}/test_cases/all_tests.cfg"
48 48 problem = Problem.get_instance
49 49
50 50 if problem.well_formed? == false
51 51 log "The problem specification is not well formed."
52 52 exit(127)
53 53 end
54 54
55 55 all_score = 0
56 56 all_comment = ''
57 57 peak_memory = -1
58 58 max_runtime = -1
59 59 (1..(problem.runs.length-1)).each do |k|
60 60 log "grade run #{k}"
61 61 run = problem.runs[k]
62 62 run_score = nil
63 63 run_comment = ''
64 64 run_comment_short = ''
65 65 run.tests.each do |test_num|
66 66 result_file_name = "#{test_num}/result"
67 67 if not File.exists?(result_file_name)
68 68 run_comment += "result file for test #{test_num} not found\n"
69 69 run_comment_short += RUN_ERROR_MARK
70 70 log "Cannot find the file #{test_num}/result!"
71 71 else
72 72 result_file = File.new(result_file_name, "r")
73 73 result_file_lines = result_file.readlines
74 74 if result_file_lines.length>=3
75 75 current_run_score = result_file_lines[1].to_i
76 76 run_comment += result_file_lines[0]
77 77 run_comment_short += char_comment(result_file_lines[0].chomp)
78 78
79 79 #update max runtime & memory
80 80 run_stat = extract_time result_file_lines[2]
81 81 peak_memory = [peak_memory,run_stat[:mem].to_i].max
82 82 max_runtime = [max_runtime,run_stat[:user].to_f + run_stat[:sys].to_f].max
83 83 else
84 84 current_run_score = 0
85 85 run_comment += "result file for test #{test_num} error\n"
86 86 run_comment_short += RUN_ERROR_MARK
87 87 log "Error in #{test_num}/result!"
88 88 end
89 89
90 90 # the score of this run should be the minimum of the score for
91 91 # each test case
92 92 if (run_score==nil) or (run_score>current_run_score)
93 93 run_score = current_run_score
94 94 end
95 95 result_file.close
96 96 end
97 97 end
98 98
99 99 run_result_file = File.new("result-#{k}", "w")
100 100 run_result_file.write run_score
101 101 run_result_file.write "\n"
102 102 run_result_file.close
103 103
104 104 run_comment_file = File.new("comment-#{k}", "w")
105 105 run_comment_file.write "#{run_comment}\n"
106 106 run_comment_file.close
107 107
108 108 all_score = all_score + run_score
109 109
110 110 # append comment for test run with many test cases
111 111 if run.tests.length > 1
112 112 run_comment_short = '[' + run_comment_short + ']'
113 113 end
114 114 all_comment += run_comment_short
115 115 end
116 116
117 117 result_file = File.new("result", "w")
118 118 result_file.write all_score
119 119 result_file.write "\n"
120 120 result_file.close
121 121
122 122 comment_file = File.new("comment", "w")
123 123 comment_file.write "#{all_comment}\n"
124 124 comment_file.close
125 125
126 126
127 127 File.open("run_stat","w") do |file|
128 128 file.puts max_runtime
129 129 file.puts peak_memory
130 130 end
131 131
132 132 log "score = #{all_score}\ncomment = #{all_comment}"
You need to be logged in to leave comments. Login now