Merge pull request #69 from arnaud-m/feature-64

arnaud-m · web-flow · commit 72a1b8f10c6d · 2022-11-29T15:15:38.000+01:00
Improve logging of cryptarithm generation close #64
diff --git a/src/main/java/cryptator/Cryptagen.java b/src/main/java/cryptator/Cryptagen.java
@@ -104,14 +104,10 @@ protected CryptagenOptionsParser() {
 
         @Override
         protected void configureLoggers() {
-            if (config.isDryRun()) {
-                getLogger().setLevel(config.isVerbose() ? Level.FINE : Level.CONFIG);
+            if (config.isVerbose()) {
+                JULogUtil.configureLoggers(Level.ALL);
             } else {
-                if (config.isVerbose()) {
-                    JULogUtil.setLevel(Level.CONFIG, getLogger());
-                } else {
-                    JULogUtil.setLevel(Level.WARNING, CryptaSolver.LOGGER);
-                }
+                JULogUtil.setLevel(Level.WARNING, CryptaSolver.LOGGER);
             }
         }
 
@@ -124,9 +120,6 @@ public String getArgumentName() {
     private static CryptaBiConsumer buildBiConsumer(final CryptagenConfig config) {
         CryptaBiConsumer consumer = new CryptaBiConsumer(LOGGER);
         consumer.withCryptarithmLog();
-        if (config.isCheckSolution()) {
-            consumer.withSolutionCheck(config.getArithmeticBase());
-        }
         if (config.isExportGraphiz()) {
             consumer.withGraphvizExport();
         }
@@ -138,8 +131,10 @@ private static int generate(final WordArray words, final CryptagenConfig config)
         final CryptaBiConsumer cons = buildBiConsumer(config);
         try {
             gen.generate(cons);
+            LOGGER.log(Level.INFO, "Found {0} cryptarithm(s).", cons.getSolutionCount());
+
         } catch (CryptaModelException e) {
-            LOGGER.log(Level.SEVERE, "fail to build the model.", e);
+            LOGGER.log(Level.SEVERE, "Fail to build the model.", e);
             return -1;
         }
         return gen.getErrorCount() + cons.getErrorCount();
diff --git a/src/main/java/cryptator/choco/ChocoLogger.java b/src/main/java/cryptator/choco/ChocoLogger.java
@@ -17,6 +17,8 @@
 import org.chocosolver.solver.Solution;
 import org.chocosolver.solver.Solver;
 
+import cryptator.specs.IChocoModel;
+
 public final class ChocoLogger {
 
     private final Logger logger;
@@ -26,6 +28,10 @@ public ChocoLogger(Logger logger) {
         this.logger = logger;
     }
 
+    public void logOnModel(final IChocoModel m) {
+        logOnModel(m.getModel());
+    }
+
     public void logOnModel(final Model model) {
         if (logger.isLoggable(Level.CONFIG)) {
             logger.log(Level.CONFIG, "Model diagnostics:\n{0}", toDimacs(model));
@@ -40,10 +46,18 @@ public void logOnSolution(final Solution solution) {
         }
     }
 
+    public void logOnSolution(final IChocoModel m) {
+        logOnSolution(m.getModel());
+    }
+
     public void logOnSolution(final Model model) {
         logOnSolution(new Solution(model));
     }
 
+    public void logOnSolver(final IChocoModel m) {
+        logOnSolver(m.getModel());
+    }
+
     public void logOnSolver(Model model) {
         if (logger.isLoggable(Level.INFO)) {
             logger.log(Level.INFO, "Solver diagnostics:\n{0}", toDimacs(model.getSolver()));
diff --git a/src/main/java/cryptator/gen/CryptaListGenerator.java b/src/main/java/cryptator/gen/CryptaListGenerator.java
@@ -8,6 +8,7 @@
  */
 package cryptator.gen;
 
+import java.util.Optional;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -20,6 +21,8 @@
 import org.chocosolver.solver.Solution;
 import org.chocosolver.solver.Solver;
 
+import cryptator.choco.ChocoLogger;
+import cryptator.cmd.CryptaBiConsumer;
 import cryptator.cmd.WordArray;
 import cryptator.config.CryptagenConfig;
 import cryptator.solver.AdaptiveSolver;
@@ -35,19 +38,22 @@ public class CryptaListGenerator implements ICryptaGenerator {
 
     private static final int TICK = 1000;
 
-    private WordArray words;
+    private final WordArray words;
 
-    private CryptagenConfig config;
+    private final CryptagenConfig config;
 
-    private Logger logger;
+    private final Logger logger;
 
-    private AtomicInteger errorCount;
+    private final ChocoLogger clog;
+
+    private final AtomicInteger errorCount;
 
     public CryptaListGenerator(final WordArray words, final CryptagenConfig config, final Logger logger) {
         super();
         this.words = words;
         this.config = config;
         this.logger = logger;
+        this.clog = new ChocoLogger(logger);
         this.errorCount = new AtomicInteger();
     }
 
@@ -109,7 +115,7 @@ private static void parallelSolve(final CryptaGenModel gen, final Consumer<ICryp
     @Override
     public void generate(final BiConsumer<ICryptaNode, ICryptaSolution> consumer) throws CryptaModelException {
         final CryptaGenModel gen = buildModel();
-        logger.log(Level.FINE, "Display model{0}", gen.getModel());
+        clog.logOnModel(gen);
 
         final Consumer<ICryptaNode> cons = buildConsumer(gen, consumer);
 
@@ -119,10 +125,7 @@ public void generate(final BiConsumer<ICryptaNode, ICryptaSolution> consumer) th
         } else {
             parallelSolve(gen, cons, nthreads);
         }
-
-        if (logger.isLoggable(Level.FINE)) {
-            logger.log(Level.FINE, "{0}", gen.getModel().getSolver().getMeasures());
-        }
+        clog.logOnSolver(gen);
     }
 
     // FIXME are consumers thread-safe ? they are used in parallel !
@@ -138,37 +141,13 @@ private class LogConsumer implements Consumer<ICryptaNode> {
         @Override
         public void accept(final ICryptaNode t) {
             if (logger.isLoggable(Level.CONFIG)) {
-                logger.log(Level.CONFIG, "candidate: {0}", TreeUtils.writeInorder(t));
-                if (logger.isLoggable(Level.FINE)) {
-                    solution.record();
-                    logger.log(Level.FINE, "candidate from solver:\n{0}", solution);
-                }
+                logger.log(Level.CONFIG, "Candidate cryptarithm:\n{0}", TreeUtils.writeInorder(t));
+                clog.logOnSolution(solution);
             }
         }
 
     }
 
-    private static class SolutionCollect implements Consumer<ICryptaSolution> {
-
-        private int solutionCount;
-
-        private ICryptaSolution solution;
-
-        @Override
-        public void accept(final ICryptaSolution u) {
-            solutionCount++;
-            this.solution = u;
-        }
-
-        public final boolean hasUniqueSolution() {
-            return solutionCount == 1;
-        }
-
-        public final ICryptaSolution getSolution() {
-            return solution;
-        }
-    }
-
     private class GenerateConsumer implements Consumer<ICryptaNode> {
 
         private final ICryptaSolver solver;
@@ -182,17 +161,26 @@ private class GenerateConsumer implements Consumer<ICryptaNode> {
             this.solver.limitSolution(2);
         }
 
+        private CryptaBiConsumer buildBiConsumer() {
+            CryptaBiConsumer consumer = new CryptaBiConsumer(logger);
+            if (config.isCheckSolution()) {
+                consumer.withSolutionCheck(config.getArithmeticBase());
+            }
+            return consumer;
+        }
+
         @Override
         public void accept(final ICryptaNode t) {
             try {
-                final SolutionCollect collect = new SolutionCollect();
+                final CryptaBiConsumer collect = buildBiConsumer();
                 solver.solve(t, config, collect);
-                if (collect.hasUniqueSolution()) {
-                    internal.accept(t, collect.getSolution());
+                Optional<ICryptaSolution> solution = collect.getUniqueSolution();
+                if (solution.isPresent()) {
+                    internal.accept(t, solution.get());
                 }
             } catch (CryptaModelException | CryptaSolverException e) {
                 errorCount.incrementAndGet();
-                logger.log(Level.WARNING, "failed to solve the cryptarithm", e);
+                logger.log(Level.WARNING, "Fail to solve the cryptarithm", e);
             }
         }
     }
diff --git a/src/main/java/cryptator/solver/CryptaModel.java b/src/main/java/cryptator/solver/CryptaModel.java
@@ -13,12 +13,13 @@
 import org.chocosolver.solver.Model;
 import org.chocosolver.solver.variables.IntVar;
 
+import cryptator.specs.IChocoModel;
 import cryptator.specs.ICryptaSolution;
 
 /**
  * The Class CryptaModel encapsulates the choco model and solution.
  */
-public final class CryptaModel {
+public final class CryptaModel implements IChocoModel {
 
     /** The model. */
     private final Model model;
@@ -39,11 +40,7 @@ public CryptaModel(final Model model, final Map<Character, IntVar> symbolsToVari
         this.solution = new CryptaSolutionVars(symbolsToVariables);
     }
 
-    /**
-     * Gets the model.
-     *
-     * @return the model
-     */
+    @Override
     public Model getModel() {
         return model;
     }
diff --git a/src/main/java/cryptator/solver/CryptaSolver.java b/src/main/java/cryptator/solver/CryptaSolver.java
@@ -91,7 +91,7 @@ public boolean solve(final ICryptaNode cryptarithm, final CryptaConfig config,
         final CryptaModel m = modeler.model(cryptarithm, config);
         logOnCryptarithm(cryptarithm);
         logOnConfiguration(config);
-        CLOG.logOnModel(m.getModel());
+        CLOG.logOnModel(m);
 
         final Solver s = m.getModel().getSolver();
         if (timeLimit > 0) {
@@ -111,7 +111,7 @@ public boolean solve(final ICryptaNode cryptarithm, final CryptaConfig config,
                 solutionCount++;
             }
         }
-        CLOG.logOnSolver(m.getModel());
+        CLOG.logOnSolver(m);
         return solutionCount > 0;
     }
 
diff --git a/src/main/java/cryptator/specs/IChocoModel.java b/src/main/java/cryptator/specs/IChocoModel.java
@@ -0,0 +1,25 @@
+/**
+ * This file is part of cryptator, https://github.com/arnaud-m/cryptator
+ *
+ * Copyright (c) 2022, Université Côte d'Azur. All rights reserved.
+ *
+ * Licensed under the BSD 3-clause license.
+ * See LICENSE file in the project root for full license information.
+ */
+package cryptator.specs;
+
+import org.chocosolver.solver.Model;
+
+/**
+ * Getter interface of a Choco model.
+ */
+public interface IChocoModel {
+
+    /**
+     * Gets the model.
+     *
+     * @return the model
+     */
+    Model getModel();
+
+}
diff --git a/src/main/java/cryptator/specs/ICryptaGenModel.java b/src/main/java/cryptator/specs/ICryptaGenModel.java
@@ -8,22 +8,14 @@
  */
 package cryptator.specs;
 
-import org.chocosolver.solver.Model;
 import org.chocosolver.solver.variables.BoolVar;
 import org.chocosolver.solver.variables.IntVar;
 
 /**
  * The Interface ICryptaGenVariables to access variables used for generating
  * cryptarithms.
  */
-public interface ICryptaGenModel {
-
-    /**
-     * Gets the model.
-     *
-     * @return the model
-     */
-    Model getModel();
+public interface ICryptaGenModel extends IChocoModel {
 
     /**
      * Gets the number of words or word variables.

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ public boolean solve(final ICryptaNode cryptarithm, final CryptaConfig config,`
`91`	`91`	`final CryptaModel m = modeler.model(cryptarithm, config);`
`92`	`92`	`logOnCryptarithm(cryptarithm);`
`93`	`93`	`logOnConfiguration(config);`
`94`		`- CLOG.logOnModel(m.getModel());`
	`94`	`+ CLOG.logOnModel(m);`
`95`	`95`
`96`	`96`	`final Solver s = m.getModel().getSolver();`
`97`	`97`	`if (timeLimit > 0) {`
`@@ -111,7 +111,7 @@ public boolean solve(final ICryptaNode cryptarithm, final CryptaConfig config,`
`111`	`111`	`solutionCount++;`
`112`	`112`	`}`
`113`	`113`	`}`
`114`		`- CLOG.logOnSolver(m.getModel());`
	`114`	`+ CLOG.logOnSolver(m);`
`115`	`115`	`return solutionCount > 0;`
`116`	`116`	`}`
`117`	`117`