cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r173:aa6e7ff3942c` public

parent | child

Description:

merge from algo-bm

Commit status:

[Not Reviewed]

References:

merge java

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r173:aa6e7ff3942c - Sun, 28 Sep 2014 02:42:25 - 9 files changed: 124 inserted, 34 deleted

grader ¶ +18 -2

               #!/usr/bin/env ruby
               def stop_grader(id)
                 if id==:all
                   File.open(File.dirname(__FILE__) + "/stop.all",'w').close
                 else
                   File.open(File.dirname(__FILE__) + "/stop.#{id}",'w').close
                 end
               end
               def check_stopfile
                 FileTest.exist?(File.dirname(__FILE__) + "/stop.all") or
                   FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
               end
               def clear_stopfile
                 if FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
                   File.delete(File.dirname(__FILE__) + "/stop.#{Process.pid}")
                 end
               end
               def config
                 Grader::Configuration.get_instance
               end
               def log_file_name
                 if !File.exists?(config.log_dir)
                   raise "Log directory does not exist: #{config.log_dir}"
                 end
                 config.log_dir +
                   "/#{GRADER_ENV}_#{config.grader_mode}.#{Process.pid}"
               end
               def log(str)
                 if config.talkative
                   puts str
                 end
                 if config.logging
                   fp = File.open(log_file_name,"a")
                   fp.puts("GRADER: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               def display_manual
                 puts <<USAGE
               Grader.
               using: (1) grader
-            -        (2) grader environment [mode]
+            +        (2) grader environment [mode] [options]
                      (3) grader stop [all|pids-list]
                      (4) grader --help
               (1) call grader with environment = 'exam', mode = 'queue'
               (2) possible modes are: 'queue', 'test_request', 'prob', 'sub', 'contest', and 'autonew'
+            +   queue: repeatedly check the task queue and grade any available tasks
+            +
+            +   prob:  re-grade every user latest submission of the specific problem.
+            +          the problem name must be specified by the next argument.
+            +
+            +          additional options:
+            +
+            +             --all-sub    re-grade every submissions instead of just the latest submission of each user.
+            +   sub:   re-grader the specified submission.
+            +          The submission ID to be re-graded must be specified by the next argument.
+            +
               (3) create stop-file to stop running grader in queue mode
               (4) You are here.
               USAGE
               end
               def process_options_and_stop_file
                 # The list of options are:
                 #   - stop [all|process ids]
                 #   -
                 # Process 'help' option
                 if (ARGV.length==1) and (/help/.match(ARGV[0]))
                   display_manual
                   exit(0)
                 end
                 # Process 'stop' option.
                 if (ARGV.length >= 1) and (ARGV[0]=='stop')
                   if ARGV.length==1
                     puts "you should specify pid-list or 'all'"
                     display_manual
                   elsif (ARGV.length==2) and (ARGV[1]=='all')
                     stop_grader(:all)
                     puts "A global stop file ('stop.all') created."
                     puts "You should remove it manually later."
                   else
                     (1..ARGV.length-1).each do |i|
                       stop_grader(ARGV[i])
                     end
                     puts "stop file(s) created"
                   end
                   exit(0)
                 end
                 # Check stop file.
                 if check_stopfile
                   puts "Stop file exists.  Terminated."
                   clear_stopfile
                   exit(0)
                 end
                 #default options
                 options = {
                   :mode => 'queue',
                   :environment => 'exam',
                   :dry_run => false,
                 }
                 # Process mode and environment option
                 if ARGV.length >= 1
                   options[:environment] = ARGV.shift
                   if ARGV.length >=1
                     options[:mode] = ARGV.shift
                   end
+            +   else
+            +     puts 'no argument specified, using default mode and environment.'
                 end
                 options[:dry_run] = (ARGV.delete('--dry') != nil)
                 if options[:dry_run] and (not ['prob','contest','autonew'].include? options[:mode])
                   puts "Dry run currently works only for 'prob' or 'contest' modes."
                   exit(0)
                 end
                 options[:report] = (ARGV.delete('--report') != nil)
                 if options[:report] and (not ['prob','contest','autonew'].include? options[:mode])
                   puts "Report currently works only for 'prob' or 'contest' modes."
                   exit(0)
                 end
+            +   options[:all_sub] = (ARGV.delete('--all-sub') != nil)
+            +
                 return options
               end
               class ResultCollector
                 def initialize
                   @results = {}
                   @problems = {}
                   @users = {}
                 end
                 def after_save_hook(submission, grading_result)
                 end
                 def save(submission, grading_result)
                   user = submission.user
                   problem = submission.problem
                   if not @problems.has_key? problem.id
                     @problems[problem.id] = problem
                   end
                   if not @users.has_key? user.id
                     @users[user.id] = user
                   end
                   @results[[user.id, problem.id]] = grading_result
                   after_save_hook(submission, grading_result)
                 end
                 def print_report_by_user
                   puts "---------------------"
                   puts "       REPORT"
                   puts "---------------------"
                   print "login,email"
                   @problems.each_value do |problem|
                     print ",#{problem.name}"
                   end
                   print "\n"
                   @users.each_value do |user|
                     print "#{user.login},#{user.email}"
                     @problems.each_value do |problem|
                       if @results.has_key? [user.id, problem.id]
                         print ",#{@results[[user.id,problem.id]][:points]}"
                       else
                         print ","
                       end
                     end
                     print "\n"
                   end
                 end
               end
               def grader_general_loop(engine, grader_proc, options)
                 runner = Grader::Runner.new(engine, grader_proc)
                 while true
                   if check_stopfile    # created by calling grader stop
                     clear_stopfile
                     log "stopped (with stop file)"
                     break
                   end
                   task = yield(runner)
                   if task==nil
                     sleep(1)
                   end
                 end
               end
               def grader_queue_loop(grader_proc, options)
                 log "Grader: queue"
                 engine = Grader::Engine.new
                 grader_general_loop(engine, grader_proc, options) do |runner|
                   runner.grade_oldest_task
                 end
               end
               def grader_test_request_loop(grader_proc, options)
                 log "Grader: test_request"
                 engine = Grader::Engine.new(:room_maker => Grader::TestRequestRoomMaker.new,
                                             :reporter => Grader::TestRequestReporter.new)
                 grader_general_loop(engine, grader_proc, options) do |runner|
                   runner.grade_oldest_test_request
                 end
               end
               def grader_autonew_loop(grader_proc, options)
                 log "Grader: autonew"
                 if options[:report]
                   result_collector = ResultCollector.new
                 else
                   result_collector = nil
                 end
                 if options[:dry_run]
                   puts "Running in dry mode"
                 end
                 prob_reporter = Grader::SubmissionReporter.new(:dry_run => options[:dry_run],
                                                                :result_collector => result_collector)
                 engine = Grader::Engine.new(:reporter => prob_reporter)
                 runner = Grader::Runner.new(engine, grader_proc)
                 grader_proc.report_active if grader_proc!=nil
                 latest_submitted_at = nil
                 graded_submission_ids = {}
                 while true
                   if check_stopfile    # created by calling grader stop
                     clear_stopfile
                     log "stopped (with stop file)"
                     break
                   end
                   if latest_submitted_at==nil
                     submissions = Submission.all
                   else
                     submissions = Submission.all(:conditions => ["submitted_at >= :latest",
                                                                  {:latest => latest_submitted_at}])
                   end
                   graded_any = false
                   if submissions.length != 0
                     submissions.each do |submission|
                       if (submission.problem == nil) or (!submission.problem.available)
                         next
                       end
                       if ! graded_submission_ids[submission.id]
                         runner.grade_submission(submission)
                         graded_submission_ids[submission.id] = true
                         if (!latest_submitted_at or
                             latest_submitted_at < submission.submitted_at)
                           latest_submitted_at = submission.submitted_at
                         end
                         puts "graded: #{submission.id}"
                         puts "latest: #{latest_submitted_at}"
                         graded_any = true
                       end
                     end
                   end
                   if ! graded_any
                     sleep(1)
                   end
                 end
               end
               def grader_grade_problems(grader_proc, options)
                 if options[:report]
                   result_collector = ResultCollector.new
                 else
                   result_collector = nil
                 end
                 if options[:dry_run]
                   puts "Running in dry mode"
                 end
                 prob_reporter = Grader::SubmissionReporter.new(:dry_run => options[:dry_run],
                                                                :result_collector => result_collector)
                 engine = Grader::Engine.new(:reporter => prob_reporter)
                 runner = Grader::Runner.new(engine, grader_proc)
                 grader_proc.report_active if grader_proc!=nil
                 ARGV.each do |prob_name|
                   prob = Problem.find_by_name(prob_name)
                   if prob==nil
                     puts "cannot find problem: #{prob_name}"
                   else
-            -       runner.grade_problem(prob)
+            +       runner.grade_problem(prob,options)
                   end
                 end
                 if options[:report]
                   result_collector.print_report_by_user
                 end
               end
               def grader_grade_contests(grader_proc, options)
                 # always use dry run when grading during contest
                 dry_run = options[:dry_run] = true
                 contest_name = ARGV.shift
                 contest = Contest.find_by_name(contest_name)
                 if contest==nil
                   puts "cannot find contest: #{contest_name}"
                   exit(0)
                 end
                 if options[:report]
                   result_collector = ResultCollector.new
                 else
                   result_collector = nil
                 end
                 if options[:dry_run]
                   puts "Running in dry mode"
                 end
                 prob_reporter = Grader::SubmissionReporter.new(:dry_run => dry_run,
                                                                :result_collector => result_collector)
                 engine = Grader::Engine.new(:reporter => prob_reporter)
                 runner = Grader::Runner.new(engine, grader_proc)
                 grader_proc.report_active if grader_proc!=nil
                 contest.problems.each do |problem|
                   puts "Grading: #{problem.name}"
                   runner.grade_problem(problem,
                                        :user_conditions => lambda do |u|
                                          u.contest_finished? and
                                            u.contest_ids.include?(contest.id)
                                        end)
                 end
                 if options[:report]
                   result_collector.print_report_by_user
                 end
               end
               def grader_grade_submissions(grader_proc, options)
                 engine = Grader::Engine.new
                 runner = Grader::Runner.new(engine, grader_proc)
                 grader_proc.report_active if grader_proc!=nil
                 ARGV.each do |sub_id|
                   puts "Grading #{sub_id}"
                   begin
                     submission = Submission.find(sub_id.to_i)
                   rescue ActiveRecord::RecordNotFound
                     puts "Submission #{sub_id} not found"
                     submission = nil
                   end
                   if submission!=nil
                     runner.grade_submission(submission)
                   end
                 end
               end
               #########################################
               # main program
               #########################################
               options = process_options_and_stop_file
               GRADER_ENV = options[:environment]
               grader_mode = options[:mode]
               dry_run = options[:dry_run]
               puts "environment: #{GRADER_ENV}"
+            + puts "grader mode: #{grader_mode}"
               require File.join(File.dirname(__FILE__),'config/environment')
               # add grader_mode to config
               # this is needed because method log needs it.  TODO: clean this up
               class << config
                 attr_accessor :grader_mode
               end
               config.grader_mode = grader_mode
               # reading rails environment
               log 'Reading rails environment'
               RAILS_ENV = config.rails_env
               require RAILS_ROOT + '/config/environment'
               # register grader process
               if config.report_grader
                 grader_proc = GraderProcess.register(config.grader_hostname,
                                                      Process.pid,
                                                      grader_mode)
               else
                 grader_proc = nil
               end
               #set loggin environment
               ENV['GRADER_LOGGING'] = log_file_name
               # register exit handler to report inactive, and terminated
               at_exit do
                 if grader_proc!=nil
                   grader_proc.report_inactive
                   grader_proc.terminate
                 end
               end
               #
               # MAIN LOOP
               #
               case grader_mode
               when "queue"
                 grader_queue_loop(grader_proc, options)
               when "test_request"
                 grader_test_request_loop(grader_proc, options)
               when "prob"
                 grader_grade_problems(grader_proc, options)
               when "contest"
                 grader_grade_contests(grader_proc, options)
               when "sub"
                 grader_grade_submissions(grader_proc, options)
               when "autonew"
                 grader_autonew_loop(grader_proc, options)
               else
                 display_manual
                 exit(0)
               end

lib/runner.rb ¶ +10 -5

               #
               # A runner drives the engine into various tasks.
               #
               module Grader
                 class Runner
                   def initialize(engine, grader_process=nil)
                     @engine = engine
                     @grader_process = grader_process
                   end
                   def grade_oldest_task
                     task = Task.get_inqueue_and_change_status(Task::STATUS_GRADING)
                     if task!=nil
                       @grader_process.report_active(task) if @grader_process!=nil
                       submission = Submission.find(task.submission_id)
                       @engine.grade(submission)
                       task.status_complete!
                       @grader_process.report_inactive(task) if @grader_process!=nil
                     end
                     return task
                   end
                   def grade_problem(problem, options={})
-            -       users = User.find(:all)
-            -       users.each do |u|
+            +       User.find_each do |u|
                       puts "user: #{u.login}"
                       if options[:user_conditions]!=nil
                         con_proc = options[:user_conditions]
                         next if not con_proc.call(u)
                       end
-            -         last_sub = Submission.find_last_by_user_and_problem(u.id,problem.id)
-            -         if last_sub!=nil
-            -           @engine.grade(last_sub)
+            +         if options[:all_sub]
+            +           Submission.where(user_id: u.id,problem_id: problem.id).find_each do |sub|
+            +             @engine.grade(sub)
+            +           end
+            +         else
+            +           last_sub = Submission.find_last_by_user_and_problem(u.id,problem.id)
+            +           if last_sub!=nil
+            +             @engine.grade(last_sub)
+            +           end
                       end
                     end
                   end
                   def grade_submission(submission)
                     puts "Submission: #{submission.id} by #{submission.user.full_name}"
                     @engine.grade(submission)
                   end
                   def grade_oldest_test_request
                     test_request = TestRequest.get_inqueue_and_change_status(Task::STATUS_GRADING)
                     if test_request!=nil
                       @grader_process.report_active(test_request) if @grader_process!=nil
                       @engine.grade(test_request)
                       test_request.status_complete!
                       @grader_process.report_inactive(test_request) if @grader_process!=nil
                     end
                     return test_request
                   end
                 end
               end

lib/submission_helper.rb ¶ +22 -4

               module Grader
                 class SubmissionRoomMaker
                   def initialize
                     @config = Grader::Configuration.get_instance
                   end
                   def produce_grading_room(submission)
                     user = submission.user
                     problem = submission.problem
                     grading_room = "#{@config.user_result_dir}/" +
                       "#{user.login}/#{problem.name}/#{submission.id}"
                     FileUtils.mkdir_p(grading_room)
                     grading_room
                   end
                   def find_problem_home(submission)
                     problem = submission.problem
                     "#{@config.problems_dir}/#{problem.name}"
                   end
                   def save_source(submission,source_name)
                     dir = self.produce_grading_room(submission)
                     f = File.open("#{dir}/#{source_name}","w")
                     f.write(submission.source)
                     f.close
                   end
                   def clean_up(submission)
                   end
                 end
                 class SubmissionReporter
                   def initialize(options={})
                     options = {:dry_run => false, :result_collector => nil}.merge(options)
                     @config = Grader::Configuration.get_instance
                     @dry_run = options[:dry_run]
                     @result_collector = options[:result_collector]
                   end
                   def report(sub,test_result_dir)
                     result = read_result(test_result_dir)
                     if @result_collector
                       @result_collector.save(sub,
                                              result)
                     end
                     save_result(sub,result)
                   end
                   def report_error(sub,msg)
                     save_result(sub,{:points => 0,
                                   :comment => "Grading error: #{msg}" })
                   end
                   protected
                   def read_result(test_result_dir)
                     cmp_msg_fname = "#{test_result_dir}/compiler_message"
                     if FileTest.exist?(cmp_msg_fname)
                       cmp_file = File.open(cmp_msg_fname)
                       cmp_msg = cmp_file.read
                       cmp_file.close
                     else
                       cmp_msg = ""
                     end
                     result_fname = "#{test_result_dir}/result"
-            -       comment_fname = "#{test_result_dir}/comment"
+            +       comment_fname = "#{test_result_dir}/comment"
+            +       runstat_fname = "#{test_result_dir}/run_stat"
                     if FileTest.exist?(result_fname)
                       comment = ""
                       begin
                         result_file = File.open(result_fname)
                         result = result_file.readline.to_i
                         result_file.close
                       rescue
                         result = 0
                         comment = "error reading result file."
                       end
                       begin
                         comment_file = File.open(comment_fname)
                         comment += comment_file.readline.chomp
                         comment_file.close
                       rescue
                         comment += ""
                       end
-            -         return {:points => result,
-            -           :comment => comment,
-            -           :cmp_msg => cmp_msg}
+            +         begin
+            +           runstat_file = File.open(runstat_fname)
+            +           max_runtime = runstat_file.readline.to_f
+            +           peak_memory = runstat_file.readline.to_i
+            +         rescue
+            +           max_runtime = -1
+            +           peak_memory = -1
+            +         end
+            +
+            +
+            +         return {points: result,
+            +           comment: comment,
+            +           cmp_msg: cmp_msg,
+            +           max_runtime: max_runtime,
+            +           peak_memory: peak_memory
+            +         }
                     else
                       if FileTest.exist?("#{test_result_dir}/a.out")
                         return {:points => 0,
                           :comment => 'error during grading',
                           :cmp_msg => cmp_msg}
                       else
                         return {:points => 0,
                           :comment => 'compilation error',
                           :cmp_msg => cmp_msg}
                       end
                     end
                   end
                   def save_result(submission,result)
                     problem = submission.problem
                     submission.graded_at = Time.now.gmtime
                     points = result[:points]
                     submission.points = points
                     comment = @config.report_comment(result[:comment])
+            +       submission.peak_memory = result[:peak_memory]
+            +       submission.max_runtime =  result[:max_runtime]
+            +       submission.effective_code_length =submission.source.length
+            +
                     #
                     # TODO: FIX THIS MESSAGE
                     #
                     if problem == nil
                       submission.grader_comment = 'PASSED: ' + comment + '(problem is nil)'
                     elsif points == problem.full_score
                       #submission.grader_comment = 'PASSED: ' + comment
                       submission.grader_comment = comment
                     elsif result[:comment].chomp =~ /^[\[\]P]+$/
                       submission.grader_comment = 'PASSED: ' + comment + '(inconsistent score)'
                     else
                       #submission.grader_comment = 'FAILED: ' + comment
                       submission.grader_comment = comment
                     end
                     submission.compiler_message = result[:cmp_msg] or ''
                     if not @dry_run
                       submission.save
                     end
                   end
                 end
               end

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

               /*
                *	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",
               }
               static void
               signal_alarm(int unused UNUSED)
               {
                 /* Time limit checks are synchronous, so we only schedule them there. */
                 timer_tick = 1;
                 alarm(1);
               }
               static void
               signal_int(int unused UNUSED)
               {
                 /* Interrupts are fatal, so no synchronization requirements. */
                 meta_printf("exitsig:%d\n", SIGINT);
                 err("SG: Interrupted");
               }
               #define PROC_BUF_SIZE 4096
               static void
               read_proc_file(char *buf, char *name, int *fdp)
               {
                 int c;
                 if (!*fdp)
                   {
                     sprintf(buf, "/proc/%d/%s", (int) box_pid, name);
                     *fdp = open(buf, O_RDONLY);
                     if (*fdp < 0)
               	die("open(%s): %m", buf);
                   }
                 lseek(*fdp, 0, SEEK_SET);
                 if ((c = read(*fdp, buf, PROC_BUF_SIZE-1)) < 0)
                   die("read on /proc/$pid/%s: %m", name);
                 if (c >= PROC_BUF_SIZE-1)
                   die("/proc/$pid/%s too long", name);
                 buf[c] = 0;
               }
               static void
               check_timeout(void)
               {
                 if (wall_timeout)
                   {
                     struct timeval now, wall;
                     int wall_ms;
                     gettimeofday(&now, NULL);
                     timersub(&now, &start_time, &wall);
                     wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
                     if (wall_ms > wall_timeout)
                       err("TO: Time limit exceeded (wall clock)");
                     if (verbose > 1)
                       fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
                   }
                 if (timeout)
                   {
                     char buf[PROC_BUF_SIZE], *x;
                     int utime, stime, ms;
                     static int proc_stat_fd;
                     read_proc_file(buf, "stat", &proc_stat_fd);
                     x = buf;
                     while (*x && *x != ' ')
               	x++;
                     while (*x == ' ')
               	x++;
                     if (*x++ != '(')
               	die("proc stat 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 stat syntax error 2");
                     ms = (utime + stime) * 1000 / ticks_per_sec;
                     if (verbose > 1)
               	fprintf(stderr, "[time check: %d msec]\n", ms);
                     if (ms > timeout && ms > extra_timeout)
               	err("TO: Time limit exceeded");
                   }
               }
               static void
               sample_mem_peak(void)
               {
                 /*
                  *  We want to find out the peak memory usage of the process, which is
                  *  maintained by the kernel, but unforunately it gets lost when the
                  *  process exits (it is not reported in struct rusage). Therefore we
                  *  have to sample it whenever we suspect that the process is about
                  *  to exit.
                  */
                 char buf[PROC_BUF_SIZE], *x;
                 static int proc_status_fd;
                 read_proc_file(buf, "status", &proc_status_fd);
                 x = buf;
                 while (*x)
                   {
                     char *key = x;
                     while (*x && *x != ':' && *x != '\n')
               	x++;
                     if (!*x || *x == '\n')
               	break;
                     *x++ = 0;
                     while (*x == ' ' || *x == '\t')
               	x++;
                     char *val = x;
                     while (*x && *x != '\n')
               	x++;
                     if (!*x)
               	break;
                     *x++ = 0;
                     if (!strcmp(key, "VmPeak"))
               	{
               	  int peak = atoi(val);
               	  if (peak > mem_peak_kb)
               	    mem_peak_kb = peak;
               	}
                   }
                 if (verbose > 1)
                   msg("[mem-peak: %u KB]\n", mem_peak_kb);
               }
               static void
               boxkeeper(void)
               {
                 int syscall_count = (filter_syscalls ? 0 : 1);
                 struct sigaction sa;
                 is_ptraced = 1;
                 bzero(&sa, sizeof(sa));
                 sa.sa_handler = signal_int;
                 sigaction(SIGINT, &sa, NULL);
                 gettimeofday(&start_time, NULL);
                 ticks_per_sec = sysconf(_SC_CLK_TCK);
                 if (ticks_per_sec <= 0)
                   die("Invalid ticks_per_sec!");
                 if (timeout || wall_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();
               	  timer_tick = 0;
               	}
                     p = wait4(box_pid, &stat, WUNTRACED, &rus);
                     if (p < 0)
               	{
               	  if (errno == EINTR)
               	    continue;
               	  die("wait4: %m");
               	}
                     if (p != box_pid)
               	die("wait4: unknown pid %d exited!", p);
                     if (WIFEXITED(stat))
               	{
               	  box_pid = 0;
               	  final_stats(&rus);
               	  if (WEXITSTATUS(stat))
               	    {
               	      if (syscall_count)
               		{
               		  meta_printf("exitcode:%d\n", WEXITSTATUS(stat));
               		  err("RE: Exited with error status %d", WEXITSTATUS(stat));
               		}
               	      else
               		{
               		  // Internal error happened inside the child process and it has been already reported.
               		  box_exit(2);
               		}
               	    }
               	  if (timeout && total_ms > timeout)
               	    err("TO: Time limit exceeded");
               	  if (wall_timeout && wall_ms > wall_timeout)
               	    err("TO: Time limit exceeded (wall clock)");
               	  flush_line();
                   fprintf(stderr,"OK\n");
-            -         print_running_stat(
-            -               (double)wall_ms/1000,
-            -               (double)total_ms/1000,
-            -               (double)sys_ms/1000,
-            -               (mem_peak_kb + 1023) / 1024);
               	  box_exit(0);
               	}
                     if (WIFSIGNALED(stat))
               	{
               	  box_pid = 0;
               	  meta_printf("exitsig:%d\n", WTERMSIG(stat));
               	  final_stats(&rus);
               	  err("SG: Caught fatal signal %d%s", WTERMSIG(stat), (syscall_count ? "" : " during startup"));
               	}
                     if (WIFSTOPPED(stat))
               	{
               	  int sig = WSTOPSIG(stat);
               	  if (sig == SIGTRAP)
               	    {
               	      if (verbose > 2)
               		msg("[ptrace status %08x] ", stat);
               	      static int stop_count;
               	      if (!stop_count++)		/* Traceme request */
               		msg(">> Traceme request caught\n");
               	      else
               		err("SG: Breakpoint");
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
               	    }
               	  else if (sig == (SIGTRAP | 0x80))
               	    {
               	      if (verbose > 2)
               		msg("[ptrace status %08x] ", stat);
               	      struct syscall_args a;
               	      static unsigned int sys_tick, last_act;
               	      static arg_t last_sys;
               	      if (++sys_tick & 1)		/* Syscall entry */
               		{
               		  char namebuf[32];
               		  int act;
               		  get_syscall_args(&a, 0);
               		  arg_t sys = a.sys;
               		  msg(">> Syscall %-12s (%08jx,%08jx,%08jx) ", syscall_name(sys, namebuf), (intmax_t) a.arg1, (intmax_t) a.arg2, (intmax_t) a.arg3);
               		  if (!exec_seen)
               		    {
               		      msg("[master] ");
               		      if (sys == NATIVE_NR_execve)
               			{
               			  exec_seen = 1;
               			  close_user_mem();
               			}
               		    }
               		  else if ((act = valid_syscall(&a)) >= 0)
               		    {
               		      last_act = act;
               		      syscall_count++;
               		      if (act & A_SAMPLE_MEM)
               			sample_mem_peak();
               		    }
               		  else
               		    {
               		      /*
               		       * 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.
               		       */
               		      set_syscall_nr(&a, ~(arg_t)0);
               		      err("FO: Forbidden syscall %s", syscall_name(sys, namebuf));
               		    }
               		  last_sys = sys;
               		}
               	      else					/* Syscall return */
               		{
               		  get_syscall_args(&a, 1);
               		  if (a.sys == ~(arg_t)0)
               		    {
               		      /* Some syscalls (sigreturn et al.) do not return a value */
               		      if (!(last_act & A_NO_RETVAL))
               			err("XX: Syscall does not return, but it should");
               		    }
               		  else
               		    {
               		      if (a.sys != last_sys)
               			err("XX: Mismatched syscall entry/exit");
               		    }
               		  if (last_act & A_NO_RETVAL)
               		    msg("= ?\n");
               		  else
               		    msg("= %jd\n", (intmax_t) a.result);
               		}
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
               	    }
               	  else if (sig == SIGSTOP)
               	    {
               	      msg(">> SIGSTOP\n");
               	      if (ptrace(PTRACE_SETOPTIONS, box_pid, NULL, (void *) PTRACE_O_TRACESYSGOOD) < 0)
               		die("ptrace(PTRACE_SETOPTIONS): %m");
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
               	    }
               	  else if (sig != SIGXCPU && sig != SIGXFSZ)
               	    {
               	      msg(">> Signal %d\n", sig);
               	      sample_mem_peak();			/* Signal might be fatal, so update mem-peak */
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, sig);
               	    }
               	  else
               	    {
               	      meta_printf("exitsig:%d", sig);
               	      err("SG: 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];
                 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);
                   }
                 if (redir_stderr)
                   {
                     close(2);
                     if (open(redir_stderr, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 2)
               	die("open(\"%s\"): %m", redir_stderr);
                   }
                 else
                   dup2(1, 2);
                 setpgrp();
                 if (memory_limit)
                   {
                     rl.rlim_cur = rl.rlim_max = memory_limit * 1024;
                     if (setrlimit(RLIMIT_AS, &rl) < 0)
               	die("setrlimit(RLIMIT_AS): %m");
                   }
                 rl.rlim_cur = rl.rlim_max = (stack_limit ? (rlim_t)stack_limit * 1024 : RLIM_INFINITY);
                 if (setrlimit(RLIMIT_STACK, &rl) < 0)
                   die("setrlimit(RLIMIT_STACK): %m");
                 rl.rlim_cur = rl.rlim_max = 64;
                 if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
                   die("setrlimit(RLIMIT_NOFILE): %m");
                 char **env = setup_environment();
                 if (filter_syscalls)
                   {
                     if (ptrace(PTRACE_TRACEME) < 0)
               	die("ptrace(PTRACE_TRACEME): %m");
                     /* Trick: Make sure that we are stopped until the boxkeeper wakes up. */
                     raise(SIGSTOP);
                   }
                 execve(args[0], args, 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\tInherit full environment of the parent process\n\
               -E <var>\tInherit the environment variable <var> from the parent process\n\
               -E <var>=<val>\tSet the environment variable <var> to <val>; unset it if <var> is empty\n\
               -f\t\tFilter system calls (-ff=very restricted)\n\
               -i <file>\tRedirect stdin from <file>\n\
               -k <size>\tLimit stack size to <size> KB (default: 0=unlimited)\n\
               -m <size>\tLimit address space to <size> KB\n\
               -M <file>\tOutput process information to <file> (name:value)\n\
               -o <file>\tRedirect stdout to <file>\n\
               -p <path>\tPermit access to the specified path (or subtree if it ends with a `/')\n\
               -p <path>=<act>\tDefine action for the specified path (<act>=yes/no)\n\
               -r <file>\tRedirect stderr to <file>\n\

std-script/compile ¶ +25 -3

               #!/usr/bin/env ruby
               require 'fileutils'
               ##############################
               #
               # Standard Compile Script
               #
               # Supported compilers:
               #   gcc, g++, and fpc.
               #
               ##############################
               def talk(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("run: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               C_COMPILER = "/usr/bin/gcc"
               CPLUSPLUS_COMPILER = "/usr/bin/g++"
               PASCAL_COMPILER = "/usr/bin/fpc"
               JAVA_COMPILER = "/usr/bin/javac"
               RUBY_INTERPRETER = "/usr/bin/ruby"
               PYTHON_INTERPRETER = "/usr/bin/python"
               PYTHON_CHECKER = "/usr/bin/pyflakes"
+            + PHP_INTERPRETER = "/usr/bin/php"
               C_OPTIONS = "-O2 -s -static -std=c99 -DCONTEST -lm -Wall"
-            - CPLUSPLUS_OPTIONS = "-O2 -s -static -DCONTEST -lm -Wall"
+            + CPLUSPLUS_OPTIONS = "-O2 -s -std=c++11 -static -DCONTEST -lm -Wall"
               PASCAL_OPTIONS = "-O1 -XS -dCONTEST"
               JAVA_OPTIONS = ""
               PYTHON_OPTIONS = ""
+            + PHP_OPTIONS = "-l"
               # Check for the correct number of arguments. Otherwise, print usage.
               if ARGV.length == 0 or ARGV.length > 4
                 puts "Usage: compile <language> [<source-file>] [<output-file>] [<message-file>]"
                 puts
                 puts "<source-file>  is defaulted to \"source\"."
                 puts "<output-file>  is defaulted to \"a.out\"."
                 puts "<message-file> is defaulted to \"compiler_message\"."
                 puts
                 exit(127)
               end
               PARAMS = {
                 :source_file => [1,'source'],
                 :output_file => [2,'a.out'],
                 :message_file => [3,'compiler_message']
               }
               params = {}
               params[:prog_lang] = ARGV[0]
               PARAMS.each_key do |param_name|
                 index, default = PARAMS[param_name]
                 if ARGV.length > index
                   params[param_name] = ARGV[index]
                 else
                   params[param_name] = default
                 end
                 talk "#{param_name}: #{params[param_name]}"
               end
               # Remove any remaining output files or message files.
               if FileTest.exists? params[:output_file]
                 FileUtils.rm(params[:output_file])
               end
               if FileTest.exists? params[:message_file]
                 FileUtils.rm(params[:message_file])
               end
               # Check if the source file exists before attempt compiling.
               if !FileTest.exists? params[:source_file]
                 talk("ERROR: The source file does not exist!")
                 open(params[:message_file],"w") do |f|
                   f.puts "ERROR: The source file did not exist."
                 end
                 exit(127)
               end
               if params[:prog_lang]=='cpp'
                 params[:prog_lang] = 'c++'
               end
               # Compile.
               case params[:prog_lang]
               when "c"
                 command = "#{C_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{C_OPTIONS} 2> #{params[:message_file]}"
                 system(command)
               when "c++"
                 command = "#{CPLUSPLUS_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{CPLUSPLUS_OPTIONS} 2> #{params[:message_file]}"
                 system(command)
               when "pas"
                 command = "#{PASCAL_COMPILER} #{params[:source_file]} -ooutpas #{PASCAL_OPTIONS} > #{params[:message_file]}"
                 system(command)
                 FileUtils.mv("output", params[:output_file])
               when "java"
                 #rename the file to the public class name
                 #get the class name
                 classname = 'DUMMY'
+            +   source = Array.new
                 File.foreach(params[:source_file]) do |line|
                   md = /\s*public\s*class\s*(\w*)/.match(line)
                   classname=md[1] if md
+            +     source << line unless line =~ /\s*package\s*\w+\s*\;/
                 end
-            -   system("cp #{params[:source_file]} #{classname}.java")
+            +   File.open("#{classname}.java","w") do |file|
+            +     source.each do |s|
+            +       file.puts s
+            +     end
+            +   end
+            +   #system("cp #{params[:source_file]} #{classname}.java")
                 command = "#{JAVA_COMPILER} #{classname}.java 2> #{params[:message_file]}"
                 system(command)
                 if File.exists?(classname + ".class")
                   File.open(params[:output_file],"w") {|file| file.write("#{classname}")}
                 end
                 if classname == 'DUMMY'
                   File.open(params[:message_file],"w") {|file| file.write("Cannot find any public class in the source code\n")}
                 end
               when "ruby"
                 command = "#{RUBY_INTERPRETER} -c #{params[:source_file]} 2> #{params[:message_file]}"
                 if system(command)
                   File.open(params[:output_file],"w") do |out_file|
                     out_file.puts "#!#{RUBY_INTERPRETER}"
                     File.open(params[:source_file],"r").each do |line|
                       out_file.print line
                     end
                   end
                   File.chmod(0755, params[:output_file])
                 end
               when "python"
                 command = "#{PYTHON_CHECKER} #{params[:source_file]} > #{params[:message_file]}"
                 if system(command)
                   #compile to python bytecode
                   command = "#{PYTHON_INTERPRETER} -m py_compile #{params[:source_file]}"
                   puts "compile: #{command}"
                   system(command)
                   puts "pwd: " + Dir.pwd
                   Dir.new('.').each {|file| puts file}
                   File.open(params[:output_file],"w") do |out_file|
                     out_file.puts "#!#{PYTHON_INTERPRETER} #{params[:source_file]}c"
                   end
                   File.chmod(0755, params[:output_file])
+            +     FileUtils.cp("#{params[:source_file]}c",params[:output_file])
                 end
+            -
+            +
+            + when "php"
+            +   command = "#{PHP_INTERPRETER} #{PHP_OPTIONS} #{params[:source_file]} 2> #{params[:message_file]}"
+            +   if system(command)
+            +     File.open(params[:output_file],"w") do |out_file|
+            +       out_file.puts "#!#{PHP_INTERPRETER}"
+            +       File.open(params[:source_file],"r").each do |line|
+            +         out_file.print line
+            +       end
+            +     end
+            +     File.chmod(0755, params[:output_file])
+            +   end
+            +
               else
                 talk("ERROR: Invalid language specified!")
                 open(params[:message_file],"w") do |f|
                   f.puts "ERROR: Invalid language specified!"
                 end
                 exit(127)
               end
               # Report success or failure.
               if FileTest.exists? params[:output_file]
                 talk "Compilation was successful!"
               else
                 talk "ERROR: Something was wrong during the compilation!"
               end

std-script/grade ¶ +27 -2

               #!/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(.*)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>=2
+            +       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
-            - log "score = #{all_score} comment = #{all_comment}"
+            +
+            + 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}"

std-script/judge ¶ +3 -2

               #!/usr/bin/env ruby
               require 'fileutils'
               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("judge: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               problem_home = ENV['PROBLEM_HOME']
               def execute(command, error_message="")
                 if not system(command)
                   msg = "ERROR: #{error_message}"
                   log msg
                   raise(msg)
                 end
               end
               def call_and_log(error_message)
                 begin
                   yield
                 rescue
                   msg = "ERROR: #{error_message}"
                   log msg
                   raise msg
                 end
               end
               def clear_and_create_empty_dir(dir)
                 FileUtils.rm_rf(dir, :secure => true)
                 call_and_log("Cannot make directory #{dir}.") { FileUtils.mkdir(dir) }
               end
               # ARGV[0] --- language
               # ARGV[1] --- program source file
               # ARGV[2] --- test result directory
               # ARGV[3] --- sandbox directory
               if ARGV.length < 2 || ARGV.length > 4
                 puts "Usage: judge <language> <program-source> [<test-result-directory>] [<sandbox-directory>]"
                 puts "  <sandbox-directory> is defaulted to ./sandbox"
                 puts "  <test-result-directory> is defaulted to ./test-result"
                 puts "WARNING: The judge script will forcefully create the (implicitly and explicitly) specified directories and remove anything inside it."
                 exit(127)
               end
               language = ARGV[0]
-            - if language != "c" && language != "c++" && language != "pas" && language != "java" && language != "ruby" && language != "python"
+            + if language != "c" && language != "c++" && language != "pas" && language != "java" && language != "ruby" && language != "python" && language != "php"
                 log "You specified a language that is not supported: #{language}."
                 exit(127)
               end
               source_file = ARGV[1]
+            + ENV['SOURCE_NAME'] = source_file
               if File.exist?(source_file) == false
                 log "The source file does not exist."
                 exit(127)
               end
               log "Making test result and sandbox directories..."
               current_dir = FileUtils.pwd
               current_dir.strip!
               if ARGV.length >= 3
                 test_result_dir = ARGV[2]
               else
                 test_result_dir = "#{current_dir}/test-result"
               end
               log "Test result directory: #{test_result_dir}"
               clear_and_create_empty_dir(test_result_dir)
               if ARGV.length >= 4
                 sandbox_dir = ARGV[3]
               else
                 sandbox_dir = "#{current_dir}/sandbox"
               end
               log "Sandbox directory: #{sandbox_dir}"
               clear_and_create_empty_dir(sandbox_dir)
               # Compile
               log
               log "Compiling..."
               call_and_log("Cannot copy the source file to #{sandbox_dir}") {
                 FileUtils.cp(source_file, sandbox_dir)
               }
               begin
                 Dir.chdir sandbox_dir
               rescue
                 log "ERROR: Cannot change directory to #{sandbox_dir}."
                 exit(127)
               end
               execute("#{problem_home}/script/compile #{language} #{source_file}", "Compilation error!")
               compile_message = open("compiler_message").read
               compile_message.strip!
               call_and_log("Cannot move the compiler message to #{test_result_dir}.") {
                 FileUtils.mv("compiler_message", test_result_dir)
               }
               if !FileTest.exist?("a.out")
                 log "Cannot compile the source code. See message in #{test_result_dir}/compile_message"
                 exit(127)
               else
                 call_and_log("Cannot move the compiled program to #{test_result_dir}") {
                   FileUtils.mv("a.out",test_result_dir)
                   if language == "java" then Dir["*.class"].each { |file| FileUtils.mv(file,test_result_dir)} end
                   if language == "python" then Dir["*.pyc"].each { |file| FileUtils.mv(file,test_result_dir)} end
                 }
                 FileUtils.rm_rf("#{sandbox_dir}/.")
               end
               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
               # Doing the testing.
               (1..(problem.num_tests)).each do |test_num|
                 $stdout.print "[#{test_num}]"
                 $stdout.flush
                 log "Test number: #{test_num}"
                 call_and_log("Cannot copy the compiled program into #{sandbox_dir}") {
                   FileUtils.cp("#{test_result_dir}/a.out", sandbox_dir, :preserve => true)
                   if language == "java" then Dir["#{test_result_dir}/*.class"].each { |file| FileUtils.cp(file,sandbox_dir)} end
                   if language == "python" then Dir["#{test_result_dir}/*.pyc"].each { |file| FileUtils.cp(file,sandbox_dir)} end
                 }
                 begin
-            -     execute("#{problem_home}/script/run #{language} #{test_num}", "Error occured during execution of the run script")
+            +     execute("#{problem_home}/script/run #{language} #{test_num} ", "Error occured during execution of the run script")
                 rescue
                   # do nothing
                 end
                 call_and_log("Cannot create directory #{test_result_dir}/#{test_num}") {
                   FileUtils.mkdir "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot copy the result file into #{test_result_dir}/#{test_num}") {
                   FileUtils.mv "#{sandbox_dir}/result", "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot copy the comment file into #{test_result_dir}/#{test_num}") {
                   FileUtils.mv "#{sandbox_dir}/comment", "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot copy the output file into #{test_result_dir}/#{test_num}") {
                   FileUtils.mv "#{sandbox_dir}/output.txt", "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot clear #{sandbox_dir}") {
                   FileUtils.rm_rf(Dir.glob("#{sandbox_dir}/*"), :secure => true)
                 }
               end
               $stdout.print "[done]\n"
               # Grade
               log
               log "Grading..."
               begin
                 Dir.chdir test_result_dir
               rescue
                 log "ERROR: Cannot change directory to #{test_result_dir}."
                 exit(127)
               end
               execute("#{problem_home}/script/grade", "An error occured during grading!")
               log
               log "All done!"

std-script/run ¶ +16 -8

               #!/usr/bin/env ruby
               require 'fileutils'
               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("run: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               def extract_time(t)
                 #  puts "TIME: #{t}"
                 if (result=/^(.*)r(.*)u(.*)s/.match(t))
                   {:real => result[1], :user => result[2], :sys => result[3]}
                 else
                   #{:real => 0, :user => 0, :sys => 0}
                   #puts "ERROR READING RUNNING TIME: #{t}"
                   raise "Error reading running time: #{t}"
                 end
               end
               def compile_box(source,bin)
                 system("g++ #{source} -o #{bin}")
               end
               if ARGV.length < 2 || ARGV.length > 3
                 puts "Usage: run <language> <test-num> [<program-name>]"
                 exit(127)
               end
               language = ARGV[0]
               test_num = ARGV[1].to_i
               if ARGV.length > 2
                 program_name = ARGV[2]
               else
                 program_name = "a.out"
               end
               problem_home = ENV['PROBLEM_HOME']
+            + source_name = ENV['SOURCE_NAME']
               require "#{problem_home}/script/test_dsl.rb"
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
+            + sandbox_dir = Dir.getwd
+            +
               if problem.well_formed? == false
                 log "The problem specification is not well formed."
                 exit(127)
               end
               # Check if the test number is okay.
               if test_num <= 0 || test_num > problem.num_tests
                 log "You have specified a wrong test number."
                 exit(127)
               end
               #####################################
               # Set the relavant file names here. #
               #####################################
               input_file_name = "#{problem_home}/test_cases/#{test_num}/input-#{test_num}.txt"
               #####################################
               time_limit = problem.get_time_limit test_num
               mem_limit = problem.get_mem_limit(test_num) * 1024
               # Copy the input file.
               #`cp #{problem_home}/test_cases/#{test_num}/#{input_file_name} .`
               # check if box is there, if not, compile it!
               if !File.exists?("#{problem_home}/script/box")
                 log "WARNING: Compiling box: to increase efficiency, it should be compile manually"
                 compile_box("#{problem_home}/script/box.cc",
                             "#{problem_home}/script/box")
               end
               # Hide PROBLEM_HOME
               ENV['PROBLEM_HOME'] = nil
+            + ENV['SOURCE_NAME'] = nil
               # Run the program.
               #run_command = "/usr/bin/time -f \"#{time_output_format}\" 2>run_result #{problem_home}/script/box_new -a 2 -f -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name}"
               #
+            -
+            -
+            + JAVA_OPTION = "-s set_robust_list -s futex -s clone -s getppid -s clone -s wait4 -p /usr/bin/ -p ./"
+            + RUBY_OPTION   = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /lib64/ -p /dev/urandom -p #{sandbox_dir}/#{program_name} -p #{sandbox_dir}/ -s set_robust_list -s sched_getaffinity -s clock_gettime -s sigaltstack -s pipe2 -s clone -s futex -s openat -s pipe"
+            + PYTHON_OPTION = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /usr/bin/ -p /lib64/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p #{sandbox_dir}/#{source_name} -s set_robust_list -s openat -s recvmsg -s connect -s socket -s sendto -s futex -E PYTHONNOUSERSITE=yes"
+            + PHP_OPTION = "-p /usr/lib64/ -p/lib64/ -p /usr/bin/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p /usr/share/ -s setfsuid -s setfsgid -s openat -s set_robust_list -s futex -s clone -s socket -s connect"
               case language
                 when "java"
+            -
                   # for java, extract the classname
                   # wne have to add additional systemcall and we don't check the mem limit (dunno how to fix...)
                   classname = 'DUMMY'
                   File.open(program_name,"r").each do |line|
                     classname = line
                   end
-            -     run_command = "#{problem_home}/script/box -T -t #{time_limit} -s getppid -s clone -s wait4 -p /usr/bin/ -p ./ -i #{input_file_name} -o output.txt /usr/bin/java #{classname} 2>run_result"
+            +     #for java, we cannot really check the memory limit...
+            +     run_command = "#{problem_home}/script/box -a 3 -f -T -t #{time_limit} #{JAVA_OPTION} -i #{input_file_name} -o output.txt /usr/bin/java #{classname} 2>run_result"
                 when "ruby"
-            -     run_command = "#{problem_home}/script/box -T -t #{time_limit} -s getppid -s wait4 -s clone -s set_robust_list -s futex -s sigaltstack -p /dev/urandom -p ./ -p /home/dae/.rvm/rubies/ruby-1.9.2-p320/ -p #{problem_home}/ -i #{input_file_name} -o output.txt #{program_name} 2>run_result"
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{mem_limit} #{RUBY_OPTION} -i #{input_file_name} -o output.txt /usr/bin/ruby #{program_name} 2>run_result"
                 when "python"
-            -     #this code just run without any checking
-            -     run_command = "#{problem_home}/script/box -T -t #{time_limit} -p #{problem_home}/ -i #{input_file_name} -o output.txt #{program_name} 2>run_result"
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{mem_limit} #{PYTHON_OPTION} -i #{input_file_name} -o output.txt /usr/bin/python #{program_name} 2>run_result"
+            +   when "php"
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} #{PHP_OPTION} -i #{input_file_name} -o output.txt /usr/bin/php #{program_name} 2>run_result"
                 else # for c++, pascal, we do the normal checking
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name} 2>run_result"
               end
               log "Running test #{test_num}..."
               log run_command
-            - log
+            + log
               system(run_command)
               # Restore PROBLEM_HOME
               ENV['PROBLEM_HOME'] = problem_home
               # Create the result file.
               result_file = File.new("result", "w")
               comment_file = File.new("comment", "w")
               # Check if the program actually produced any output.
               run_result_file = File.new("run_result", "r")
               run_result = run_result_file.readlines
               run_result_file.close
               run_stat = run_result[run_result.length-1]
               running_time = extract_time(run_stat)
               report = lambda{ |status, points, comment|
                 result_file.write status.strip
                 result_file.write "\n"
                 result_file.write points.to_s.strip
                 result_file.write "\n"
                 result_file.write run_stat.strip
                 result_file.write "\n"
                 result_file.close
                 FileUtils.rm "run_result"
                 # `rm output.txt`   --- keep the output
                 comment_file.write comment
                 # added for debuggin --- jittat
                 comment_file.write "--run-result--\n"
                 run_result.each do |l|
                   comment_file.write l
                 end
                 comment_file.close
                 log "Done!"
                 exit(0)
               }
+            +
               if run_result[0][0,2] != "OK"
                 log "There was a runtime error."
                 report.call(run_result[0], 0, "No comment.\n")
               end
               if running_time[:user].to_f > time_limit
                 log "Time limit exceeded."
                 report.call("Time limit exceeded", 0, "No comment.\n")
               end
               # Run 'check' to evaluate the output.
               #puts "There was no runtime error. Proceed to checking the output."
               check_command = "#{problem_home}/script/check #{language} #{test_num}"
               log "Checking the output..."
               log check_command
               if not system(check_command)
                 log "Problem with check script"
                 report.call("Incorrect",0,"Check script error.\n")
                 exit(127)
               end
               check_file = File.new("check_result", "r")
               check_file_lines = check_file.readlines
               report.call(check_file_lines[0], check_file_lines[1], "No comment.\n")

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

r173:aa6e7ff3942c - Sun, 28 Sep 2014 02:42:25 - 9 files changed: 124 inserted, 34 deleted

Sign in to your account

Commit r173:aa6e7ff3942c public

Author

r173:aa6e7ff3942c - Sun, 28 Sep 2014 02:42:25 - 9 files changed: 124 inserted, 34 deleted

Commit `r173:aa6e7ff3942c` public