diff --git a/modeling/AVATAR/testMatteo.xml b/modeling/AVATAR/testMatteo.xml index e28769f215eb2a9b0acbd7cd104dea0fe34a5816..86fafcbe43b1c4beb547465bdc2e08ca9b0930d9 100644 --- a/modeling/AVATAR/testMatteo.xml +++ b/modeling/AVATAR/testMatteo.xml @@ -1,6 +1,6 @@ <?xml version="1.0" encoding="UTF-8"?> -<TURTLEGMODELING version="1.0beta" ANIMATE_INTERACTIVE_SIMULATION="true" ACTIVATE_PENALTIES="true" UPDATE_INFORMATION_DIPLO_SIM="true" ANIMATE_WITH_INFO_DIPLO_SIM="true" OPEN_DIAG_DIPLO_SIM="false" LAST_SELECTED_MAIN_TAB="1" LAST_SELECTED_SUB_TAB="1"> +<TURTLEGMODELING version="1.0beta" ANIMATE_INTERACTIVE_SIMULATION="true" ACTIVATE_PENALTIES="true" UPDATE_INFORMATION_DIPLO_SIM="true" ANIMATE_WITH_INFO_DIPLO_SIM="true" OPEN_DIAG_DIPLO_SIM="false" LAST_SELECTED_MAIN_TAB="1" LAST_SELECTED_SUB_TAB="4"> <Modeling type="AVATAR Design" nameTab="Design1" tabs="Block Diagram$Main$P0$P2$P3$P1$DR" > <AVATARBlockDiagramPanel name="Block Diagram" minX="10" maxX="2500" minY="10" maxY="1500" zoom="1.0" > diff --git a/src/main/java/avatartranslator/AvatarBlock.java b/src/main/java/avatartranslator/AvatarBlock.java index b159cc322356be4a354bedf4374b634ae6872058..4ff2d674eb4fd398e85e339be42ffd89ede0fd16 100644 --- a/src/main/java/avatartranslator/AvatarBlock.java +++ b/src/main/java/avatartranslator/AvatarBlock.java @@ -195,6 +195,28 @@ public class AvatarBlock extends AvatarElement implements AvatarStateMachineOwne return sb.toString(); } + public String toShortString() { + //Thread.currentThread().dumpStack(); + StringBuffer sb = new StringBuffer("block:" + getName() + " ID=" + getID() + " \n"); + if (getFather() != null) { + sb.append(" subblock of: " + getFather().getName() + " ID=" + getFather().getID()+ "\n"); + } else { + sb.append(" top level block\n"); + } + for(AvatarAttribute attribute: attributes) { + sb.append(" attribute: " + attribute.toString() + " ID=" + attribute.getID() + "\n"); + } + for(AvatarMethod method: methods) { + sb.append(" method: " + method.toString() + " ID=" + method.getID() + "\n"); + } + for(AvatarSignal signal: signals) { + sb.append(" signal: " + signal.toString() + " ID=" + signal.getID() + "\n"); + } + + + return sb.toString(); + } + public int attributeNb() { return attributes.size(); } diff --git a/src/main/java/avatartranslator/AvatarBlockTemplate.java b/src/main/java/avatartranslator/AvatarBlockTemplate.java index 80bf36053b525d3ce68ab5f64f6ff6cbeb30650d..92190d2e333b72366debc0d1102e994735f3b40e 100644 --- a/src/main/java/avatartranslator/AvatarBlockTemplate.java +++ b/src/main/java/avatartranslator/AvatarBlockTemplate.java @@ -389,7 +389,7 @@ public class AvatarBlockTemplate { at.setGuard("duration>0"); at = makeAvatarEmptyTransitionBetween(ab, asm, stepRead, activatedState, _refB); at.setDelays("2", "2"); - at.addAction("durattion=duration-step"); + at.addAction("duration = duration - step"); // Preempted AvatarActionOnSignal preemptRead = new AvatarActionOnSignal("read_" + preemptP.getSignalName(), preemptP, _refB); @@ -431,7 +431,7 @@ public class AvatarBlockTemplate { AvatarSignal stepP = new AvatarSignal("stepP", AvatarSignal.IN, _refB); AvatarAttribute att1 = new AvatarAttribute("step", AvatarType.INTEGER, ab, _refB); stepP.addParameter(att1); - AvatarSignal deactivatedP = new AvatarSignal("deactivated", AvatarSignal.IN, _refB); + AvatarSignal deactivatedP = new AvatarSignal("deactivatedP", AvatarSignal.IN, _refB); AvatarSignal reactivatedP = new AvatarSignal("reactivatedP", AvatarSignal.IN, _refB); AvatarSignal finishP = new AvatarSignal("finishP", AvatarSignal.OUT, _refB); @@ -509,6 +509,7 @@ public class AvatarBlockTemplate { // Making a step AvatarActionOnSignal stepRead = new AvatarActionOnSignal("read_" + stepP.getSignalName(), stepP, _refB); + stepRead.addValue("step"); asm.addElement(stepRead); at = makeAvatarEmptyTransitionBetween(ab, asm, activatedState, stepRead, _refB); at.setGuard("duration>0"); @@ -555,7 +556,7 @@ public class AvatarBlockTemplate { // Create attributes - AvatarAttribute h = new AvatarAttribute("duration", AvatarType.INTEGER, ab, _refB); + AvatarAttribute h = new AvatarAttribute("h", AvatarType.INTEGER, ab, _refB); h.setInitialValue("" + 0); ab.addAttribute(h); @@ -581,12 +582,14 @@ public class AvatarBlockTemplate { // Tick AvatarActionOnSignal aaosWrite = new AvatarActionOnSignal("sendTickIn_" + tick.getSignalName(), tick, _refB); asm.addElement(aaosWrite); + aaosWrite.addValue("step"); at = makeAvatarEmptyTransitionBetween(ab, asm, mainState, aaosWrite, _refB); at = makeAvatarEmptyTransitionBetween(ab, asm, aaosWrite, mainState, _refB); - at.addAction("h=h+step"); + at.addAction("h = h + step"); // finished aaosWrite = new AvatarActionOnSignal("sendAllFinished_" + allFinished.getSignalName(), allFinished, _refB); + aaosWrite.addValue("h"); asm.addElement(aaosWrite); at = makeAvatarEmptyTransitionBetween(ab, asm, mainState, aaosWrite, _refB); @@ -600,7 +603,7 @@ public class AvatarBlockTemplate { // Still to be added: main blocks - public static AvatarBlock getClockGraphBlock(String _name, AvatarSpecification _avspec, Object _refB, + public static AvatarBlock getMainGraphBlock(String _name, AvatarSpecification _avspec, Object _refB, Vector<String> swTasks, Vector<String> hwTasks, Vector<String> hwSizes, String tickS, String allFinishedS, int nbCoresV, int durationDRV, int HWSize) { @@ -655,7 +658,7 @@ public class AvatarBlockTemplate { AvatarAttribute step = new AvatarAttribute("step", AvatarType.INTEGER, ab, _refB); ab.addAttribute(step); - AvatarAttribute nbHW = new AvatarAttribute("nbHW", AvatarType.INTEGER, ab, _refB); + AvatarAttribute nbHW = new AvatarAttribute("allocHW", AvatarType.INTEGER, ab, _refB); nbHW.setInitialValue("" + HWSize); ab.addAttribute(nbHW); @@ -740,6 +743,7 @@ public class AvatarBlockTemplate { } else { as = allFinished; AvatarActionOnSignal allFinishedRead = new AvatarActionOnSignal("read_" + as.getSignalName(), as, _refB); + allFinishedRead.addValue("finalClockValue"); asm.addElement(allFinishedRead); at = makeAvatarEmptyTransitionBetween(ab, asm, finishedHWRead, allFinishedRead, _refB); @@ -751,20 +755,167 @@ public class AvatarBlockTemplate { asm.addElement(stop); at = makeAvatarEmptyTransitionBetween(ab, asm, allFinishedRead, stop, _refB); } + cpt ++; + + } + + // evaluateSW state + AvatarState evaluateSW = new AvatarState("evaluateSW", _refB); + asm.addElement(evaluateSW); + at = makeAvatarEmptyTransitionBetween(ab, asm, finishHW, evaluateSW, _refB); + at.setDelays("1", "1"); + + + // preemptSW state + AvatarState preemptSW = new AvatarState("preemptSW", _refB); + asm.addElement(preemptSW); + at = makeAvatarEmptyTransitionBetween(ab, asm, evaluateSW, preemptSW, _refB); + at.setGuard("(allocCore > 0) && (rescheduleSW)"); + at.addAction("allocCore = 0"); + + for(String task: swTasks) { + as = ab.getAvatarSignalWithName("preempt_" + task); + AvatarActionOnSignal preemptSWWrite = new AvatarActionOnSignal("write_" + as.getSignalName(), as, _refB); + asm.addElement(preemptSWWrite); + at = makeAvatarEmptyTransitionBetween(ab, asm, preemptSW, preemptSWWrite, _refB); + at = makeAvatarEmptyTransitionBetween(ab, asm, preemptSWWrite, preemptSW, _refB); + } + + + + // selectSW state + AvatarState selectSW = new AvatarState("selectSW", _refB); + asm.addElement(selectSW); + at = makeAvatarEmptyTransitionBetween(ab, asm, preemptSW, selectSW, _refB); + at.setDelays("1", "1"); + at = makeAvatarEmptyTransitionBetween(ab, asm, evaluateSW, selectSW, _refB); + at.setGuard("else"); + + for(String task: swTasks) { + as = ab.getAvatarSignalWithName("select_" + task); + AvatarActionOnSignal selectSWWrite = new AvatarActionOnSignal("write_" + as.getSignalName(), as, _refB); + asm.addElement(selectSWWrite); + at = makeAvatarEmptyTransitionBetween(ab, asm, selectSW, selectSWWrite, _refB); + at.setGuard("allocCore < nbCores"); + at = makeAvatarEmptyTransitionBetween(ab, asm, selectSWWrite, selectSW, _refB); + at.addAction("allocCore = allocCore + 1"); + } + + // selectHW state + AvatarState selectHW = new AvatarState("selectHW", _refB); + asm.addElement(selectHW); + at = makeAvatarEmptyTransitionBetween(ab, asm, selectSW, selectHW, _refB); + at.setDelays("2", "2"); + at.setGuard("currentDR == 0"); + + cpt = 0; + for(String task: hwTasks) { + as = ab.getAvatarSignalWithName("select_" + task); + AvatarActionOnSignal selectHWWrite = new AvatarActionOnSignal("write_" + as.getSignalName(), as, _refB); + asm.addElement(selectHWWrite); + at = makeAvatarEmptyTransitionBetween(ab, asm, selectHW, selectHWWrite, _refB); + at.setGuard("remainHW > " + hwSizes.get(cpt)); + + at = makeAvatarEmptyTransitionBetween(ab, asm, selectHWWrite, selectHW, _refB); + at.addAction("runningHW = runningHW + 1"); + at.addAction("allocHW = allocHW + " + hwSizes.get(cpt)); + at.addAction("remainHW = remainHW - " + hwSizes.get(cpt)); + cpt ++; + } + // blockNonSelected state + AvatarState blockNonSelected = new AvatarState("blockNonSelected", _refB); + asm.addElement(blockNonSelected); + at = makeAvatarEmptyTransitionBetween(ab, asm, selectHW, blockNonSelected, _refB); + at.setGuard("runningHW> 0 "); + for(String task: hwTasks) { + as = ab.getAvatarSignalWithName("deactivate_" + task); + AvatarActionOnSignal deactivateHWWrite = new AvatarActionOnSignal("deactivate_" + as.getSignalName(), as, _refB); + asm.addElement(deactivateHWWrite); + at = makeAvatarEmptyTransitionBetween(ab, asm, blockNonSelected, deactivateHWWrite, _refB); + at = makeAvatarEmptyTransitionBetween(ab, asm, deactivateHWWrite, blockNonSelected, _refB); + } + // startDR state + AvatarState startDR = new AvatarState("startDR", _refB); + asm.addElement(startDR); + at = makeAvatarEmptyTransitionBetween(ab, asm, selectHW, startDR, _refB); + at.setGuard("(runningHW == 0) && (allocHW > 0)"); + // unblockAllHWP state + AvatarState unblockAllHWP = new AvatarState("unblockAllHWP", _refB); + asm.addElement(unblockAllHWP); + at = makeAvatarEmptyTransitionBetween(ab, asm, startDR, unblockAllHWP, _refB); + at.addAction("currentDR = durationDR"); + at.addAction("allocHW = 0"); + at.addAction("remainHW = nbHW"); + + + for(String task: hwTasks) { + as = ab.getAvatarSignalWithName("reactivate_" + task); + AvatarActionOnSignal reactivateHWWrite = new AvatarActionOnSignal("reactivate_" + as.getSignalName(), as, _refB); + asm.addElement(reactivateHWWrite); + at = makeAvatarEmptyTransitionBetween(ab, asm, unblockAllHWP, reactivateHWWrite, _refB); + at = makeAvatarEmptyTransitionBetween(ab, asm, reactivateHWWrite, unblockAllHWP, _refB); } + // makeStep state + AvatarState makeStep = new AvatarState("makeStep", _refB); + asm.addElement(makeStep); + at = makeAvatarEmptyTransitionBetween(ab, asm, selectSW, makeStep, _refB); + at.setGuard("nbHWTasks == 0"); + at.setDelays("1", "1"); + at = makeAvatarEmptyTransitionBetween(ab, asm, blockNonSelected, makeStep, _refB); + at.setDelays("1", "1"); + at = makeAvatarEmptyTransitionBetween(ab, asm, blockNonSelected, makeStep, _refB); + at.setDelays("1", "1"); + + // makeSteps state + AvatarState makeSteps = new AvatarState("makeSteps", _refB); + asm.addElement(makeSteps); + AvatarActionOnSignal tickRead = new AvatarActionOnSignal(tick.getSignalName(), tick, _refB); + tickRead.addValue("step"); + asm.addElement(tickRead); + at = makeAvatarEmptyTransitionBetween(ab, asm, makeStep, tickRead, _refB); + at = makeAvatarEmptyTransitionBetween(ab, asm, tickRead, makeSteps, _refB); + + for(String task: swTasks) { + as = ab.getAvatarSignalWithName("step_" + task); + AvatarActionOnSignal stepSWWrite = new AvatarActionOnSignal("step_" + as.getSignalName(), as, _refB); + stepSWWrite.addValue("step"); + asm.addElement(stepSWWrite); + at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, stepSWWrite, _refB); + at = makeAvatarEmptyTransitionBetween(ab, asm, stepSWWrite, makeSteps, _refB); + } + for(String task: hwTasks) { + as = ab.getAvatarSignalWithName("step_" + task); + AvatarActionOnSignal stepHWWrite = new AvatarActionOnSignal("step_" + as.getSignalName(), as, _refB); + asm.addElement(stepHWWrite); + stepHWWrite.addValue("step"); + at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, stepHWWrite, _refB); + at = makeAvatarEmptyTransitionBetween(ab, asm, stepHWWrite, makeSteps, _refB); + } + // waitForSteps state + AvatarState waitForSteps = new AvatarState("waitForSteps", _refB); + asm.addElement(waitForSteps); + at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, waitForSteps, _refB); + at.setDelays("1", "1"); + at.setGuard("currentDR == 0"); + at = makeAvatarEmptyTransitionBetween(ab, asm, makeSteps, waitForSteps, _refB); + at.setDelays("1", "1"); + at.setGuard("currentDR > 0"); + at.addAction("currentDR = currentDR - step"); + at = makeAvatarEmptyTransitionBetween(ab, asm, waitForSteps, finishSW, _refB); + at.setDelays("2", "2"); return ab; } diff --git a/src/main/java/avatartranslator/AvatarRelation.java b/src/main/java/avatartranslator/AvatarRelation.java index 1e7ba948363802daaf5735278aee5a0fefeb433b..319df8bae0847f72ce5a373ba69f356cac8e2939 100644 --- a/src/main/java/avatartranslator/AvatarRelation.java +++ b/src/main/java/avatartranslator/AvatarRelation.java @@ -205,7 +205,11 @@ public class AvatarRelation extends AvatarElement { if (i>0) { sb.append(" ; "); } - sb.append(block1.getName() + "." + signals1.get(i).getName() + "=" + block2.getName() + "." + signals2.get(i).getName()); + if ((signals1.get(i) == null) || (signals2.get(i) == null)) { + sb.append(block1.getName() + "." + "NULL" + "=" + block2.getName() + "." + "NULL"); + } else { + sb.append(block1.getName() + "." + signals1.get(i).getName() + "=" + block2.getName() + "." + signals2.get(i).getName()); + } } return sb.toString(); } diff --git a/src/main/java/avatartranslator/AvatarSpecification.java b/src/main/java/avatartranslator/AvatarSpecification.java index cbb51f59091a64374e8f49d1091f6ca1cb82f24c..2c60c5ced5001c250912f64a2dc63425ec944fd7 100644 --- a/src/main/java/avatartranslator/AvatarSpecification.java +++ b/src/main/java/avatartranslator/AvatarSpecification.java @@ -250,6 +250,25 @@ public class AvatarSpecification extends AvatarElement { return sb.toString(); } + + public String toShortString() { + //TraceManager.addDev("To Short String"); + //Thread.currentThread().dumpStack(); + StringBuffer sb = new StringBuffer("Blocks:\n"); + for(AvatarBlock block: blocks) { + sb.append("*** " + block.toShortString()+"\n"); + } + sb.append("\nRelations:\n"); + for(AvatarRelation relation: relations) { + sb.append("Relation:" + relation.toString() + "\n"); + } + /*for (AvatarConstant constant: constants){ + sb.append("Constant:" + constant.toString() + "\n"); + }*/ + + return sb.toString(); + } + public AvatarBlock getBlockWithName(String _name) { for(AvatarBlock block: blocks) { if (block.getName().compareTo(_name)== 0) { diff --git a/src/main/java/cli/BF.java b/src/main/java/cli/BF.java new file mode 100644 index 0000000000000000000000000000000000000000..797f72e3c6a7b47236e09272e8c209aa2e2e83e8 --- /dev/null +++ b/src/main/java/cli/BF.java @@ -0,0 +1,357 @@ +/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille + * + * ludovic.apvrille AT enst.fr + * + * This software is a computer program whose purpose is to allow the + * edition of TURTLE analysis, design and deployment diagrams, to + * allow the generation of RT-LOTOS or Java code from this diagram, + * and at last to allow the analysis of formal validation traces + * obtained from external tools, e.g. RTL from LAAS-CNRS and CADP + * from INRIA Rhone-Alpes. + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited + * liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + */ + + +package cli; + +//import com.sun.deploy.trace.Trace; +import common.ConfigurationTTool; +import launcher.RTLLauncher; +import myutil.Conversion; +import myutil.IntExpressionEvaluator; +import myutil.PluginManager; +import myutil.TraceManager; +import ui.MainGUI; +import ui.util.IconManager; +import avatartranslator.*; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.util.BitSet; +import java.util.*; + + +/** + * Class Set + * Creation: 19/03/2019 + * Version 2.0 19/03/2019 + * + * @author Ludovic APVRILLE + */ +public class BF extends Command { + + + public BF() { + + } + + public List<Command> getListOfSubCommands() { + return subcommands; + } + + public String getCommand() { + return "bruteforce"; + } + + public String getShortCommand() { + return "bf"; + } + + public String getUsage() { return "bf <graphfile> <nbOfCLBs> <durationDynamicReconfiguration> <nbOfCores>"; } + + public String getDescription() { return "Bruteforcing FPGA and SW scheduling. Reserved for Development purpose"; } + + public String getExample() { + return "bf graph.txt 100 30 2"; + } + + + public String executeCommand(String command, Interpreter interpreter) { + int cpt = 0; + try { + + TraceManager.addDev("BF checking attributes"); + + // Check attributes + String[] commands = command.split(" "); + if (commands.length < 4) { + return Interpreter.BAD; + } + + String fileName = commands[0]; + + if (fileName.length() < 1) { + return Interpreter.BAD_FILE_NAME; + } + + + + int nbOfCLBs = Integer.decode(commands[1]); + int dynamicReconfigurationTime = Integer.decode(commands[2]); + int nbOfCores = Integer.decode(commands[3]); + + + if (nbOfCLBs < 1) { + return Interpreter.BAD; + } + + if (dynamicReconfigurationTime < 1) { + return Interpreter.BAD; + } + + + if (nbOfCores < 1) { + return Interpreter.BAD; + } + + + // Read text file + TraceManager.addDev("Reading file"); + File f = new File(fileName); + cpt = 1; + int inSWTask = 0; + int inHWTask = 0; + Vector<BFTask> tasks = new Vector<>(); + BFTask t = null; + int taskIndex = 0; + + try(BufferedReader br = new BufferedReader(new FileReader(fileName))) { + for(String line; (line = br.readLine()) != null; ) { + cpt ++; + if (line.length() > 0) { + + // Graph structure + if (line.contains("-")) { + // link between tasks + int indexMinus = line.indexOf("-"); + String originTaskName = line.substring(0, indexMinus).trim(); + String []nextTasks = line.substring(indexMinus+1, line.length()).trim().split(" "); + + //TraceManager.addDev("origin task:" + originTaskName); + BFTask originTask = getBFTaskByName(tasks, originTaskName); + if (originTask == null) { + return Interpreter.BAD_FILE; + } + + for(String taskName: nextTasks) { + //TraceManager.addDev("destination task:" + taskName); + BFTask destinationTask = getBFTaskByName(tasks, taskName); + if (destinationTask == null) { + return Interpreter.BAD_FILE; + } + originTask.addNext(destinationTask); + destinationTask.addPrevious(originTask); + } + + + //Task definition + } else { + if (t == null) { + // new task + t = new BFTask(line); + tasks.add(t); + taskIndex = 1; + } else { + if (taskIndex == 1) { + // hw or sw? + if (line.compareTo("hw") == 0) { + t.type = 0; + } else { + t.type = 1; + } + } else { + // extra info + int info = Integer.decode(line); + switch (taskIndex){ + case 2: + if (t.isSW()) { + t.timing = info; + t = null; + } else { + t.clb = info; + } + break; + case 3: + t.dsp = info; + break; + case 4: + t.mem = info; + break; + case 5: + t.timing = info; + t = null; + } + } + + if (t != null) { + taskIndex ++; + } + + } + } + } + + } + + } + + TraceManager.addDev("File read"); + + // Print all tasks + TraceManager.addDev("Tasks:"); + for (BFTask ta: tasks) { + TraceManager.addDev(ta.toString()); + } + + // Generate AvatarSpec + AvatarSpecification avspec = new AvatarSpecification(fileName, this); + + // tasks -> blocks + for(BFTask bft: tasks) { + bft.makeBlock(avspec); + avspec.addBlock(bft.block); + } + + // Clock + TraceManager.addDev("Making clock block"); + AvatarBlock clockBlock = AvatarBlockTemplate.getClockGraphBlock("Clock", avspec, this, 1, "tick", + "allFinished"); + avspec.addBlock(clockBlock); + + // Main block + TraceManager.addDev("Making main block"); + Vector<String> swTasks = new Vector<>(); + Vector<String> hwTasks = new Vector<>(); + Vector<String> hwSizes = new Vector<>(); + for(BFTask bft: tasks) { + if (bft.isHW()) { + hwTasks.add(bft.name); + hwSizes.add(""+bft.clb); + } else { + swTasks.add(bft.name); + } + } + + AvatarBlock mainBlock = AvatarBlockTemplate.getMainGraphBlock("Main", avspec, this, + swTasks, hwTasks, hwSizes, "tick", + "allFinished", nbOfCores, dynamicReconfigurationTime, nbOfCLBs); + avspec.addBlock(mainBlock); + + // Relations + TraceManager.addDev("Making relations 1"); + AvatarRelation ar = new AvatarRelation("rMainClock", clockBlock, mainBlock, this); + ar.addSignals(clockBlock.getAvatarSignalWithName("tick"), mainBlock.getAvatarSignalWithName("tick")); + ar.addSignals(clockBlock.getAvatarSignalWithName("allFinished"), mainBlock.getAvatarSignalWithName("allFinished")); + avspec.addRelation(ar); + + TraceManager.addDev("Making relations 2"); + + for(BFTask bft: tasks) { + TraceManager.addDev("Dealing with btf=" + bft.name); + // Relation between this block and the main block + AvatarBlock b = bft.block; + ar = new AvatarRelation("r" + bft.name + "Main", b, mainBlock, this); + avspec.addRelation(ar); + TraceManager.addDev("Making relations 2.1 for " + bft.name); + AvatarSignal as1 = b.getAvatarSignalWithName("selectP"); + AvatarSignal as2 = mainBlock.getAvatarSignalWithName("select_" + bft.name); + ar.addSignals(as1, as2); + as1 = b.getAvatarSignalWithName("stepP"); + as2 = mainBlock.getAvatarSignalWithName("step_" + bft.name); + ar.addSignals(as1, as2); + TraceManager.addDev("Making relations 2.3"); + as1 = b.getAvatarSignalWithName("finishP"); + as2 = mainBlock.getAvatarSignalWithName("finished_" + bft.name); + ar.addSignals(as1, as2); + if (bft.isHW()) { + TraceManager.addDev("Making relations 2.4.1"); + as1 = b.getAvatarSignalWithName("deactivatedP"); + as2 = mainBlock.getAvatarSignalWithName("deactivate_" + bft.name); + ar.addSignals(as1, as2); + TraceManager.addDev("Making relations 2.4.2"); + as1 = b.getAvatarSignalWithName("reactivatedP"); + if (as1 == null) { + TraceManager.addDev("Null as1"); + } + as2 = mainBlock.getAvatarSignalWithName("reactivate_" + bft.name); + if (as2 == null) { + TraceManager.addDev("Null as2"); + } + ar.addSignals(as1, as2); + TraceManager.addDev("Done Making relations 2.4.2"); + } else { + TraceManager.addDev("Making relations 2.5"); + as1 = b.getAvatarSignalWithName("preemptP"); + as2 = mainBlock.getAvatarSignalWithName("preempt_" + bft.name); + ar.addSignals(as1, as2); + } + + + TraceManager.addDev("Done making relations 2.1 for " + bft.name); + // Relation between this block and its next + + } + + TraceManager.addDev("All done :)"); + + + // Printing avspec + TraceManager.addDev("\n\n**************** AVSPEC:\n" + avspec.toShortString() + "\n*********\n\n"); + + + // Compte RG + + // Deduce best scheduling + + + + + return null; + } catch (Exception e) { + TraceManager.addDev("Exception: " + e.getMessage()); + return "BF failed"; + + } + + } + + public void fillSubCommands() { + + } + + private BFTask getBFTaskByName(Vector<BFTask> list, String name) { + for(BFTask t: list) { + if (t.name.compareTo(name) == 0) { + return t; + } + } + return null; + } + +} diff --git a/src/main/java/cli/Interpreter.java b/src/main/java/cli/Interpreter.java index 420044b77dfe96e3e7cab4d13b30f5c2072ed1a8..c8f5b31b3828698c678aa4a84ce5f12655084415 100644 --- a/src/main/java/cli/Interpreter.java +++ b/src/main/java/cli/Interpreter.java @@ -59,7 +59,7 @@ import java.util.Vector; public class Interpreter implements Runnable, TerminalProviderInterface { public final static Command[] commands = {new Action(), new Help(), new History(), new Print(), new Quit(), - new TestSpecific(), new TML(), new Set(), new Wait(), new Robot()}; + new TestSpecific(), new TML(), new Set(), new Wait(), new Robot(), new BF()}; // Errors public final static String UNKNOWN = "Unknown command"; @@ -72,6 +72,8 @@ public class Interpreter implements Runnable, TerminalProviderInterface { public final static String TTOOL_ALREADY_STARTED = "TTool is already started. Cannot execute command."; public final static String BAD_COMMAND_NAME = "The provided command is invalid"; public final static String ROBOT_EXCEPTION = "Robot could not be started"; + public final static String BAD_FILE_NAME = "Unvalid file identifier"; + public final static String BAD_FILE = "Badly formatted file"; private String script; @@ -109,7 +111,9 @@ public class Interpreter implements Runnable, TerminalProviderInterface { String line; currentLine = 0; while ((line = term.getNextCommand()) != null) { + //TraceManager.addDev("Dealing with line: " + line); for(String subCommand: line.split(";")) { + //TraceManager.addDev("Executing: " + subCommand); executeLine(subCommand, currentLine, false); } currentLine++; @@ -145,8 +149,9 @@ public class Interpreter implements Runnable, TerminalProviderInterface { while (scanner.hasNextLine()) { String line = scanner.nextLine(); currentLine++; - + //TraceManager.addDev("Dealing with line: " + line); for(String subCommand: line.split(";")) { + //TraceManager.addDev("Executing: " + subCommand); executeLine(subCommand, currentLine, true); }