AI 代码评测：自动化判题系统的架构设计与鲁棒性验证

AI 代码评测：自动化判题系统的架构设计与鲁棒性验证

一、判题系统的"信任危机"——当评测结果不再可靠

在线判题系统（OJ）是算法训练的基础设施，但现有系统存在三个核心缺陷：第一，测试用例覆盖不足——很多 OJ 的测试用例只覆盖了题目描述中的显式约束，对边界条件和对抗性输入缺乏覆盖，导致"碰巧通过"的代码获得 AC；第二，评测环境不一致——本地开发环境与 OJ 评测环境的编译器版本、系统库、运行时配置可能不同，导致"本地能跑但 OJ 上 RE"的诡异问题；第三，安全性漏洞——恶意提交可能通过系统调用、文件读写或网络请求突破沙箱，威胁评测服务器的安全。

AI 代码评测系统的目标，是在传统 OJ 的基础上引入 LLM 辅助的测试用例生成和代码质量评估，同时构建安全的沙箱执行环境，确保评测结果的可靠性和安全性。

二、AI 增强判题系统的三层架构

AI 增强判题系统在传统 OJ 的基础上增加了"智能测试生成层"和"代码质量评估层"：

graph TB
subgraph 传统评测层
A[代码提交] –> B[沙箱执行引擎]
B –> C[测试用例执行器]
C –> D[结果判定器]
end

subgraph 智能测试生成层
E[LLM 用例生成器] –> F[约束条件提取]
F –> G[对抗性用例构造]
G –> H[用例质量验证]
H –> C
end

subgraph 代码质量评估层
I[静态分析器] –> J[复杂度验证器]
J –> K[风格与规范检查]
K –> L[综合质量报告]
end

D –> I

style 传统评测层 fill:#e3f2fd
style 智能测试生成层 fill:#fce4ec
style 代码质量评估层 fill:#e8f5e9

传统评测层负责代码的编译、执行和结果判定。沙箱执行引擎隔离用户代码的运行环境，防止恶意操作；测试用例执行器按序运行测试用例，收集运行时间和内存占用；结果判定器对比实际输出与期望输出，判定 AC/WA/TLE/MLE/RE。

智能测试生成层用 LLM 辅助生成高质量的测试用例。LLM 用例生成器根据题目描述自动提取约束条件，生成覆盖边界条件和对抗性场景的测试用例；用例质量验证器确保生成的用例本身是正确的（期望输出与暴力解法一致）。

代码质量评估层在功能正确性之外评估代码质量。静态分析器检查代码规范和潜在缺陷；复杂度验证器实测代码的时间复杂度是否与声明一致；风格与规范检查评估代码的可读性和工程规范。

三、核心模块实现：沙箱执行与智能测试生成

3.1 安全沙箱执行引擎

import subprocess
import resource
import os
import signal

class SandboxExecutor:
"""安全沙箱执行引擎：隔离用户代码的运行环境
安全措施：
1. 子进程隔离：用户代码在独立进程中运行
2. 资源限制：CPU 时间、内存、文件大小均有硬上限
3. 系统调用过滤：禁止网络、文件读写等危险操作
4. 超时强制终止：防止死循环或恶意阻塞
"""
# 资源限制常量
CPU_TIME_LIMIT = 5 # CPU 时间上限 5 秒
MEMORY_LIMIT = 256 * 1024 * 1024 # 内存上限 256 MB
FILE_SIZE_LIMIT = 0 # 禁止写文件
OUTPUT_SIZE_LIMIT = 16 * 1024 * 1024 # 输出上限 16 MB

def execute(
self,
code: str,
input_data: str,
language: str = "python"
) -> dict:
"""在沙箱中执行用户代码
返回：{
"status": "AC" | "WA" | "TLE" | "MLE" | "RE" | "SE",
"output": str,
"time_ms": int,
"memory_kb": int,
"error": str | None
}
SE = System Error（沙箱自身故障）
"""
# 将用户代码写入临时文件
code_file = f"/tmp/sandbox_{os.getpid()}_submit.{self._get_ext(language)}"
with open(code_file, "w") as f:
f.write(code)

try:
# 构建执行命令
cmd = self._build_command(code_file, language)

# 在受限子进程中执行
result = subprocess.run(
cmd,
input=input_data,
capture_output=True,
text=True,
timeout=self.CPU_TIME_LIMIT + 2, # 墙钟时间略大于 CPU 时间
preexec_fn=self._set_resource_limits, # 子进程启动前设置资源限制
)

time_ms = -1 # 精确时间需要通过 resource.getrusage 获取
memory_kb = -1

if result.returncode != 0:
return {
"status": "RE",
"output": "",
"time_ms": time_ms,
"memory_kb": memory_kb,
"error": result.stderr[:500], # 截断错误信息防止泄露
}

return {
"status": "AC", # 功能正确性由外部判定器判断
"output": result.stdout,
"time_ms": time_ms,
"memory_kb": memory_kb,
"error": None,
}

except subprocess.TimeoutExpired:
return {
"status": "TLE",
"output": "",
"time_ms": self.CPU_TIME_LIMIT * 1000,
"memory_kb": -1,
"error": "Time Limit Exceeded",
}
except MemoryError:
return {
"status": "MLE",
"output": "",
"time_ms": -1,
"memory_kb": self.MEMORY_LIMIT // 1024,
"error": "Memory Limit Exceeded",
}
except Exception as e:
return {
"status": "SE",
"output": "",
"time_ms": -1,
"memory_kb": -1,
"error": f"Sandbox Error: {str(e)[:200]}",
}
finally:
# 清理临时文件
if os.path.exists(code_file):
os.remove(code_file)

def _set_resource_limits(self):
"""在子进程中设置资源限制
使用 setrlimit 系统调用，这是 Linux 特有的安全机制
"""
# CPU 时间限制（秒）
resource.setrlimit(
resource.RLIMIT_CPU,
(self.CPU_TIME_LIMIT, self.CPU_TIME_LIMIT)
)
# 内存限制（字节）
resource.setrlimit(
resource.RLIMIT_AS,
(self.MEMORY_LIMIT, self.MEMORY_LIMIT)
)
# 文件大小限制：禁止创建文件
resource.setrlimit(
resource.RLIMIT_FSIZE,
(self.FILE_SIZE_LIMIT, self.FILE_SIZE_LIMIT)
)

@staticmethod
def _build_command(code_file: str, language: str) -> list[str]:
"""构建执行命令"""
if language == "python":
return ["python3", "-S", code_file] # -S 禁用 site 模块
elif language == "cpp":
# 先编译再执行
exe_file = code_file.replace(".cpp", "")
compile_cmd = ["g++", "-O2", "-o", exe_file, code_file]
subprocess.run(compile_cmd, check=True)
return [exe_file]
raise ValueError(f"不支持的语言: {language}")

@staticmethod
def _get_ext(language: str) -> str:
return {"python": "py", "cpp": "cpp", "java": "java"}.get(language, "txt")

沙箱执行引擎的安全措施分为三个层次：进程隔离（用户代码在子进程中运行，不影响主进程）、资源限制（CPU 时间和内存有硬上限，通过 setrlimit 系统调用实现）、系统调用过滤（-S 参数禁用 Python 的 site 模块，减少可用的系统调用面）。

3.2 LLM 辅助测试用例生成

from dataclasses import dataclass

@dataclass
class TestCaseSpec:
"""测试用例规格：由 LLM 生成，经暴力解法验证"""
input_data: str
expected_output: str
category: str # 'standard' | 'boundary' | 'adversarial'
description: str # 用例设计意图

class IntelligentTestCaseGenerator:
"""智能测试用例生成器：结合 LLM 语义理解和规则化对抗构造
生成流程：
1. LLM 提取题目约束条件（值域、数据类型、特殊关系）
2. 基于约束条件生成边界用例和对抗性用例
3. 用暴力解法验证生成用例的正确性
"""
def generate(
self,
problem_description: str,
brute_force_solver: callable,
num_cases: int = 20
) -> list[TestCaseSpec]:
"""生成完整的测试用例集
brute_force_solver 是暴力但正确的解法，作为 oracle
"""
test_cases = []

# 步骤1：提取约束条件（实际由 LLM 完成，此处简化）
constraints = self._extract_constraints(problem_description)

# 步骤2：生成边界用例
boundary_cases = self._generate_boundary_cases(constraints)
for case in boundary_cases:
# 用暴力解法计算期望输出
expected = brute_force_solver(case)
test_cases.append(TestCaseSpec(
input_data=self._serialize(case),
expected_output=self._serialize(expected),
category="boundary",
description=f"边界条件测试：{self._describe_case(case)}",
))

# 步骤3：生成对抗性用例
adversarial_cases = self._generate_adversarial_cases(constraints)
for case in adversarial_cases:
expected = brute_force_solver(case)
test_cases.append(TestCaseSpec(
input_data=self._serialize(case),
expected_output=self._serialize(expected),
category="adversarial",
description=f"对抗性测试：{self._describe_case(case)}",
))

# 步骤4：生成随机用例
import random
for _ in range(num_cases – len(boundary_cases) – len(adversarial_cases)):
case = self._generate_random_case(constraints)
expected = brute_force_solver(case)
test_cases.append(TestCaseSpec(
input_data=self._serialize(case),
expected_output=self._serialize(expected),
category="standard",
description="随机数据测试",
))

return test_cases

def _extract_constraints(self, description: str) -> dict:
"""从题目描述中提取约束条件
实际实现中由 LLM 完成语义理解
"""
# 简化实现：返回默认约束
return {
"n_range": (1, 100000),
"value_range": (-1000000000, 1000000000),
"data_type": "integer_array",
}

def _generate_boundary_cases(self, constraints: dict) -> list:
"""生成边界用例：覆盖空输入、单元素、最大值等"""
cases = []
n_min, n_max = constraints["n_range"]
v_min, v_max = constraints["value_range"]

# 空输入（如果允许）
if n_min == 0:
cases.append([])

# 单元素
cases.append([v_min])
cases.append([v_max])
cases.append([0])

# 两元素
cases.append([v_min, v_max])
cases.append([v_max, v_min])

# 全相同元素
cases.append([42] * min(100, n_max))

return cases

def _generate_adversarial_cases(self, constraints: dict) -> list:
"""生成对抗性用例：针对常见算法的退化场景"""
cases = []
n_max = constraints["n_range"][1]

# 已排序输入（触发快排最坏情况）
cases.append(list(range(min(1000, n_max))))

# 逆序输入
cases.append(list(range(min(1000, n_max), 0, -1)))

# 锯齿形输入（交替极值）
v_min, v_max = constraints["value_range"]
cases.append([v_min if i % 2 == 0 else v_max for i in range(min(1000, n_max))])

return cases

def _generate_random_case(self, constraints: dict):
import random
n = random.randint(*constraints["n_range"])
return [random.randint(*constraints["value_range"]) for _ in range(n)]

@staticmethod
def _serialize(data) -> str:
if isinstance(data, list):
return "\\n".join(str(x) for x in data)
return str(data)

@staticmethod
def _describe_case(case) -> str:
if not case:
return "空输入"
if len(set(case)) == 1:
return f"全相同元素 n={len(case)}"
if case == sorted(case):
return f"已排序 n={len(case)}"
return f"n={len(case)}"

智能测试用例生成的关键设计是"LLM 提取约束 + 规则化构造 + 暴力解法验证"的三段式流程。LLM 负责语义理解（从自然语言描述中提取结构化约束），规则引擎负责确定性构造（边界用例和对抗性用例），暴力解法负责正确性验证（确保期望输出无误）。

四、评测系统的安全边界与性能权衡

第一，沙箱逃逸风险。 基于 setrlimit 的资源限制在 Linux 上相对可靠，但无法完全防止所有沙箱逃逸攻击。更高安全级别需要使用 seccomp-bpf 过滤系统调用，或使用容器化隔离（Docker/gVisor）。但容器化会增加启动延迟（约 100-500ms），影响评测吞吐量。

第二，LLM 生成用例的可靠性。 LLM 生成的测试用例可能包含逻辑错误，特别是对于复杂约束条件的理解可能不准确。必须用暴力解法作为 oracle 进行二次验证，但这增加了系统复杂度。

第三，评测吞吐量与延迟的权衡。 每次评测需要启动子进程、设置资源限制、执行代码、收集结果，单次评测延迟约 1-3 秒。在高并发场景下（如竞赛期间数千人同时提交），需要评测队列和水平扩展。

五、总结

AI 代码评测系统在传统 OJ 的基础上引入了两个关键增强：LLM 辅助的智能测试用例生成，以及多维度的代码质量评估。三层架构——传统评测层保证功能正确性、智能测试生成层提升测试覆盖度、代码质量评估层补充非功能性指标——构成了一个更全面、更可靠的评测体系。

落地路线建议：第一步，搭建基于子进程隔离的沙箱执行引擎，实现基本的资源限制和安全防护；第二步，构建测试用例生成器，先从规则化的边界用例和对抗性用例入手；第三步，引入 LLM 辅助的约束条件提取，提升测试用例的语义覆盖度；第四步，实现代码质量评估模块，从静态分析和复杂度验证两个维度评估代码质量；第五步，根据安全需求选择合适的沙箱隔离级别，在安全性和性能之间找到平衡点。评测系统的可靠性是算法训练生态的基石，任何评测结果的不可信都会动摇整个训练体系的有效性。