From f52cfc4bfe0667c0e4f431db08d4248303e3b4e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9A=D0=B8=D1=81=D0=B5=D0=BB=D1=91=D0=B2=20=D0=92=D0=BB?= =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D1=81=D0=BB=D0=B0=D0=B2?= Date: Tue, 14 May 2019 16:39:12 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A2=D0=B5=D1=81=D1=82=D0=B8=D1=80=D0=BE?= =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D0=B5=20=D1=81=20=D1=80=D0=B0=D0=B7?= =?UTF-8?q?=D0=BD=D1=8B=D0=BC=D0=B8=20=D0=BF=D0=B0=D1=80=D0=B0=D0=BC=D0=B5?= =?UTF-8?q?=D1=82=D1=80=D0=B0=D0=BC=D0=B8,=20time=20limit.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/inport/Main.java | 109 +++++++++++++----------- src/inport/Testing.java | 178 +++++++++++++++++++++++++++++++++------- 2 files changed, 207 insertions(+), 80 deletions(-) diff --git a/src/inport/Main.java b/src/inport/Main.java index 9976781..609eaf0 100644 --- a/src/inport/Main.java +++ b/src/inport/Main.java @@ -4,12 +4,18 @@ import java.io.*; import java.util.ArrayList; import java.util.Map; import java.util.TreeMap; +import java.util.function.BiFunction; +import java.util.function.Function; import static inport.Testing.*; +import static inport.Testing.solveTaskWithPartialCargoOp; + import inport.ConversionUtil.*; public class Main { + static final int DEFAULT_TIME_LIMIT_S = 1; + public static void main(String[] args) { if (args.length == 0) { System.out.println("To few arguments."); @@ -32,9 +38,9 @@ public class Main { String error; if (!task.isTypified()) { - error = solveTask_1(task); + error = solveTask_1(task, DEFAULT_TIME_LIMIT_S); } else { - error = solveTask_2(task); + error = solveTask_2(task, DEFAULT_TIME_LIMIT_S); } long finish = System.currentTimeMillis(); @@ -89,69 +95,72 @@ public class Main { break; } case "debug" : { - String fileName = "experiment/in.ipp"; - String solverResults = "temp_data/solver_results.txt"; - String output = "experiment/debug_info.txt"; - - TaskCase task = new TaskCase(); - try { - task.deserialize(fileName); - } catch (IOException e) { - System.out.println(e.getMessage()); - break; - } - String error = solveTask_2(task); - - if (!error.isEmpty()) { - System.out.println("Error : " + error); - break; - } else { - task.serialize(fileName); - } - - debugInfo(task, solverResults, output); - + debug(Testing::solveTask_2, DEFAULT_TIME_LIMIT_S); break; } case "debug 2" : { - String fileName = "experiment/in.ipp"; - String solverResults = "temp_data/solver_results.txt"; - String output = "experiment/debug_info.txt"; - - TaskCase task = new TaskCase(); - try { - task.deserialize(fileName); - } catch (IOException e) { - System.out.println(e.getMessage()); - break; - } - String error = solveTaskWithPartialCargoOp(task); - - if (!error.isEmpty()) { - System.out.println("Error : " + error); - break; - } else { - task.serialize(fileName); - } - - debugInfo(task, solverResults, output); - + debug(Testing::solveTaskWithPartialCargoOp, DEFAULT_TIME_LIMIT_S); break; } case "testing" : - test_2(); + test_2(DEFAULT_TIME_LIMIT_S); break; case "testing_with_partial_op": - testWithPartialOp(); + testWithPartialOp(DEFAULT_TIME_LIMIT_S); break; - case "testing_exp": - test_2_exp(); + case "different_parameters": + try { + testingWithDiffParameters( + "tests/with_typing/Case2.tipp", + 1, 30, + 16, 35, + 1.1, 30); + +// testingWithDiffParameters( +// "tests/with_typing/TaskT.tipp", +// 10, 10, +// 32, 32, +// 1.1, 10); + + } catch (IOException ex) { + System.out.println(ex.getMessage()); + } break; default: System.out.println("Unknown type \"" + type + "\""); } } + private static void debug(BiFunction solver, int timeLimitS) { + String fileName = "experiment/in.ipp"; + String solverResults = "temp_data/solver_results.txt"; + String output = "experiment/debug_info.txt"; + + TaskCase task = new TaskCase(); + try { + task.deserialize(fileName); + } catch (IOException e) { + System.out.println(e.getMessage()); + return; + } + + long start = System.currentTimeMillis(); + + String error = solver.apply(task, timeLimitS); + + long finish = System.currentTimeMillis(); + System.out.println(" " + (finish - start) / 1000.0 + " s"); + + if (!error.isEmpty()) { + System.out.println("Error : " + error); + return; + } else { + task.serialize(fileName); + } + + debugInfo(task, solverResults, output); + } + private static void debugInfo(TaskCase task, String solverResults, String output) { try (FileInputStream fstream = new FileInputStream(solverResults)) { BufferedReader br = new BufferedReader(new InputStreamReader(fstream)); diff --git a/src/inport/Testing.java b/src/inport/Testing.java index ea5f85b..2c53200 100644 --- a/src/inport/Testing.java +++ b/src/inport/Testing.java @@ -2,8 +2,12 @@ package inport; import java.io.*; import java.util.ArrayList; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; import java.util.function.BiConsumer; -import java.util.function.Function; +import java.util.function.BiFunction; import java.util.stream.Collectors; public class Testing { @@ -19,52 +23,62 @@ public class Testing { dir.delete(); } - public static String solveTask_1(TaskCase task) { + public static String solveTask_1(TaskCase task, int timeLimitS) { return solveTask( task, "conversion_1.mzn", ConversionUtil::portToMiniZinc_1, - ConversionUtil::resolveMiniZincResults); + ConversionUtil::resolveMiniZincResults, + timeLimitS); } - public static String solveTask_2(TaskCase task) { + public static String solveTask_2(TaskCase task, int timeLimitS) { return solveTask( task, "conversion_2.mzn", ConversionUtil::portToMiniZinc_2, - ConversionUtil::resolveMiniZincResults); + ConversionUtil::resolveMiniZincResults, + timeLimitS); } - public static String solveTaskWithPartialCargoOp(TaskCase task) { + public static String solveTaskWithPartialCargoOp(TaskCase task, int timeLimitS) { return solveTask( task, "conversion_2_with_partial_cargo_operations.mzn", ConversionUtil::portToMiniZinc_2, - ConversionUtil::resolveMiniZincResults); + ConversionUtil::resolveMiniZincResults, + timeLimitS); } - public static String solveTask_2_0(TaskCase task) { + public static String solveTask_2_0(TaskCase task, int timeLimitS) { return solveTask( task, "conversion_2.0.mzn", ConversionUtil::portToMiniZinc_2, ConversionUtil::resolveMiniZincResults, - "temp_data_2"); + "temp_data_2", + timeLimitS); } public static String solveTask(TaskCase task, String constraintName, BiConsumer converterToMinizincFormat, - BiConsumer interpreter) { - return solveTask(task, constraintName, converterToMinizincFormat, interpreter, "temp_data"); + BiConsumer interpreter, + int timeLimitS) { + return solveTask(task, constraintName, converterToMinizincFormat, interpreter, "temp_data", timeLimitS); } + private final static Lock lock = new ReentrantLock(); + private final static Condition condition = lock.newCondition(); + private static Boolean isDestroyed; + /* Возвращает описание ошибки, если ошибки не было, то пустую строку. */ public static String solveTask(TaskCase task, String constraintName, BiConsumer converterToMinizincFormat, BiConsumer interpreter, - String tempDir) { + String tempDir, + final int timeLimitS) { File directory = new File(tempDir); if (!directory.exists()) { directory.mkdir(); @@ -90,17 +104,61 @@ public class Testing { constraints, minizincData, "-o", solverResults); - Process process = pb.start(); + lock.lock(); + isDestroyed = false; + lock.unlock(); + + final Process process = pb.start(); + + Thread killer = new Thread(() -> { + lock.lock(); + long start = System.currentTimeMillis(); + try { + while (process.isAlive()) { + long currentTimeMillis = System.currentTimeMillis(); + + if (currentTimeMillis - start > timeLimitS * 1000) { + process.destroyForcibly(); + isDestroyed = true; + break; + } + condition.await(timeLimitS * 1000 - (currentTimeMillis - start), TimeUnit.MILLISECONDS); + } + } catch (InterruptedException ex) { + isDestroyed = true; + process.destroyForcibly(); + } finally { + lock.unlock(); + } + }); + + killer.start(); int exitCode = process.waitFor(); + + lock.lock(); + try { + condition.signal(); + } finally { + lock.unlock(); + } + killer.join(); assert exitCode == 0; + lock.lock(); + try { + if (isDestroyed) { + return "Time limit exceeded."; + } + }finally { + lock.unlock(); + } + BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream())); String output = br.lines().collect(Collectors.joining("\n")); // BufferedReader br2 = new BufferedReader(new InputStreamReader(process.getErrorStream())); // String errors = br.lines().collect(Collectors.joining("\n")); - // System.out.println("output : " + output); // System.out.println("errors : " + errors); @@ -118,7 +176,7 @@ public class Testing { return ""; } - private static String testCase(String file, Function solver) { + private static String testCase(String file, BiFunction solver, int timeLimitS) { TaskCase task = new TaskCase(); try { task.deserialize(file); @@ -126,7 +184,7 @@ public class Testing { return "Error : " + e.getMessage(); } double expected_result = task.getSolution_result(); - String error = solver.apply(task); + String error = solver.apply(task, timeLimitS); double result = task.getSolution_result(); if (!error.isEmpty()) { return "Error : " + error; @@ -137,7 +195,7 @@ public class Testing { return "OK"; } - public static void testGroup(String group, Function solver) { + public static void testGroup(String group, BiFunction solver, int timeLimitS) { File testDir = new File("tests/" + group + "/"); System.out.println(testDir.toString() + " :"); @@ -148,10 +206,10 @@ public class Testing { long start = System.currentTimeMillis(); - String res = testCase(testDir.toString() + "/" + file.getName(), solver); + String res = testCase(testDir.toString() + "/" + file.getName(), solver, timeLimitS); long finish = System.currentTimeMillis(); - System.out.println(" " + res + ", " + (finish - start) + " ms"); + System.out.println(" " + res + ", " + (finish - start) / 1000.0 + " s"); if (res.equals("OK")) { nPassedTests++; } @@ -159,20 +217,80 @@ public class Testing { System.out.println("Passed tests : " + nPassedTests + "/" + testDir.listFiles().length); } - public static void test_1() { - testGroup("without_typing", Testing::solveTask_1); + public static void test_1(int timeLimitS) { + testGroup("without_typing", Testing::solveTask_1, timeLimitS); } - static void test_2() { - testGroup("with_typing", Testing::solveTask_2); - } - public static void testWithPartialOp() { - testGroup("with_typing", Testing::solveTaskWithPartialCargoOp); + static void test_2(int timeLimitS) { + testGroup("with_typing", Testing::solveTask_2, timeLimitS); } - static void test_2_0() { - testGroup("with_typing", Testing::solveTask_2_0); + public static void testWithPartialOp(int timeLimitS) { + testGroup("with_typing", Testing::solveTaskWithPartialCargoOp, timeLimitS); } - static void test_2_exp() { - testGroup("experiments", Testing::solveTask_2); + + static void testingWithDiffParameters(String test, + double cargoMult, double cargoMultMax, + double nIntevals, double nIntervalsMax, + double step, int timeLimitS) throws IOException { + System.out.println(test); + System.out.print("* "); + for (double i = Math.ceil(nIntevals); i <= nIntervalsMax; i = Math.ceil(step * i)) { + System.out.print(i + " "); + } + System.out.println(); + + + File directory = new File("debug_dir/"); + if (!directory.exists()) { + directory.mkdir(); + } + + for (double mult = Math.ceil(cargoMult); mult <= cargoMultMax; mult = Math.ceil(step * mult)) { + System.out.print(mult + " "); + for (double i = Math.ceil(nIntevals); i <= nIntervalsMax; i = Math.ceil(step * i)) { + TaskCase taskCase = new TaskCase(); + taskCase.deserialize(test); + + taskCase.setPlanningInterval(i); + + for (OperationTemplate template : taskCase.getTemplates()) { + if (template instanceof LoadingTemplate) { + LoadingTemplate op = (LoadingTemplate)template; + op.setIntensity(op.getIntensity() * mult); + } + } + for (TransportShip ship : taskCase.getShips()) { + ship.setCargoMax(ship.getCargoMax() * mult); + } + for (StorageState state : taskCase.getStorageInitialState()) { + state.setCargoState(state.getCargoState() * mult); + } + for (StorageState state : taskCase.getStorageEndState()) { + state.setCargoState(state.getCargoState() * mult); + } + for (Storage storage : taskCase.getStorages()) { + storage.setVolume(storage.getVolume() * mult); + } + for (Operation operation : taskCase.getSolution()) { + final double m = mult; + operation.setIntensity(operation.getIntensity().map(v -> (int)(v * m))); + } + +// taskCase.serialize(directory + "/" + mult + " " + i + ".tipp"); + + long start = System.currentTimeMillis(); + String result = solveTaskWithPartialCargoOp(taskCase, timeLimitS); + long finish = System.currentTimeMillis(); + + if (result.isEmpty()) { + System.out.print((finish - start) / 1000.0 + " "); + } else if (result.equals("Time limit exceeded.")) { + System.out.print("TL "); + } else { + System.out.print("ER "); + } + } + System.out.println(); + } } } -- GitLab