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

                     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

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

               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 */

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

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