rbx.cp 0.5.72__py3-none-any.whl → 0.6.0__py3-none-any.whl

rbx/grading/judge/sandboxes/timeit.py

@@ -5,6 +5,7 @@ import resource
 import signal
 import stat
 import sys
+import threading
 from time import monotonic
 from typing import Any, Dict, List, Optional, Set, Union
 
@@ -25,6 +26,7 @@ class Options:
     file_duplicates: Dict[int, List[str]] = dataclasses.field(default_factory=dict)
     prefixed: Set[str] = dataclasses.field(default_factory=set)
     prefix: str = ''
+    process_group: Optional[int] = None
 
 
 def exit_with(code: int):
@@ -91,17 +93,16 @@ def create_tee(files, mode, buffer_size=4096, prefix=''):
             # Close parent's end of the pipe
             os.close(pipe_write)
 
-            bytes = os.read(pipe_read, buffer_size)
-            while bytes:
+            new = True
+            while bytes := os.read(pipe_read, 1):
                 for tee in tee_list:
-                    if tee.prefix:
+                    if tee.prefix and new:
                         tee.file.write(tee.prefix)
                     tee.file.write(bytes)
                     tee.file.flush()
+                    new = bytes == b'\n'
                     # TODO maybe add in fsync() here if the fileno() method
                     # exists on file
-
-                bytes = os.read(pipe_read, buffer_size)
         except Exception:
             pass
         finally:
@@ -150,6 +151,8 @@ def parse_opts() -> Options:
             options.fs_limit = int(opt[2:])
         elif opt.startswith('-P'):
             options.prefix = opt[2:]
+        elif opt.startswith('-g'):
+            options.process_group = int(opt[2:])
         else:
             raise Exception(f'Invalid option {opt}')
         num_opts += 1
@@ -270,6 +273,7 @@ def wait_and_finish(
     entries.append(f'time-wall: {wall_time:.3f}')
     entries.append(f'mem: {memory_used}')
     entries.append(f'file: {file_sizes}')
+    entries.append(f'pid: {pid}')
 
     output_file = pathlib.Path(sys.argv[1])
     output_file.parent.mkdir(parents=True, exist_ok=True)
@@ -279,6 +283,9 @@ def wait_and_finish(
 def main():
     options = parse_opts()
 
+    if options.process_group is not None:
+        os.setpgid(0, options.process_group)
+
     start_time = monotonic()
     sub_pid = os.fork()
     if sub_pid == 0:
@@ -292,13 +299,21 @@ def main():
     alarm_msg: List[Optional[str]] = [None]
     status_holder: Set[str] = set()
 
-    def handle_alarm(*args, **kwargs):
+    stop_wall_handler = threading.Event()
+    stop_alarm_handler = threading.Event()
+
+    def handle_wall():
+        if stop_wall_handler.wait(options.wall_time_limit):
+            return
+        stop_alarm_handler.set()
         nonlocal alarm_msg
-        wall_time = monotonic() - start_time
-        if options.wall_time_limit is not None and wall_time > options.wall_time_limit:
-            alarm_msg[0] = 'wall timelimit'
-            os.kill(sub_pid, 9)
+        alarm_msg[0] = 'wall timelimit'
+        os.kill(sub_pid, 9)
+
+    def handle_alarm():
+        if stop_alarm_handler.wait(0.3):
             return
+        nonlocal alarm_msg
         ru = resource.getrusage(resource.RUSAGE_CHILDREN)
         if options.time_limit is not None:
             cpu_time = get_cpu_time(ru)
@@ -313,20 +328,26 @@ def main():
                 os.kill(sub_pid, 9)
                 return
 
-        signal.setitimer(signal.ITIMER_REAL, 0.3)
+        stop_alarm_handler.clear()
+        handle_alarm()
+
+    alarm_handler = threading.Thread(target=handle_alarm, daemon=True)
+    wall_handler = threading.Thread(target=handle_wall, daemon=True)
+    alarm_handler.start()
+    wall_handler.start()
 
     def handle_sub_term(*args, **kwargs):
         nonlocal status_holder
         status_holder.add('TE')
         os.kill(sub_pid, 9)
 
-    signal.setitimer(signal.ITIMER_REAL, 0.3)
-    signal.signal(signal.SIGALRM, handle_alarm)
     signal.signal(signal.SIGTERM, handle_sub_term)
 
     wait_and_finish(sub_pid, options, start_time, status_holder, alarm_msg=alarm_msg)
-    # Cancel alarm before exiting to avoid surprises.
-    signal.setitimer(signal.ITIMER_REAL, 0)
+
+    # Process finished, stop the handlers.
+    stop_wall_handler.set()
+    stop_alarm_handler.set()
 
     # Exit gracefully.
     sys.exit(0)

rbx/grading/processing_context.py

@@ -1,87 +1,71 @@
-import asyncio
 import contextlib
 import os
 import signal
-import threading
-from typing import Optional, Set
+import subprocess
+from typing import List, Optional
 
-_processing_context_pids: Optional[Set[int]] = None
-_terminate_all_on_error = False
-_lock = threading.Lock()
-
-# Creating a processing context is not thread-safe, but adding to it is.
+from rbx.grading.judge.sandbox import SandboxBase
 
 
 @contextlib.contextmanager
-def new_processing_context(terminate_all_on_error: bool = False):
-    global _processing_context_pids, _terminate_all_on_error
-    with _lock:
-        old_processing_context_pids = _processing_context_pids
-        _old_terminate_all_on_error = _terminate_all_on_error
-        _processing_context_pids = set()
-        _terminate_all_on_error = terminate_all_on_error
+def new_process_group():
+    p = subprocess.Popen(['/bin/bash', '-c', 'exec sleep infinity'])
     try:
-        yield
+        yield p.pid
     finally:
-        with _lock:
-            _processing_context_pids = old_processing_context_pids
-            _terminate_all_on_error = _old_terminate_all_on_error
-
-
-def get_processing_context() -> Set[int]:
-    with _lock:
-        return _processing_context_pids or set()
-
-
-def add_to_processing_context(pid: int):
-    global _processing_context_pids
-    with _lock:
-        if _processing_context_pids is None:
-            return
-        _processing_context_pids.add(pid)
-
-
-def terminate_all_processes_in_context(clear: bool = True):
-    global _processing_context_pids
-    with _lock:
-        if _processing_context_pids is None:
-            return
-        for pid in _processing_context_pids:
-            try:
-                os.kill(pid, signal.SIGTERM)
-            except OSError:
-                pass
-        if clear:
-            _processing_context_pids.clear()
-
-
-async def wait_all_processes_in_context(wait_for: int):
-    global _processing_context_pids, _terminate_all_on_error
-    wait_pids = set()
-    while len(get_processing_context()) < wait_for:
-        await asyncio.sleep(0.01)
-
-    with _lock:
-        if _processing_context_pids is None:
-            return
-        wait_pids.update(_processing_context_pids)
-
-    wait_lock = threading.Lock()
-    finished_pids = []
-
-    def process(pid: int, returncode: int):
-        with wait_lock:
-            finished_pids.append(pid)
-        if returncode != 0 and _terminate_all_on_error:
-            terminate_all_processes_in_context()
-
-    def wait_all_processes():
-        while len(finished_pids) < len(wait_pids):
-            try:
-                pid, status = os.wait()
-            except ChildProcessError:
-                return
-            if pid in wait_pids:
-                process(pid, os.waitstatus_to_exitcode(status))
-
-    await asyncio.to_thread(wait_all_processes)
+        p.terminate()
+        p.wait()
+
+
+def should_use_group(sandboxes: List[SandboxBase]) -> bool:
+    if not sandboxes:
+        return False
+    uses_pgid = all(sandbox.use_pgid() for sandbox in sandboxes)
+    all_pgids = set(
+        sandbox.params.pgid for sandbox in sandboxes if sandbox.params.pgid is not None
+    )
+    return uses_pgid and len(all_pgids) == 1
+
+
+async def _fetch_pids(sandboxes: List[SandboxBase]) -> List[int]:
+    return [await sandbox.get_pid() for sandbox in sandboxes]
+
+
+def _find_sandbox_idx(pids: List[int], pid: int) -> Optional[int]:
+    try:
+        return pids.index(pid)
+    except ValueError:
+        return None
+
+
+async def _wait_for_group(sandboxes: List[SandboxBase]) -> List[int]:
+    pgid = [
+        sandbox.params.pgid for sandbox in sandboxes if sandbox.params.pgid is not None
+    ][0]
+    assert pgid is not None
+
+    sandbox_pids = await _fetch_pids(sandboxes)
+
+    finished = []
+    while len(finished) < len(sandboxes):
+        try:
+            pid, status = os.waitpid(-pgid, 0)
+        except ChildProcessError:
+            break
+
+        if os.waitstatus_to_exitcode(status) != 0:
+            os.kill(pgid, signal.SIGKILL)
+
+        sandbox_idx = _find_sandbox_idx(sandbox_pids, pid)
+        if sandbox_idx is not None:
+            finished.append(sandbox_idx)
+            continue
+
+    return finished
+
+
+async def wait_all(sandboxes: List[SandboxBase]):
+    if not should_use_group(sandboxes):
+        raise RuntimeError('Sandboxes are not using a process group')
+
+    await _wait_for_group(sandboxes)

rbx/grading/steps.py

@@ -10,7 +10,6 @@ import shutil
 import subprocess
 import sys
 import tempfile
-import typing
 from enum import Enum
 from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union
 
@@ -53,6 +52,27 @@ class Outcome(Enum):
             Outcome.IDLENESS_LIMIT_EXCEEDED,
         ]
 
+    def short_name(self) -> str:
+        if self == Outcome.ACCEPTED:
+            return 'AC'
+        if self == Outcome.WRONG_ANSWER:
+            return 'WA'
+        if self == Outcome.TIME_LIMIT_EXCEEDED:
+            return 'TLE'
+        if self == Outcome.IDLENESS_LIMIT_EXCEEDED:
+            return 'ILE'
+        if self == Outcome.MEMORY_LIMIT_EXCEEDED:
+            return 'MLE'
+        if self == Outcome.RUNTIME_ERROR:
+            return 'RTE'
+        if self == Outcome.OUTPUT_LIMIT_EXCEEDED:
+            return 'OLE'
+        if self == Outcome.JUDGE_FAILED:
+            return 'FL'
+        if self == Outcome.INTERNAL_ERROR:
+            return 'IE'
+        return 'XX'
+
 
 class DigestHolder(BaseModel):
     value: Optional[str] = None
@@ -372,12 +392,12 @@ def _is_c_command(exe_command: str) -> bool:
     return 'gcc' in exe_command or 'clang' in exe_command
 
 
-def _is_cpp_command(exe_command: str) -> bool:
+def is_cpp_command(exe_command: str) -> bool:
     return 'g++' in exe_command or 'clang++' in exe_command
 
 
 def is_cxx_command(exe_command: str) -> bool:
-    return _is_cpp_command(exe_command) or _is_c_command(exe_command)
+    return is_cpp_command(exe_command) or _is_c_command(exe_command)
 
 
 def is_cxx_sanitizer_command(command: str) -> bool:
@@ -413,7 +433,8 @@ def _complain_about_clang() -> None:
     )
 
 
-def _get_cxx_version_output(command: str) -> Optional[str]:
+@functools.cache
+def _get_cxx_version_output(command: str, extra_flags: str = '') -> Optional[str]:
     cmds = shlex.split(command)
     if not cmds:
         return None
@@ -421,8 +442,8 @@ def _get_cxx_version_output(command: str) -> Optional[str]:
     if not is_cxx_command(exe):
         return None
 
-    exe = cmds[0]
-    output = subprocess.run([exe, '-v'], capture_output=True)
+    extra = shlex.split(extra_flags)
+    output = subprocess.run([exe, '-v', *extra], capture_output=True, input='')
     if output.returncode != 0:
         console.print('[error]Failed to get C/C++ compiler version.[/error]')
         return None
@@ -430,6 +451,8 @@ def _get_cxx_version_output(command: str) -> Optional[str]:
 
 
 def _maybe_get_bits_stdcpp_for_clang(command: str) -> Optional[GradingFileInput]:
+    if not is_cpp_command(get_exe_from_command(command)):
+        return None
     version_output = _get_cxx_version_output(command)
     if version_output is None:
         return None
@@ -446,11 +469,44 @@ def _maybe_get_bits_stdcpp_for_clang(command: str) -> Optional[GradingFileInput]
     return GradingFileInput(src=bits, dest=pathlib.Path('bits/stdc++.h'))
 
 
-def _maybe_get_bits_stdcpp_for_commands(
+def _find_system_paths_in_version_output(version_output: str) -> List[pathlib.Path]:
+    res = []
+    start = False
+    for line in version_output.splitlines():
+        if line.startswith('#include <...> search starts here:'):
+            start = True
+            continue
+        if not start:
+            continue
+        if not line.startswith(' '):
+            break
+        res.append(pathlib.Path(line.strip()))
+    return res
+
+
+def _get_system_bits_stdcpp(command: str) -> Optional[GradingFileInput]:
+    if not is_cpp_command(get_exe_from_command(command)):
+        return None
+    version_output = _get_cxx_version_output(command, '-xc++ -E -')
+    if version_output is None:
+        return None
+    for path in _find_system_paths_in_version_output(version_output):
+        bits_candidate = path / 'bits' / 'stdc++.h'
+        if not bits_candidate.is_file():
+            continue
+        return GradingFileInput(
+            src=bits_candidate.resolve().absolute(), dest=pathlib.Path('bits/stdc++.h')
+        )
+    return None
+
+
+def maybe_get_bits_stdcpp_for_commands(
     commands: List[str],
 ) -> Optional[GradingFileInput]:
     for command in commands:
-        res = _maybe_get_bits_stdcpp_for_clang(command)
+        res = _get_system_bits_stdcpp(command) or _maybe_get_bits_stdcpp_for_clang(
+            command
+        )
         if res is not None:
             return res
     return None
@@ -560,10 +616,9 @@ def compile(
     sandbox: SandboxBase,
     artifacts: GradingArtifacts,
 ) -> bool:
+    sandbox.reset()
+
     commands = _try_following_alias_for_commands(commands)
-    bits_artifact = _maybe_get_bits_stdcpp_for_commands(commands)
-    if bits_artifact is not None:
-        _process_input_artifacts(GradingArtifacts(inputs=[bits_artifact]), sandbox)
     _process_input_artifacts(artifacts, sandbox)
 
     if not commands:
@@ -571,7 +626,9 @@ def compile(
         return True
 
     logs: List[PreprocessLog] = []
-    sandbox.set_params(params)
+    sandbox.set_params(
+        params.model_copy(deep=True)
+    )  # Copy to allow further modification.
 
     for i, command in enumerate(commands):
         _maybe_complain_about_sanitization(command)
@@ -584,10 +641,6 @@ def compile(
         if is_java_like_command(get_exe_from_command(command)):
             sandbox.params.address_space = None
 
-        if bits_artifact is not None and _is_cpp_command(cmd[0]):
-            # Include from sandbox directory to import bits/stdc++.h.
-            cmd.append('-I.')
-
         if not sandbox.execute_without_std(cmd):
             console.print(
                 '[error]Sandbox crashed while processing command:[/error]',
@@ -642,12 +695,15 @@ async def run(
     sandbox: SandboxBase,
     artifacts: GradingArtifacts,
     metadata: Optional[RunLogMetadata] = None,
-    kill_on_processing_context_exit: bool = False,
 ) -> Optional[RunLog]:
+    sandbox.reset()
+
     _process_input_artifacts(artifacts, sandbox)
     _process_fifos(artifacts, sandbox)
     cmd = _split_and_expand(command, sandbox)
-    sandbox.set_params(params)
+    sandbox.set_params(
+        params.model_copy(deep=True)
+    )  # Copy to allow further modification.
 
     # Remove memory constraints for Java.
     if is_java_like_command(get_exe_from_command(command)):
@@ -662,9 +718,6 @@ async def run(
         )
         return None
 
-    if sandbox.get_exit_code() != 0 and kill_on_processing_context_exit:
-        processing_context.terminate_all_processes_in_context(clear=False)
-
     if not _process_output_artifacts(artifacts, sandbox):
         return None
 
@@ -706,27 +759,25 @@ async def run_coordinated(
     interactor: CoordinatedRunParams,
     solution: CoordinatedRunParams,
 ) -> Tuple[Optional[RunLog], Optional[RunLog]]:
-    with processing_context.new_processing_context(terminate_all_on_error=True):
-        # Schedule both runs to execute immediately.
-        runs = tuple(
-            asyncio.create_task(
-                run(
-                    params.command,
-                    params.params,
-                    params.sandbox,
-                    params.artifacts,
-                    params.metadata,
-                    kill_on_processing_context_exit=True,
-                )
+    def run_one(params: CoordinatedRunParams) -> asyncio.Task[Optional[RunLog]]:
+        return asyncio.create_task(
+            run(
+                params.command,
+                params.params,
+                params.sandbox,
+                params.artifacts,
+                params.metadata,
             )
-            for params in [interactor, solution]
-        )
-        await processing_context.wait_all_processes_in_context(wait_for=2)
-        logs = typing.cast(
-            Tuple[Optional[RunLog], Optional[RunLog]],
-            tuple(await asyncio.gather(*runs)),
         )
-        return logs
+
+    # Use interactor PID as the process group id.
+    interactor_task = run_one(interactor)
+    solution.sandbox.params.pgid = await interactor.sandbox.get_pid()
+    solution_task = run_one(solution)
+
+    await processing_context.wait_all([interactor.sandbox, solution.sandbox])
+
+    return await asyncio.gather(interactor_task, solution_task)
 
 
 def _normalize_checked_words(s: str) -> Tuple[str, ...]:

rbx/resources/packagers/boca/checker.sh

@@ -1,4 +1,7 @@
 ### START OF CHECKER COMPILATION
+CACHE_DIR="/tmp/boca-cache"
+mkdir -p $CACHE_DIR
+
 CDIR=$(pwd)
 CHECKER_PATH="checker.cpp"
 CHECKER_OUT="checker.exe"
@@ -27,7 +30,7 @@ printf "%s" "${RbxHeaderContent}" >rbx.h
 printf "%s" "${CheckerContent}" >$CHECKER_PATH
 
 checker_hash=($(cat $CHECKER_PATH rbx.h testlib.h | md5sum))
-checker_cache="/tmp/boca-chk-${checker_hash}"
+checker_cache="$CACHE_DIR/checker-${checker_hash}"
 
 echo "Polygon checker hash: $checker_hash"
 echo "Copying polygon checker to $CDIR/$CHECKER_OUT"

rbx/resources/packagers/boca/compile/c

@@ -92,12 +92,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe

rbx/resources/packagers/boca/compile/cc

@@ -93,12 +93,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe

rbx/resources/packagers/boca/compile/cpp

@@ -92,12 +92,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe

rbx/resources/packagers/boca/compile/java

@@ -88,13 +88,8 @@ if [ ! -x $sf ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
 time=30
+ttime=30
 
 maxm=512
 if [ "$4" != "" -a "$4" -gt "512" ]; then