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 --- .../viatrasolver/reasoner/ViatraReasoner.xtend | 37 ++++++++--- .../dse/BestFirstStrategyForModelGeneration.java | 41 +++++++++++- .../dse/PartialModelAsLogicInterpretation.xtend | 73 ++++++++++++++++++++-- .../reasoner/dse/SolutionStoreWithCopy.xtend | 11 ++++ 4 files changed, 145 insertions(+), 17 deletions(-) (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend index 5d8859bd..fd70688b 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend @@ -25,6 +25,18 @@ import org.eclipse.viatra.dse.api.DesignSpaceExplorer import org.eclipse.viatra.dse.api.DesignSpaceExplorer.DseLoggingLevel import org.eclipse.viatra.dse.solutionstore.SolutionStore import org.eclipse.viatra.dse.statecode.IStateCoderFactory +import java.util.List +import java.util.Map +import org.eclipse.viatra.dse.base.ThreadContext +import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod +import org.eclipse.viatra.query.runtime.api.IPatternMatch +import org.eclipse.viatra.query.runtime.api.IQuerySpecification +import java.util.Collection +import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher +import java.util.SortedMap +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.common.util.EList class ViatraReasoner extends LogicReasoner{ val PartialInterpretationInitialiser initialiser = new PartialInterpretationInitialiser() @@ -42,6 +54,9 @@ class ViatraReasoner extends LogicReasoner{ this.inconsistencyDetector = inconsistencyDetector } + public static var Collection>> allPatterns = null + //public static var List> additionalMatches = null + override solve(LogicProblem problem, LogicSolverConfiguration configuration, ReasonerWorkspace workspace) throws LogicReasonerException { val viatraConfig = configuration.asConfig val DesignSpaceExplorer dse = new DesignSpaceExplorer(); @@ -71,6 +86,7 @@ class ViatraReasoner extends LogicReasoner{ viatraConfig.nameNewElements, viatraConfig.typeInferenceMethod ) + allPatterns = method.allPatterns dse.addObjective(new ModelGenerationCompositeObjective( new ScopeObjective, @@ -83,7 +99,7 @@ class ViatraReasoner extends LogicReasoner{ dse.addGlobalConstraint(additionalConstraint.apply(method)) } - dse.setInitialModel(emptySolution) + dse.setInitialModel(emptySolution,false) var IStateCoderFactory statecoder = if(viatraConfig.stateCoderStrategy == StateCoderStrategy.Neighbourhood) { new NeighbourhoodBasedStateCoderFactory @@ -107,7 +123,8 @@ class ViatraReasoner extends LogicReasoner{ val strategy = new BestFirstStrategyForModelGeneration( workspace,inconsistencyDetector, viatraConfig.inconsistencDetectorConfiguration, - viatraConfig.diversityRequirement) + viatraConfig.diversityRequirement/*, + method.allPatterns*/) val transformationTime = System.nanoTime - transformationStartTime val solverStartTime = System.nanoTime @@ -124,14 +141,15 @@ class ViatraReasoner extends LogicReasoner{ val solverTime = System.nanoTime - solverStartTime val statecoderFinal = statecoder + //additionalMatches = strategy.solutionStoreWithCopy.additionalMatches val statistics = createStatistics => [ //it.solverTime = viatraConfig.runtimeLimit it.solverTime = (solverTime/1000000) as int it.transformationTime = (transformationTime/1000000) as int for(x : 0.. [ - it.name = '''_Sulution«x»FoundAt''' - it.value = strategy.solutionStoreWithCopy.allRuntimes.get(x).intValue + it.name = '''_Solution«x»FoundAt''' + it.value = (strategy.solutionStoreWithCopy.allRuntimes.get(x)/1000000) as int ] } it.entries += createIntStatisticEntry => [ @@ -179,7 +197,7 @@ class ViatraReasoner extends LogicReasoner{ */ return factory.createModelResult => [ it.problem = problem - it.trace = null + it.trace = strategy.solutionStoreWithCopy.copyTraces it.representation += strategy.solutionStoreWithCopy.solutions it.statistics = statistics ] @@ -199,11 +217,14 @@ class ViatraReasoner extends LogicReasoner{ sc.sumStatecoderRuntime } - override getInterpretation(ModelResult modelResult) { - return new PartialModelAsLogicInterpretation + override getInterpretations(ModelResult modelResult) { + val indexes = 0..>; + val res = indexes.map[i | new PartialModelAsLogicInterpretation(modelResult.representation.get(i) as PartialInterpretation,traces.get(i))].toList + return res } - def ViatraReasonerConfiguration asConfig(LogicSolverConfiguration configuration) { + private def ViatraReasonerConfiguration asConfig(LogicSolverConfiguration configuration) { if(configuration instanceof ViatraReasonerConfiguration) { return configuration } else throw new IllegalArgumentException('''Wrong configuration. Expected: «ViatraReasonerConfiguration.name», but got: «configuration.class.name»"''') 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