From 12e85e62f96b2b3730b9f7772c0a32016086da92 Mon Sep 17 00:00:00 2001 From: hneemann Date: Thu, 9 May 2024 12:25:00 +0200 Subject: [PATCH] fixed a bug in max path len calculation --- .../digital/analyse/DependencyAnalyser.java | 24 +------ .../digital/analyse/ModelAnalyser.java | 2 +- .../digital/analyse/PathLenAnalyser.java | 67 +++++++++++++++++++ 3 files changed, 71 insertions(+), 22 deletions(-) create mode 100644 src/main/java/de/neemann/digital/analyse/PathLenAnalyser.java diff --git a/src/main/java/de/neemann/digital/analyse/DependencyAnalyser.java b/src/main/java/de/neemann/digital/analyse/DependencyAnalyser.java index 60378f12b..df6fd5407 100644 --- a/src/main/java/de/neemann/digital/analyse/DependencyAnalyser.java +++ b/src/main/java/de/neemann/digital/analyse/DependencyAnalyser.java @@ -9,8 +9,6 @@ import de.neemann.digital.core.*; import de.neemann.digital.core.Observer; import de.neemann.digital.draw.elements.PinException; import de.neemann.digital.lang.Lang; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import java.util.*; @@ -20,9 +18,7 @@ import java.util.*; * really depends on. */ public class DependencyAnalyser { - private static final Logger LOGGER = LoggerFactory.getLogger(DependencyAnalyser.class); private final HashMap> dependencyMap; - private int maxDepth; /** * Creates a new instance @@ -35,10 +31,9 @@ public class DependencyAnalyser { dependencyMap = new HashMap<>(); for (Signal s : modelAnalyser.getInputs()) { Set effected = new HashSet<>(); - backtracking(s.getValue(), effected, 0); + backtracking(s.getValue(), effected); dependencyMap.put(s, effected); } - LOGGER.info("circuit max depth: " + getMaxPathLen()); } /** @@ -71,31 +66,18 @@ public class DependencyAnalyser { return num; } - private void backtracking(ObservableValue value, Set effected, int depth) throws PinException, BacktrackException { - if (depth > maxDepth) - maxDepth = depth; + private void backtracking(ObservableValue value, Set effected) throws PinException, BacktrackException { if (!effected.contains(value)) { effected.add(value); for (Observer o : value.getObservers()) { if ((o instanceof NodeInterface)) { ObservableValues outputs = ((NodeInterface) o).getOutputs(); - int d = depth; - if (!(o instanceof NodeWithoutDelay)) d++; for (ObservableValue co : outputs) - backtracking(co, effected, d); + backtracking(co, effected); } else throw new BacktrackException(Lang.get("err_backtrackOf_N_isImpossible", o.getClass().getSimpleName())); } } } - - /** - * Returns the max depth of the circuit. - * - * @return the max depth of the circuit - */ - public int getMaxPathLen() { - return maxDepth; - } } diff --git a/src/main/java/de/neemann/digital/analyse/ModelAnalyser.java b/src/main/java/de/neemann/digital/analyse/ModelAnalyser.java index 6435a213c..bb77f9939 100644 --- a/src/main/java/de/neemann/digital/analyse/ModelAnalyser.java +++ b/src/main/java/de/neemann/digital/analyse/ModelAnalyser.java @@ -324,7 +324,7 @@ public class ModelAnalyser { if (!Main.isExperimentalMode() && !modelContainsSwitches()) CycleDetector.checkForCycles(inputs); - DependencyAnalyser da = new DependencyAnalyser(this); + PathLenAnalyser da = new PathLenAnalyser(this); return da.getMaxPathLen(); } diff --git a/src/main/java/de/neemann/digital/analyse/PathLenAnalyser.java b/src/main/java/de/neemann/digital/analyse/PathLenAnalyser.java new file mode 100644 index 000000000..5e8ea807c --- /dev/null +++ b/src/main/java/de/neemann/digital/analyse/PathLenAnalyser.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017 Helmut Neemann + * Use of this source code is governed by the GPL v3 license + * that can be found in the LICENSE file. + */ +package de.neemann.digital.analyse; + +import de.neemann.digital.core.Observer; +import de.neemann.digital.core.*; +import de.neemann.digital.draw.elements.PinException; +import de.neemann.digital.lang.Lang; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.*; + +/** + * Used to determine the max path len in the circuit. + * This means the max number of gates between on of the inputs and one of the outputs. + */ +public class PathLenAnalyser { + private static final Logger LOGGER = LoggerFactory.getLogger(PathLenAnalyser.class); + private int maxDepth; + + /** + * Creates a new instance + * + * @param modelAnalyser the model analyser + * @throws BacktrackException BacktrackException + * @throws PinException PinException + */ + public PathLenAnalyser(ModelAnalyser modelAnalyser) throws BacktrackException, PinException { + for (Signal s : modelAnalyser.getInputs()) { + LOGGER.debug(s.getName()); + HashMap found = new HashMap<>(); + backtracking(s.getValue(), found, 0); + } + } + + private void backtracking(ObservableValue value, HashMap found, int depth) throws PinException, BacktrackException { + Integer d = found.get(value); + if (d == null || d < depth) { + found.put(value, depth); + + if (depth > maxDepth) + maxDepth = depth; + for (Observer o : value.getObservers()) { + if ((o instanceof NodeInterface)) { + LOGGER.debug(o.toString()); + ObservableValues outputs = ((NodeInterface) o).getOutputs(); + int de = depth; + if (!(o instanceof NodeWithoutDelay)) de++; + for (ObservableValue co : outputs) + backtracking(co, found, de); + } else + throw new BacktrackException(Lang.get("err_backtrackOf_N_isImpossible", o.getClass().getSimpleName())); + } + } + } + + /** + * @return the max path len in the circuit + */ + public int getMaxPathLen() { + return maxDepth; + } +}