From adce403870ea34f79cf2c59b88cdb5b2dcb438a8 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Wed, 5 Jul 2017 16:31:32 +0200 Subject: Support for generationg multiple difference models by VIATRA-Solver --- .../dse/BestFirstStrategyForModelGeneration.java | 41 +++++++++++- .../dse/PartialModelAsLogicInterpretation.xtend | 73 ++++++++++++++++++++-- .../reasoner/dse/SolutionStoreWithCopy.xtend | 11 ++++ 3 files changed, 116 insertions(+), 9 deletions(-) (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java index 5a6fee2c..862ba245 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java @@ -11,12 +11,17 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; +import java.util.LinkedList; import java.util.List; import java.util.PriorityQueue; import java.util.Random; +import java.util.SortedMap; +import java.util.TreeMap; +import java.util.TreeSet; import org.apache.log4j.Logger; import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy; @@ -24,6 +29,10 @@ import org.eclipse.viatra.dse.base.ThreadContext; import org.eclipse.viatra.dse.objectives.Fitness; import org.eclipse.viatra.dse.objectives.ObjectiveComparatorHelper; import org.eclipse.viatra.dse.solutionstore.SolutionStore; +import org.eclipse.viatra.query.runtime.api.IPatternMatch; +import org.eclipse.viatra.query.runtime.api.IQuerySpecification; +import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher; +import org.eclipse.viatra.query.runtime.exception.ViatraQueryException; import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner; import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicSolverConfiguration; @@ -57,12 +66,15 @@ public class BestFirstStrategyForModelGeneration implements IStrategy { private SolutionStoreWithCopy solutionStoreWithCopy; private SolutionStoreWithDiversityDescriptor solutionStoreWithDiversityDescriptor; private int numberOfStatecoderFail=0; + //Collection>> additionalPatterns = null; + //List> additionalMatchers = new LinkedList>(); private int maxDepth = Integer.MAX_VALUE; private boolean isInterrupted = false; //private boolean backTrackIfSolution = true; private boolean onlyBetterFirst = false; + private PriorityQueue trajectoiresToExplore; private Logger logger = Logger.getLogger(IStrategy.class); @@ -84,12 +96,15 @@ public class BestFirstStrategyForModelGeneration implements IStrategy { } - public BestFirstStrategyForModelGeneration(ReasonerWorkspace workspace, LogicReasoner reasoner, LogicSolverConfiguration configuration, DiversityDescriptor descriptor) { - this.maxDepth = Integer.MAX_VALUE; + public BestFirstStrategyForModelGeneration( + ReasonerWorkspace workspace, LogicReasoner reasoner, LogicSolverConfiguration configuration, DiversityDescriptor descriptor/*, + Collection>> additionalPatterns*/) { + this.maxDepth = Integer.MAX_VALUE; this.workspace = workspace; this.reasoner = reasoner; this.configuration = configuration; this.solutionStoreWithDiversityDescriptor = new SolutionStoreWithDiversityDescriptor(descriptor); + //this.additionalPatterns = additionalPatterns; } @Override @@ -108,6 +123,8 @@ public class BestFirstStrategyForModelGeneration implements IStrategy { return objectiveComparatorHelper.compare(o2.fitness, o1.fitness); } }; + + trajectoiresToExplore = new PriorityQueue(11, comparator); @@ -127,6 +144,18 @@ public class BestFirstStrategyForModelGeneration implements IStrategy { @Override public void explore() { + + /*if(this.additionalPatterns!=null) { + for (IQuerySpecification> additionalPattern : additionalPatterns) { + try { + this.additionalMatchers.add(additionalPattern.getMatcher(context.getQueryEngine())); + } catch (ViatraQueryException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + }*/ + final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper(); boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints(); @@ -210,9 +239,15 @@ public class BestFirstStrategyForModelGeneration implements IStrategy { final Fitness nextFitness = context.calculateFitness(); if (nextFitness.isSatisifiesHardObjectives()) { if(solutionStoreWithDiversityDescriptor.isDifferent(context)) { - solutionStoreWithCopy.newSolution(context); + /*SortedMap x = new TreeMap(); + for(ViatraQueryMatcher additioanMatcher : this.additionalMatchers) { + x.put(additioanMatcher.getPatternName(),additioanMatcher.countMatches()); + }*/ + + solutionStoreWithCopy.newSolution(context/*,x*/); solutionStoreWithDiversityDescriptor.newSolution(context); solutionStore.newSolution(context); + logger.debug("Found a solution."); } } diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend index b2a7e3f5..56c3c852 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend @@ -1,16 +1,68 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicModelInterpretation -import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration -import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation +import java.util.HashMap +import java.util.List +import java.util.Map +import org.eclipse.emf.ecore.EObject + +import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink class PartialModelAsLogicInterpretation implements LogicModelInterpretation{ + val PartialInterpretation partialInterpretation + val Map trace; + val Map type2Interpretation + val Map relation2Interpretation + val Map elementBackwardTrace + new(PartialInterpretation partialInterpretation, Map forwardMap) { + this.partialInterpretation = partialInterpretation + this.trace = forwardMap + this.type2Interpretation = initTypes(partialInterpretation.partialtypeinterpratation) + this.relation2Interpretation = initRelations(partialInterpretation.partialrelationinterpretation) + this.elementBackwardTrace = initElementBackwardTrace(trace) + } + + def initTypes(List types) { + types.toMap[it.interpretationOf] + } + def initRelations(List relations) { + relations.toMap[it.interpretationOf] + } + def initElementBackwardTrace(Map trace) { + val entryBackwardMap = new HashMap + for(entry: trace.entrySet) { + if(entry.key instanceof DefinedElement) { + entryBackwardMap.put(entry.value as DefinedElement, entry.key as DefinedElement) + } + } + return entryBackwardMap + } override getElements(Type type) { - throw new UnsupportedOperationException("TODO: auto-generated method stub") + val t1 = type.lookup(trace) as TypeDeclaration + val t2 = t1.lookup(this.type2Interpretation) + return t2.elements.map[it.elementLookupBackward] + } + + def elementLookupForward(DefinedElement e) { + if(this.trace.containsKey(e)) return e.lookup(trace) as DefinedElement + else return e; + } + def elementLookupBackward(DefinedElement e) { + if(this.elementBackwardTrace.containsKey(e)) return e.lookup(this.elementBackwardTrace) + else return e; } override getInterpretation(FunctionDeclaration function, Object[] parameterSubstitution) { @@ -18,13 +70,22 @@ class PartialModelAsLogicInterpretation implements LogicModelInterpretation{ } override getInterpretation(RelationDeclaration relation, Object[] parameterSubstitution) { - throw new UnsupportedOperationException("TODO: auto-generated method stub") + if(parameterSubstitution.size == 2) { + val param1 = (parameterSubstitution.get(0) as DefinedElement).elementLookupForward + val param2 = (parameterSubstitution.get(1) as DefinedElement).elementLookupForward + val r1 = relation.lookup(trace) as RelationDeclaration + val r2 = r1.lookup(this.relation2Interpretation) + val links = r2.relationlinks.filter(BinaryElementRelationLink) + val existLink = links.exists[it.param1 == param1 && it.param2 == param2] + //println(existLink) + return existLink + } else throw new UnsupportedOperationException } override getInterpretation(ConstantDeclaration constant) { throw new UnsupportedOperationException("TODO: auto-generated method stub") } - override getMinimalInteger() { 0 } - override getMaximalInteger() {0 } + override getMinimalInteger() {0} + override getMaximalInteger() {0} } \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend index 679b9600..a8b7301e 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend @@ -7,16 +7,24 @@ import org.eclipse.emf.ecore.EObject import java.util.Map import org.eclipse.emf.ecore.util.EcoreUtil import org.eclipse.viatra.dse.base.ThreadContext +import java.util.TreeMap +import java.util.SortedMap class SolutionStoreWithCopy { long runtime = 0 List solutions = new LinkedList + //public List> additionalMatches = new LinkedList List> copyTraces = new LinkedList long sartTime = System.nanoTime List solutionTimes = new LinkedList + /*def newSolution(ThreadContext context, SortedMap additonalMatch) { + additionalMatches+= additonalMatch + newSolution(context) + }*/ + def newSolution(ThreadContext context) { //print(System.nanoTime-initTime + ";") val copyStart = System.nanoTime @@ -38,4 +46,7 @@ class SolutionStoreWithCopy { def getSolutions() { solutions } + def getCopyTraces() { + return copyTraces + } } \ No newline at end of file -- cgit v1.2.3-54-g00ecf