实现Verilog语言的判题

Author: qwertycxz

package-lock.json

@@ -57,6 +57,7 @@
         "moment": "^2.29.3",
         "queue-typescript": "^1.0.1",
         "reflect-metadata": "^0.1.13",
+        "serialport": "^13.0.0",
         "unzip-stream": "^0.3.1",
         "ws": "^7.5.7"
     }

package.json

@@ -1,8 +1,11 @@
 import * as TOML from "@iarna/toml";
 import { plainToClass, Type } from "class-transformer";
 import {
+    ArrayNotEmpty,
+    ArrayUnique,
     isBoolean,
     IsBoolean,
+    IsHexadecimal,
     IsInt,
     IsNotEmpty,
     IsNumber,
@@ -174,6 +177,14 @@ export class JudgeFactoryConfig {
     @IsPositive()
     remoteFileCacheBytes!: number;
 }
+export class FpgaConfig {
+    @ArrayNotEmpty()
+    @ArrayUnique()
+    @IsHexadecimal({
+        each: true,
+    })
+    serial!: string[];
+}
 export class Config {
     @ValidateNested()
     @IsNotEmpty()
@@ -199,6 +210,10 @@ export class Config {
     @IsNotEmpty()
     @Type(() => JudgeFactoryConfig)
     judger!: JudgeFactoryConfig;
+    @ValidateNested()
+    @IsNotEmpty()
+    @Type(() => FpgaConfig)
+    fpga!: FpgaConfig;
 }
 let config: Config | undefined = undefined;
 

src/Config.ts

@@ -35,4 +35,8 @@ export class CMP extends Language {
             },
         };
     }
+
+    get judgeTimeout() {
+        return 1000;
+    }
 }

src/Spawn/Language/CMP.ts

@@ -35,4 +35,8 @@ export class PlainText extends Language {
             args: [binPath],
         };
     }
+
+    get judgeTimeout() {
+        return 1000;
+    }
 }

src/Spawn/Language/PlainText.ts

@@ -16,14 +16,24 @@ export class Verilog extends Language {
             skip: false,
             command: getConfig().language.verilog,
             args: [getConfig().language.ise],
+            spawnOption: {
+                timeLimit: 60000,
+            },
         };
     }
 
+    get judgeTimeout() {
+        return 1000;
+    }
+
     pragramOptionGenerator(): RunOption {
         return {
             skip: false,
             command: getConfig().language.impact,
             args: ["-batch", "main.cmd"],
+            spawnOption: {
+                timeLimit: 10000,
+            },
         };
     }
 

src/Spawn/Language/Verilog.ts

@@ -42,6 +42,7 @@ export abstract class Language {
     abstract get compileCacheable(): boolean;
     abstract get srcFileName(): string;
     abstract get compiledFiles(): string[];
+    abstract get judgeTimeout(): number;
     abstract compileOptionGenerator(): RunOption;
     abstract pragramOptionGenerator(): RunOption;
 }

src/Spawn/Language/decl.ts

@@ -49,13 +49,9 @@ export function hengSpawn(
     const basicOption: BasicSpawnOption = {
         cwd: options.cwd,
         shell: getConfig().language.shell,
-        // timeout: 1000,
+        timeout: options.timeLimit,
     };
 
-    // if (options.timeLimit) {
-    //     basicOption.timeout = Math.ceil(options.timeLimit * 1.2) + 250;
-    // }
-
     if (options.stdio === undefined) {
         options.stdio = ["ignore", "ignore", "ignore"];
     }

src/Spawn/index.ts

@@ -155,11 +155,7 @@ export class ExecutableAgent {
                 `skip ${this.execType} compile, compiled: ${this.compiled}, compileCached：${this.compileCached}`
             );
             return JSON.parse(
-                (
-                    await fs.promises.readFile(
-                        await this.fileAgent.getPath(CompileStatisticName)
-                    )
-                ).toString("utf-8")
+                await this.fileAgent.getString(CompileStatisticName)
             );
         } else {
             let compileLogFileFH: FileHandle | undefined = undefined;

src/Utilities/ExecutableAgent.ts

@@ -8,7 +8,6 @@ import * as crypto from "crypto";
 import { Throttle } from "./Throttle";
 import { getLogger } from "log4js";
 import axios from "axios";
-import { FileHandle } from "fs/promises";
 const pipeline = util.promisify(stream.pipeline);
 
 const logger = getLogger("File");
@@ -379,22 +378,13 @@ export class FileAgent {
         this.nameToFile.set(name, [file, subpath, false, new Throttle(1)]);
         return path;
     }
-    async getStream(name: string): Promise<Readable> {
+    async getBuffer(name: string) {
         this.checkInit();
-        const s = fs.createReadStream(await this.getPath(name));
-        await waitForOpen(s);
-        return s;
+        return fs.promises.readFile(await this.getPath(name));
     }
-    /** @deprecated  no auto close fd */
-    async getFd(name: string): Promise<number> {
+    async getString(name: string) {
         this.checkInit();
-        const s = fs.openSync(await this.getPath(name), "r");
-        return s;
-    }
-    async getFileHandler(name: string): Promise<FileHandle> {
-        this.checkInit();
-        const s = await fs.promises.open(await this.getPath(name), "r");
-        return s;
+        return fs.promises.readFile(await this.getPath(name), "utf-8");
     }
     async getPath(name: string): Promise<string> {
         this.checkInit();

src/Utilities/File.ts

@@ -26,6 +26,8 @@ import { stat } from "./Statistics";
 import * as crypto from "crypto";
 import { FileHandle } from "fs/promises";
 import { EmptyMeterResult, MeterResult } from "../Spawn/Meter";
+import { SerialPort } from "serialport";
+import { closePort } from "./Serial";
 
 const UsrCompileResultTransformer = {
     mle: JudgeResultKind.CompileMemoryLimitExceeded,
@@ -134,7 +136,7 @@ export abstract class JudgeAgent {
         const compileLog = await executableAgent.fileAgent.getPath(
             CompileLogName
         );
-        const compileLogSize = fs.statSync(compileLog).size;
+        const compileLogSize = (await fs.promises.stat(compileLog)).size;
         const exteaInfo = {
             compileTime: this.transformTime(compileSumTime),
             compileMessage: await readStream(
@@ -199,7 +201,10 @@ export abstract class JudgeAgent {
 
     protected async runJudge(
         executableAgent: ExecutableAgent,
-        judgeFunction: (testCase: TestCase) => Promise<JudgeCaseResult>
+        judgeFunction: (
+            testCase: TestCase,
+            judgeTimeout: number
+        ) => Promise<JudgeCaseResult>
     ): Promise<JudgeCaseResult[]> {
         const programResult = await executableAgent.program();
         let runResult: JudgeResult | undefined = undefined;
@@ -217,7 +222,10 @@ export abstract class JudgeAgent {
         const judgeCaseResults: JudgeCaseResult[] = [];
         if (this.judge.test) {
             for (const testCase of this.judge.test.cases) {
-                const caseResult = await judgeFunction(testCase);
+                const caseResult = await judgeFunction(
+                    testCase,
+                    executableAgent.configuredLanguage.judgeTimeout
+                );
                 judgeCaseResults.push(caseResult);
                 if (
                     caseResult.kind !== JudgeResultKind.Accepted &&
@@ -468,11 +476,50 @@ export class NormalJudgeAgent extends JudgeAgent {
 
         const caseResults = await this.runJudge(
             userExecutableAgent,
-            async (testCase) => {
+            async (testCase, judgeTimeout) => {
+                let kind = JudgeResultKind.SystemError;
+                let time = 0;
+                let memory = 0;
+                const path = (await SerialPort.list()).find(
+                    (info) =>
+                        info.serialNumber &&
+                        getConfig().fpga.serial.includes(info.serialNumber)
+                )?.path;
+                if (path) {
+                    const [port, input, output] = await Promise.all([
+                        SerialPort.binding.open({
+                            baudRate: 250000,
+                            path,
+                        }),
+                        this.fileAgent.getBuffer(testCase.input),
+                        this.fileAgent.getBuffer(testCase.output),
+                    ]);
+                    const start = Date.now();
+                    port.write(input);
+                    const timeout = setTimeout(closePort, judgeTimeout, port);
+                    try {
+                        const { buffer, bytesRead } = await port.read(
+                            Buffer.alloc(output.length),
+                            0,
+                            output.length
+                        );
+                        if (buffer.equals(output)) {
+                            kind = JudgeResultKind.Accepted;
+                        } else {
+                            kind = JudgeResultKind.WrongAnswer;
+                        }
+                        memory = bytesRead;
+                    } catch {
+                        kind = JudgeResultKind.TimeLimitExceeded;
+                    }
+                    clearTimeout(timeout);
+                    closePort(port);
+                    time = Date.now() - start;
+                }
                 return {
-                    kind: JudgeResultKind.OutpuLimitExceeded,
-                    time: 0,
-                    memory: 0,
+                    kind,
+                    time,
+                    memory,
                 };
             }
         );

src/Utilities/Judge.ts

@@ -0,0 +1,7 @@
+import type { BindingPortInterface } from "@serialport/bindings-cpp";
+
+export function closePort(port: BindingPortInterface) {
+    if (port.isOpen) {
+        port.close();
+    }
+}