nl.uu.cs.ape.solver.ModuleUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of APE Show documentation
APE is a command line tool and an API for the automated exploration of possible computational pipelines (workflows) from large collections of computational tools.
The newest version!
package nl.uu.cs.ape.solver;

import java.util.ArrayList;
import java.util.List;

import nl.uu.cs.ape.automaton.ModuleAutomaton;
import nl.uu.cs.ape.automaton.TypeAutomaton;
import nl.uu.cs.ape.models.AllModules;
import nl.uu.cs.ape.models.Pair;
import nl.uu.cs.ape.models.enums.AtomType;
import nl.uu.cs.ape.models.SATAtomMappings;
import nl.uu.cs.ape.models.logic.constructs.PredicateLabel;
import nl.uu.cs.ape.models.logic.constructs.TaxonomyPredicate;

/**
 * The {@code ModuleUtils} class is used to encode SAT constraints based on the
 * module annotations.
 *
 * @author Vedran Kasalica
 */
public abstract class ModuleUtils {

	/**
	 * Return a representation of the INPUT and OUTPUT type constraints.
	 * Depending on the parameter pipeline, the INPUT constraints will be based on a
	 * pipeline or general memory approach.
	 *
	 * @param synthesisInstance A specific synthesis run that contains all the
	 *                          information specific for it.
	 * @return String representation of constraints regarding the required INPUT
	 *         and OUTPUT types of the modules.
	 */
	public String encodeModuleAnnotations(Class synthesisInstance) {
		StringBuilder constraints = new StringBuilder();
		constraints.append(inputCons(synthesisInstance));

		constraints.append(outputCons(synthesisInstance));
		return constraints.toString();
	}

	/**
	 * Return a formula that preserves the memory structure that is being used
	 * (e.g. 'shared memory'), i.e. ensures that the referenced items are available
	 * according to the mem. structure and that the input type and the referenced
	 * type from the memory represent the same data.
	 *
	 * @param synthesisInstance A specific synthesis run that contains all the
	 *                          information specific for it.
	 * @return String representation of constraints regarding the required
	 *         memory structure implementation.
	 */
	public String encodeMemoryStructure(Class synthesisInstance) {
		StringBuilder constraints = new StringBuilder();

		constraints.append(
				allowDataReferencingCons(synthesisInstance));
		constraints.append(enforcingUsageOfGeneratedTypesCons(synthesisInstance));

		constraints.append(enforceDataReferenceRules(synthesisInstance));
		return constraints.toString();
	}

	/**
	 * Encode data instance dependency constraints.
	 * 
	 * @param typeAutomaton type automaton
	 * @param mappings      all the atom mappings
	 * @return String representation of constraints.
	 */
	public String encodeDataInstanceDependencyCons(TypeAutomaton typeAutomaton, SATAtomMappings mappings) {
		StringBuilder constraints = new StringBuilder();

		constraints.append(allowDataDependencyCons(typeAutomaton, mappings));
		constraints.append(enforceDataDependencyOverModules(typeAutomaton, mappings));
		constraints.append(enforceDataDependencyOverDataReferencing(typeAutomaton, mappings));

		return constraints.toString();
	}

	/**
	 * Generate constraints that ensure that the set of inputs correspond to the
	 * tool specifications.

	 * Returns the representation of the input type constraints for all tools
	 * regarding @typeAutomaton, for the synthesis concerning @moduleAutomaton.
	 * 
	 * @param synthesisInstance - synthesis instance
	 *
	 * @return String representation of constraints.
	 */
	public abstract String inputCons(Class synthesisInstance);

	/**
	 * Constraints that ensure that the referenced memory states contain the same
	 * data type as the one that is used as the input for the tool. Constraints
	 * ensure that the {@link AtomType#MEM_TYPE_REFERENCE} are implemented
	 * correctly.
	 * 
	 * @param synthesisInstance - synthesis instance
	 *
	 * @return String representing the constraints required to ensure that the
	 *         {@link AtomType#MEM_TYPE_REFERENCE} are implemented correctly.
	 */
	public abstract String enforceDataReferenceRules(Class synthesisInstance);

	/**
	 * Generate constraints that ensure that the all tool inputs can reference data
	 * that is available in memory at the time.
	 *
	 * 

	 * Return the representation of the input type constraints for all modules,
	 * regarding @typeAutomaton, for the synthesis concerning @moduleAutomaton and
	 * the Shared Memory Approach.
	 * 
	 * @param synthesisInstance - synthesis instance
	 *
	 * @return String representation of constraints.
	 */
	public abstract String allowDataReferencingCons(Class synthesisInstance);

	/**
	 * Generate constraints that ensure that the data instances can depend on
	 * instances that are available in memory, and that each data instance depends
	 * on itself.
	 *
	 * @param typeAutomaton type automaton
	 * @param mappings      all the atom mappings
	 * 
	 * @return String representation of constraints.
	 */
	public abstract String allowDataDependencyCons(TypeAutomaton typeAutomaton, SATAtomMappings mappings);

	/**
	 * Generate constraints that ensure that tool inputs that reference data in
	 * memory depend on the same data as the referenced data instance.
	 *
	 * @param typeAutomaton type automaton
	 * @param mappings      all the atom mappings
	 * 
	 * @return String representation of constraints.
	 */
	public abstract String enforceDataDependencyOverDataReferencing(TypeAutomaton typeAutomaton,
			SATAtomMappings mappings);

	/**
	 * Generate constraints that data dependency is preserved over modules.
	 * 
	 * @param typeAutomaton type automaton
	 * @param mappings      all the atom mappings
	 * 
	 * @return String representation of constraints.
	 */
	public abstract String enforceDataDependencyOverModules(TypeAutomaton typeAutomaton, SATAtomMappings mappings);

	/**
	 * Function returns the encoding that ensures that tool outputs are used
	 * according to the configuration, e.g. if the config specifies that all
	 * workflow inputs have to be used, then each of them has to be referenced at
	 * least once.
	 * 
	 * @param synthesisInstance - synthesis instance
	 *
	 * @return String representation of constraints.
	 */
	public abstract String enforcingUsageOfGeneratedTypesCons(Class synthesisInstance);

	/**
	 * Return the representation of the output type constraints for all tools
	 * regarding @typeAutomaton, for the synthesis concerning @moduleAutomaton.

	 * Generate constraints that preserve tool outputs.
	 * 
	 * @param synthesisInstance - synthesis instance
	 *
	 * @return String representation of constraints.
	 */
	public abstract String outputCons(Class synthesisInstance);

	/**
	 * Generating the mutual exclusion constraints for each pair of tools from
	 * modules (excluding abstract modules from the taxonomy) in each state of
	 * moduleAutomaton.
	 *
	 * @param allModules      All the modules.
	 * @param moduleAutomaton Module automaton.
	 * @param mappings        Mapping function.
	 * @return The String representation of constraints.
	 */
	public abstract String moduleMutualExclusion(AllModules allModules, ModuleAutomaton moduleAutomaton,
			SATAtomMappings mappings);

	/**
	 * Generating the mandatory usage constraints of root module @rootModule in each
	 * state of @moduleAutomaton.
	 *
	 * @param allModules      All the modules.
	 * @param moduleAutomaton Module automaton.
	 * @param mappings        Mapping function.
	 * @return String representation of constraints.
	 */
	public abstract String moduleMandatoryUsage(AllModules allModules, ModuleAutomaton moduleAutomaton,
			SATAtomMappings mappings);

	/**
	 * Generating the mandatory usage of a submodules in case of the parent module
	 * being used, with respect to the Module Taxonomy. The rule starts from
	 * the @rootModule and it's valid in each state of @moduleAutomaton.
	 *
	 * @param allModules      All the modules.
	 * @param currModule      Module that should be used.
	 * @param moduleAutomaton Module automaton.
	 * @param mappings        Mapping function.
	 * @return String representation of constraints enforcing taxonomy
	 *         classifications.
	 */
	public abstract String moduleEnforceTaxonomyStructure(AllModules allModules, TaxonomyPredicate currModule,
			ModuleAutomaton moduleAutomaton, SATAtomMappings mappings);

	/**
	 * Gets predicate pairs.
	 *
	 * @param predicateList List of predicates.
	 * @return A a list of pairs of tools from modules. Note that the abstract
	 *         modules are not returned, only the unique pairs of modules that are
	 *         representing actual tools.
	 */
	public static List> getPredicatePairs(List predicateList) {
		List> pairs = new ArrayList<>();

		for (int i = 0; i < predicateList.size() - 1; i++) {
			for (int j = i + 1; j < predicateList.size(); j++) {

				pairs.add(new Pair<>(predicateList.get(i), predicateList.get(j)));
			}
		}

		return pairs;
	}
}