feat: thread result model code

2025-07-11 13:03:39 +02:00
19 changed files with 284 additions and 410 deletions
--- a/src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java
+++ b/src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java
@@ -1,8 +1,6 @@
 package de.dhbwstuttgart.server;

 import de.dhbwstuttgart.util.Logger;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
 import org.java_websocket.WebSocket;

 public class ServerTaskLogger extends Logger {
--- a/src/main/java/de/dhbwstuttgart/server/SocketServer.java
+++ b/src/main/java/de/dhbwstuttgart/server/SocketServer.java
@@ -29,7 +29,6 @@ public class SocketServer extends WebSocketServer {

  public static Logger logger = new Logger("SocketServer");
  public static final int maxTasksPerSession = 100;
-  private static boolean serverRunning = false;

  /**
   * Increase this every time a breaking change to the server communication is done.
@@ -46,17 +45,12 @@ public class SocketServer extends WebSocketServer {
    super(new InetSocketAddress(port));
    this.setConnectionLostTimeout(30);

-    serverRunning = true;
+
    // add a shutdown hook to close all connections when the process ends or is stopped by a SIGINT signal
    Runtime.getRuntime().addShutdownHook(new Thread(this::onShutdown));
  }

-  public static boolean isServerRunning() {
-    return serverRunning;
-  }
-
  private void onShutdown() {
-    serverRunning = false;
    try {
      for (var webSocket : this.getConnections()) {
        this.sendError(webSocket, "Sorry, i am shutting down. You are now on your own, good Luck!", true);
@@ -91,7 +85,7 @@ public class SocketServer extends WebSocketServer {
      // wait 10 seconds for the client to send a task and close the connection if nothing has been received until then
      final int secondsUntilTimeout = 10;
      timeoutExecutor.schedule(() -> {
-          if (webSocket.<SocketData>getAttachment().totalTasks.get() > 0 || !webSocket.isOpen()) {
+          if (webSocket.<SocketData>getAttachment().unhandledTasks.get() == 0 || !webSocket.isOpen()) {
            return;
          }
          sendMessage(webSocket, "No task received after " + secondsUntilTimeout + " seconds. Closing connection...");
--- a/src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.java
@@ -37,10 +37,6 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
    super();
  }

-  public Constraint(int initialCapacity) {
-    super(initialCapacity);
-  }
-
  public Constraint(boolean isInherited, boolean isImplemented) {
    this.isInherited = isInherited;
    this.isImplemented = isImplemented;
@@ -81,14 +77,6 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
    methodSignatureConstraint = c;
  }

-  public <B extends IConstraintElement> Constraint<B> createdMapped(Function<A,B> mapper) {
-    Constraint<B> result = new Constraint<>(this.size());
-    for (A element : this) {
-      result.add(mapper.apply(element));
-    }
-    return result;
-  }
-
  public String toString() {
    return super.toString() + "\nisInherited = " + isInherited
      + " isOveridden = " + isImplemented
--- a/src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
@@ -285,13 +285,8 @@ public class TYPEStmt implements StatementVisitor {
            // see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
            // Expression muss zu Numeric Convertierbar sein. also von Numeric erben
            Constraint<Pair> numeric;
-            HashSet<JavaClassName> classNames = TypeUnifyTaskHelper.getPresizedHashSet(info.getAvailableClasses().size());
-            for (var classEl : info.getAvailableClasses()) {
-                classNames.add(classEl.getClassName());
-            }
-
            // PL eingefuegt 2018-07-17
-            if (classNames.contains(bytee.getName())) {
+            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -299,7 +294,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (classNames.contains(shortt.getName())) {
+            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -307,7 +302,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (classNames.contains(integer.getName())) {
+            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -315,7 +310,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (classNames.contains(longg.getName())) {
+            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -323,7 +318,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (classNames.contains(floatt.getName())) {
+            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -331,7 +326,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (classNames.contains(doublee.getName())) {
+            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -346,7 +341,7 @@ public class TYPEStmt implements StatementVisitor {

            if (binary.operation.equals(BinaryExpr.Operator.ADD)) {
                // Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                if (classNames.contains(string.getName())) {
+                if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
                    Constraint<Pair> stringConcat = new Constraint<>();
                    stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
                    stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/CancellableTask.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/CancellableTask.java
@@ -1,91 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify;
-
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.RecursiveTask;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * An intermediate class for the recursive steps of the TypeUnifyTask:
- * This allows canceling parts of the recursion tree, instead of only  the whole execution as before. But in
- * order for that to work, all cancellable child tasks must be added when they are created
- *
- * @param <T>
- */
-public abstract class CancellableTask<T> extends RecursiveTask<T> {
-
-  private final AtomicBoolean executionCancelled = new AtomicBoolean(false);
-  private final List<CancellableTask<?>> childTasks = new LinkedList<>();
-  private CancellableTask<?> parentTask = null;
-
-  /**
-   * Set the execution for this task and all its (recursive) children to be canceled
-   */
-  protected void cancelExecution() {
-    // is this branch already canceled? Then do nothing
-    if (this.executionCancelled.getAndSet(true)) return;
-    this.cancelChildExecution();
-  }
-
-  private void cancelChildExecution() {
-    synchronized (this.childTasks) {
-      for (var childTask : childTasks) {
-        // no need to cancel a branch that is already finished
-        if (!childTask.isDone()) {
-          childTask.cancelExecution();
-        }
-      }
-    }
-  }
-
-  private void cancelChildExecutionAfter(CancellableTask<?> checkpointTask) {
-    boolean reachedCheckpoint = false;
-    int i = 0;
-    for (var childTask : childTasks) {
-      if (!reachedCheckpoint) {
-        reachedCheckpoint = childTask == checkpointTask;
-      }
-      else {
-        // no need to cancel a branch that is already finished
-        if (!childTask.isDone()) {
-          childTask.cancelExecution();
-        }
-        i++;
-      }
-    }
-    System.out.println("Skipped " + i + " younger siblings");
-  }
-
-  protected void cancelSiblingTasks() {
-    if (this.parentTask != null) {
-      boolean thisWasCancelledBefore = this.executionCancelled.get();
-      this.parentTask.cancelChildExecution();
-      this.executionCancelled.set(thisWasCancelledBefore);
-    }
-  }
-
-  public void cancelYoungerSiblingTasks() {
-    if (this.parentTask != null) {
-      this.parentTask.cancelChildExecutionAfter(this);
-    }
-  }
-
-  public Boolean isExecutionCancelled() {
-    return executionCancelled.get();
-  }
-
-  public void addChildTask(CancellableTask<?> childTask) {
-    this.childTasks.add(childTask);
-    childTask.setParentTask(this);
-    if (this.executionCancelled.get()) {
-      childTask.executionCancelled.set(true);
-    }
-  }
-
-  private void setParentTask(CancellableTask<?> parentTask) {
-    this.parentTask = parentTask;
-  }
-
-}
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/MartelliMontanariUnify.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/MartelliMontanariUnify.java
@@ -94,8 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
-				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen.
-				termsList.replaceAll(mgu::apply);
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
+				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/RuleSet.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/RuleSet.java
@@ -6,7 +6,6 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.ListIterator;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
@@ -653,13 +652,12 @@ public class RuleSet implements IRuleSet{
 		HashMap<UnifyType, Integer> typeMap = new HashMap<>(200);
 		
 		Stack<UnifyType> occuringTypes = new Stack<>();
-		occuringTypes.ensureCapacity(pairs.size() * 3);
-
+		
 		for(UnifyPair pair : pairs) {
 			occuringTypes.push(pair.getLhsType());
 			occuringTypes.push(pair.getRhsType());
 		}
-
+		
 		while(!occuringTypes.isEmpty()) {
 			UnifyType t1 = occuringTypes.pop();
 			if(!typeMap.containsKey(t1))
@@ -671,9 +669,9 @@ public class RuleSet implements IRuleSet{
 			if(t1 instanceof SuperType)
 				occuringTypes.push(((SuperType) t1).getSuperedType());
 			else
-				t1.getTypeParams().forEach(occuringTypes::push);
+				t1.getTypeParams().forEach(x -> occuringTypes.push(x));	
 		}
-		LinkedList<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
+		Queue<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
 		ArrayList<UnifyPair> result = new ArrayList<UnifyPair>();
 		boolean applied = false;

@@ -694,30 +692,19 @@ public class RuleSet implements IRuleSet{
 					&& !((rhsType instanceof WildcardType) && ((WildcardType)rhsType).getWildcardedType().equals(lhsType))) //PL eigefuegt 2018-02-18
 			{
 				Unifier uni = new Unifier(lhsType,  rhsType);
-				// apply unifier to result and result1 in place
-				result.replaceAll(p -> uni.apply(pair, p));
-				ListIterator<UnifyPair> result1Iterator = result1.listIterator();
-				while (result1Iterator.hasNext()) {
-					UnifyPair x = result1Iterator.next();
-					result1Iterator.set(uni.apply(pair, x));
-				}
-
+				result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
+				result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
+				
 				Function<? super Constraint<UnifyPair>,? extends Constraint<UnifyPair>> applyUni = b -> b.stream().map(
 						x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
 								? () -> new Constraint<UnifyPair>(
 										  b.isInherited(),
 										  b.isImplemented(),
-										  b.getExtendConstraint().createdMapped(x -> uni.apply(pair,x)),
+										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)),
 										  b.getmethodSignatureConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new)))
 								: () -> new Constraint<UnifyPair>(b.isInherited(), b.isImplemented())
 									));
-				oderConstraints.replaceAll(oc -> {
-						HashSet<Constraint<UnifyPair>> mapped = new HashSet<>(oc.size());
-						for (var element : oc) {
-							mapped.add(applyUni.apply(element));
-						}
-						return mapped;
-				});
+				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
 				/*
 						oderConstraints = oderConstraints.stream().map(
 						a -> a.stream().map(applyUni
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java
@@ -45,7 +45,7 @@ public class TypeUnify2Task extends TypeUnifyTask {
               */
    //writeLog("xxx");
    //noOfThread--;
-    if (this.isExecutionCancelled()) {
+    if (this.myIsCancelled()) {
      return CompletableFuture.completedFuture(new HashSet<>());
    } else {
      return res;
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
@@ -27,7 +27,11 @@ import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
 import de.dhbwstuttgart.util.Logger;
 import de.dhbwstuttgart.util.Pair;
 import de.dhbwstuttgart.util.Tuple;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
 import java.io.Serial;
+import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -46,6 +50,7 @@ import java.util.concurrent.RecursiveTask;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
+import org.apache.commons.io.output.NullOutputStream;


 /**
@@ -53,7 +58,7 @@ import java.util.stream.Collectors;
 *
 * @author Florian Steurer
 */
-public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<UnifyPair>>>> {
+public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<UnifyPair>>>> {

  @Serial
  private static final long serialVersionUID = 1L;
@@ -113,6 +118,8 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
  public static int noShortendElements;
  public static int noou = 0;

+  boolean myIsCanceled = false;
+
  public TypeUnifyTask(UnifyContext context) {
    this.context = context.newWithLogger(Logger.NULL_LOGGER);
    rules = new RuleSet(context.placeholderRegistry());
@@ -207,6 +214,13 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
 		}		
 }
 */
+  void myCancel(boolean b) {
+    myIsCanceled = true;
+  }
+
+  public boolean myIsCancelled() {
+    return myIsCanceled;
+  }

  public CompletableFuture<Set<Set<UnifyPair>>> compute() {
    if (one) {
@@ -236,7 +250,7 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
        throw new TypeinferenceException("Unresolved constraints: " + res, new NullToken()); //return new HashSet<>();
      }

-      if (this.isExecutionCancelled()) {
+      if (this.myIsCancelled()) {
        return new HashSet<>();
      }

@@ -273,7 +287,7 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni

    //.collect(Collectors.toCollection(HashSet::new)));

-    if (this.isExecutionCancelled()) {
+    if (this.myIsCancelled()) {
      return CompletableFuture.completedFuture(new HashSet<>());
    }

@@ -302,7 +316,14 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
    /*
     * Occurs-Check durchfuehren
     */
-    Set<UnifyPair> ocurrPairs = TypeUnifyTaskHelper.occursCheck(eq);
+    Set<UnifyPair> ocurrPairs = eq.stream().filter(x -> {
+        UnifyType lhs, rhs;
+        return (lhs = x.getLhsType()) instanceof PlaceholderType
+          && !((rhs = x.getRhsType()) instanceof PlaceholderType)
+          && rhs.getTypeParams().occurs((PlaceholderType) lhs);
+      })
+      .peek(UnifyPair::setUndefinedPair)
+      .collect(Collectors.toCollection(HashSet::new));

    Set<UnifyPair> finalOcurrPairs = ocurrPairs;
    context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs);
@@ -326,7 +347,14 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
      /* In commit dfd91b5f8b7fca1cb5f302eec4b0ba3330271c9b eingefuegt ANFANG */
      Set<UnifyPair> occurcheck = new HashSet<>(eq0);
      occurcheck.removeAll(eq0Prime);
-      ocurrPairs = TypeUnifyTaskHelper.occursCheck(occurcheck);
+      ocurrPairs = occurcheck.stream().filter(x -> {
+          UnifyType lhs, rhs;
+          return (lhs = x.getLhsType()) instanceof PlaceholderType
+            && !((rhs = x.getRhsType()) instanceof PlaceholderType)
+            && rhs.getTypeParams().occurs((PlaceholderType) lhs);
+        })
+        .peek(UnifyPair::setUndefinedPair)
+        .collect(Collectors.toCollection(HashSet::new));
      Set<UnifyPair> finalOcurrPairs1 = ocurrPairs;
      context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs1);
      if (!ocurrPairs.isEmpty()) {
@@ -463,7 +491,7 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
    //		.collect(Collectors.toCollection(HashSet::new));
    //Muss auskommentiert werden, wenn computeCartesianRecursive ENDE

-    if (this.isExecutionCancelled()) {
+    if (this.myIsCancelled()) {
      return CompletableFuture.completedFuture(new HashSet<>());
    }

@@ -740,8 +768,7 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
    // Ergebnisvariable für die parallele Verabeitung: Tupel aus
    // - forkOrig result : currentThreadResult (frueher "res")
    // - fork results : forkResults (frueher "add_res")
-    CompletableFuture<VarianceCase.ComputationResults> parallelResultDataFuture;
-
+    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> parallelResultDataFuture;

    if (parallel) {
      parallelResultDataFuture = varianceCase.computeParallel(
@@ -752,16 +779,13 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
      // same as variance = 0
      elems.add(varianceCase.a); //PL 2019-01-16 muss das wirklich hin steht schon in Zeile 859 ja braucht man siehe Zeile 859
      parallelResultDataFuture =  this.unify2(elems, eq, oderConstraints, fc, false, rekTiefe, new HashSet<>(methodSignatureConstraint))
-        .thenApply(VarianceCase.ComputationResults::new);
+        .thenApply(currentThreadResult -> new Tuple<>(currentThreadResult, new HashSet<>()));
    }

-    if (this.isExecutionCancelled()) {
-      return CompletableFuture.completedFuture(new HashSet<>());
-    }

    return parallelResultDataFuture.thenCompose(parallelResultData -> {
-      Set<Set<UnifyPair>> currentThreadResult = parallelResultData.mainResult;
-      Set<Set<Set<UnifyPair>>> forkResults = parallelResultData.forkResults;
+      Set<Set<UnifyPair>> currentThreadResult = parallelResultData.getFirst();
+      Set<Set<Set<UnifyPair>>> forkResults = parallelResultData.getSecond();

      Set<Set<UnifyPair>> result = prevResult;
      List<Set<UnifyPair>> nextSetAsList = prevNextSetAsList;
@@ -858,7 +882,6 @@ public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<Uni
        // Iterator<Set<UnifyPair>> nextSetasListIt = new ArrayList<>(nextSetAsList).iterator();
        boolean shouldBreak = varianceCase.eraseInvalidSets(rekTiefe, aParDef, nextSetAsList);
        if (shouldBreak) {
-          // this.cancelYoungerSiblingTasks();
          return CompletableFuture.completedFuture(result);
        }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTaskHelper.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTaskHelper.java
@@ -186,24 +186,6 @@ public class TypeUnifyTaskHelper {
      .collect(Collectors.toCollection(ArrayList::new));
  }

-
-  public static Set<UnifyPair> occursCheck(final Set<UnifyPair> eq) {
-    Set<UnifyPair> ocurrPairs = new HashSet<>(eq.size());
-    for (UnifyPair x : eq) {
-      UnifyType lhs = x.getLhsType();
-      UnifyType rhs = x.getRhsType();
-      if (lhs instanceof PlaceholderType lhsPlaceholder &&
-        !(rhs instanceof PlaceholderType) &&
-        rhs.getTypeParams().occurs(lhsPlaceholder))
-      {
-        x.setUndefinedPair();
-        ocurrPairs.add(x);
-      }
-    }
-    return ocurrPairs;
-  }
-
-
  public static <T> HashSet<T> getPresizedHashSet(int minElements) {
    if (minElements < 16) return new HashSet<>();
    // HashSet and HashMap will resize at 75% load, so we account for that by multiplying with 1.5
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyResultModel.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyResultModel.java
@@ -26,7 +26,7 @@ public class UnifyResultModel {
 		this.fc = fc;
 	}
 	
-	private List<UnifyResultListener> listeners = new ArrayList<>();
+	private final List<UnifyResultListener> listeners = new ArrayList<>();
 	
 	public void addUnifyResultListener(UnifyResultListener listenerToAdd) {
 		listeners.add(listenerToAdd);
@@ -35,25 +35,31 @@ public class UnifyResultModel {
 	public void removeUnifyResultListener(UnifyResultListener listenerToRemove) {
 		listeners.remove(listenerToRemove);
 	}
-	
-	public void notify(Set<Set<UnifyPair>> eqPrimePrimeSet, UnifyContext context) {
-		Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
-			Optional<Set<UnifyPair>> res = new RuleSet(context.placeholderRegistry()).subst(x.stream().map(y -> {
-				if (y.getPairOp() == PairOperator.SMALLERDOTWC) y.setPairOp(PairOperator.EQUALSDOT);
-				return y; //alle Paare a <.? b erden durch a =. b ersetzt
-			}).collect(Collectors.toCollection(HashSet::new)));
-			if (res.isPresent()) {//wenn subst ein Erg liefert wurde was veraendert
-				return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), fc);
-			}
-			else return x; //wenn nichts veraendert wurde wird x zurueckgegeben
-		}).collect(Collectors.toCollection(HashSet::new));
-		List<ResultSet> newResult = eqPrimePrimeSetRet.stream().map(unifyPairs ->
-           new ResultSet(UnifyTypeFactory.convert(unifyPairs, de.dhbwstuttgart.typeinference.constraints.Pair.generateTPHMap(cons), context.placeholderRegistry())))
-           .collect(Collectors.toList());
-		UnifyResultEvent evt = new UnifyResultEvent(newResult);
-		
+
+	private synchronized void announceResult(UnifyResultEvent event) {
 		for (UnifyResultListener listener : listeners) {
-			listener.onNewTypeResultFound(evt);
+			listener.onNewTypeResultFound(event);
 		}
 	}
+
+	public void notify(Set<Set<UnifyPair>> eqPrimePrimeSet, UnifyContext context) {
+		context.executor().execute(() -> {
+			Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
+				Optional<Set<UnifyPair>> res = new RuleSet(context.placeholderRegistry()).subst(x.stream().map(y -> {
+					if (y.getPairOp() == PairOperator.SMALLERDOTWC) y.setPairOp(PairOperator.EQUALSDOT);
+					return y; //alle Paare a <.? b erden durch a =. b ersetzt
+				}).collect(Collectors.toCollection(HashSet::new)));
+				if (res.isPresent()) {//wenn subst ein Erg liefert wurde was veraendert
+					return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), fc);
+				}
+				else return x; //wenn nichts veraendert wurde wird x zurueckgegeben
+			}).collect(Collectors.toCollection(HashSet::new));
+			List<ResultSet> newResult = eqPrimePrimeSetRet.stream().map(unifyPairs ->
+					new ResultSet(UnifyTypeFactory.convert(unifyPairs, de.dhbwstuttgart.typeinference.constraints.Pair.generateTPHMap(cons), context.placeholderRegistry())))
+				.collect(Collectors.toList());
+			UnifyResultEvent evt = new UnifyResultEvent(newResult);
+
+			this.announceResult(evt);
+		});
+	}
 }
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyTaskModel.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyTaskModel.java
@@ -12,7 +12,7 @@ public class UnifyTaskModel {
    
    public synchronized void cancel() {
    	for(TypeUnifyTask t : usedTasks) {
-    		t.cancelExecution();
+    		t.myCancel(true);
    	}
    }
 }
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/UnknownVarianceCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/UnknownVarianceCase.java
@@ -13,13 +13,14 @@ import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;

-public class UnknownVarianceCase extends VarianceCase {
+public class Variance0Case extends VarianceCase {

  protected final int variance = 0;

-  protected UnknownVarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected Variance0Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -49,7 +50,7 @@ public class UnknownVarianceCase extends VarianceCase {
  }

  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
+  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -61,9 +62,10 @@ public class UnknownVarianceCase extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
-    elems.add(a);
-    return typeUnifyTask.unify2(elems, eq, oderConstraints, fc, context.parallel(), rekTiefe, new HashSet<>(methodSignatureConstraint))
-      .thenApply(ComputationResults::new);
+    elems.add(a); //PL 2019-01-16 muss das wirklich hin steht schon in Zeile 859 ja braucht man siehe Zeile 859
+    return typeUnifyTask.unify2(elems, eq, oderConstraints, fc, context.parallel(), rekTiefe, new HashSet<>(methodSignatureConstraint)).thenApply(
+      unify2Result -> new Tuple<>(unify2Result, new HashSet<>())
+    );
  }

  @Override
@@ -73,7 +75,7 @@ public class UnknownVarianceCase extends VarianceCase {
    Set<UnifyPair> compResult,
    Set<UnifyPair> compRes
  ) {
-    context.logger().debug("RES var=0 ADD:" + result.toString() + " " + currentThreadResult.toString());
+    context.logger().debug("RES var=1 ADD:" + result.toString() + " " + currentThreadResult.toString());
    result.addAll(currentThreadResult);
  }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/ContravarianceCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/ContravarianceCase.java
@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;

+import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -16,11 +17,11 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;

-public class ContravarianceCase extends VarianceCase {
+public class Variance1Case extends VarianceCase {

  protected final int variance = 1;

-  protected ContravarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected Variance1Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -36,7 +37,7 @@ public class ContravarianceCase extends VarianceCase {
    if (this.isOderConstraint) {
      nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
    }
-    context.logger().debug(() -> "nextSetasListOderConstraints 1: " + nextSetasListOderConstraints);
+    context.logger().debug("nextSetasListOderConstraints 1: " + nextSetasListOderConstraints);

    //Alle maximale Elemente in nextSetasListRest bestimmen
    //nur für diese wird parallele Berechnung angestossen.
@@ -48,7 +49,7 @@ public class ContravarianceCase extends VarianceCase {


  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
+  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -60,6 +61,10 @@ public class ContravarianceCase extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
+    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValues = CompletableFuture.completedFuture(new Tuple<>(
+      new HashSet<>(), new HashSet<>()
+    ));
+
    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
@@ -67,19 +72,18 @@ public class ContravarianceCase extends VarianceCase {

    /* FORK ANFANG */
    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
-    typeUnifyTask.addChildTask(forkOrig);
    // schedule compute() on another thread
    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
-      (currentThreadResult) -> {
+    resultValues = resultValues.thenCombine(forkOrigFuture,
+      (prevResults, currentThreadResult) -> {
        forkOrig.context.logger().debug("final Orig 1");
        forkOrig.closeLogFile();
-        return new ComputationResults(currentThreadResult);
+        return new Tuple<>(currentThreadResult, prevResults.getSecond());
      });

    //forks.add(forkOrig);
-    if (typeUnifyTask.isExecutionCancelled()) {
-      return CompletableFuture.completedFuture(new ComputationResults());
+    if (typeUnifyTask.myIsCancelled()) {
+      throw new UnifyCancelException();
    }
    /* FORK ENDE */

@@ -104,17 +108,16 @@ public class ContravarianceCase extends VarianceCase {
      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
      newElems.add(nSaL);
      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
-      typeUnifyTask.addChildTask(fork);
      // schedule compute() on another thread
      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
      resultValues = resultValues.thenCombine(forkFuture,
        (prevResults, fork_res) -> {
-          if (typeUnifyTask.isExecutionCancelled()) {
-            return new ComputationResults();
+          if (typeUnifyTask.myIsCancelled()) {
+            throw new UnifyCancelException();
          }
          context.logger().debug("fork_res: " + fork_res.toString());
          context.logger().debug(Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.addForkResult(fork_res);
+          prevResults.getSecond().add(fork_res);
          if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
            aParDef.add(fork.getNextSetElement());
          }
@@ -124,8 +127,8 @@ public class ContravarianceCase extends VarianceCase {
        }
      );

-      if (typeUnifyTask.isExecutionCancelled()) {
-        return CompletableFuture.completedFuture(new ComputationResults());
+      if (typeUnifyTask.myIsCancelled()) {
+        throw new UnifyCancelException();
      }
    }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/InvarianceOrConstraintCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/InvarianceOrConstraintCase.java
@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;

+import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -14,12 +15,11 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;

-public class InvarianceOrConstraintCase extends VarianceCase {
+public class Variance2Case extends VarianceCase {

-  // either for invariance or for oderConstraints
  protected final int variance = 2;

-  protected InvarianceOrConstraintCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected Variance2Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -37,7 +37,7 @@ public class InvarianceOrConstraintCase extends VarianceCase {


  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
+  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -49,6 +49,8 @@ public class InvarianceOrConstraintCase extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
+    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValuesFuture;
+
    context.logger().debug("var2einstieg");
    Set<TypeUnify2Task> forks = new HashSet<>();
    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
@@ -58,16 +60,14 @@ public class InvarianceOrConstraintCase extends VarianceCase {

    /* FORK ANFANG */
    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
-    typeUnifyTask.addChildTask(forkOrig);
    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply((currentThreadResult) -> {
+    resultValuesFuture = forkOrigFuture.thenApply((currentThreadResult) -> {
      forkOrig.context.logger().debug("final Orig 2");
      forkOrig.closeLogFile();
-      return new ComputationResults(currentThreadResult);
+      return new Tuple<>(currentThreadResult, new HashSet<>());
    });
-
-    if (typeUnifyTask.isExecutionCancelled()) {
-      return resultValues;
+    if (typeUnifyTask.myIsCancelled()) {
+      throw new UnifyCancelException();
    }
    /* FORK ENDE */

@@ -89,24 +89,27 @@ public class InvarianceOrConstraintCase extends VarianceCase {
      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
      newElems.add(nSaL);
      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraintForParallel));
-      typeUnifyTask.addChildTask(fork);
      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
-      resultValues = resultValues.thenCombine(forkFuture, (prevResults, fork_res) -> {
-        if (typeUnifyTask.isExecutionCancelled()) {
-          return prevResults;
+      resultValuesFuture = resultValuesFuture.thenCombine(forkFuture, (resultValues, fork_res) -> {
+        if (typeUnifyTask.myIsCancelled()) {
+          throw new UnifyCancelException();
        }
-        prevResults.addForkResult(fork_res);
+        resultValues.getSecond().add(fork_res);
        fork.context.logger().debug("final 2");
        fork.closeLogFile();
-        return prevResults;
+        return resultValues;
      });

-      if (typeUnifyTask.isExecutionCancelled()) {
-        return resultValues;
+      if (typeUnifyTask.myIsCancelled()) {
+        throw new UnifyCancelException();
      }
    }

-    return resultValues;
+    if (typeUnifyTask.myIsCancelled()) {
+      throw new UnifyCancelException();
+    }
+
+    return resultValuesFuture;
  }

  @Override
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceCase.java
@@ -5,9 +5,9 @@ import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.util.Logger;
 import de.dhbwstuttgart.util.Tuple;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -17,11 +17,11 @@ public abstract class VarianceCase {

  public static VarianceCase createFromVariance(int variance, boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    return switch (variance) {
-      case 0    -> new UnknownVarianceCase(isOderConstraint, typeUnifyTask, context);
-      case 1    -> new ContravarianceCase(isOderConstraint, typeUnifyTask, context);
-      case -1   -> new CovarianceCase(isOderConstraint, typeUnifyTask, context);
-      case 2    -> new InvarianceOrConstraintCase(isOderConstraint, typeUnifyTask, context);
-      default   -> throw new RuntimeException("Invalid variance: " + variance);
+      case 0 -> new Variance0Case(isOderConstraint, typeUnifyTask, context);
+      case 1 -> new Variance1Case(isOderConstraint, typeUnifyTask, context);
+      case -1 -> new VarianceM1Case(isOderConstraint, typeUnifyTask, context);
+      case 2 -> new Variance2Case(isOderConstraint, typeUnifyTask, context);
+      default -> throw new RuntimeException("Invalid variance: " + variance);
    };
  }

@@ -72,7 +72,7 @@ public abstract class VarianceCase {
  /**
   *
   */
-  public abstract CompletableFuture<ComputationResults> computeParallel(
+  public abstract CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -104,29 +104,4 @@ public abstract class VarianceCase {
    Set<Set<UnifyPair>> aParDef,
    List<Set<UnifyPair>> nextSetAsList
  );
-
-  /**
-   * Wrapper class for the parallel computation results
-   */
-  public static class ComputationResults {
-    public Set<Set<UnifyPair>> mainResult;
-    public Set<Set<Set<UnifyPair>>> forkResults;
-
-    public ComputationResults() {
-      this(new HashSet<>(), new HashSet<>());
-    }
-
-    public ComputationResults(Set<Set<UnifyPair>> mainResult) {
-      this(mainResult, new HashSet<>());
-    }
-
-    public ComputationResults(Set<Set<UnifyPair>> mainResult, Set<Set<Set<UnifyPair>>> forkResults) {
-      this.mainResult = mainResult;
-      this.forkResults = forkResults;
-    }
-
-    void addForkResult(Set<Set<UnifyPair>> forkResult) {
-      forkResults.add(forkResult);
-    }
-  }
 }
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceM1Case.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceM1Case.java
@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;

+import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -16,11 +17,11 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;

-public class CovarianceCase extends VarianceCase {
+public class VarianceM1Case extends VarianceCase {

  protected final int variance = -1;

-  protected CovarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected VarianceM1Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -48,7 +49,7 @@ public class CovarianceCase extends VarianceCase {


  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
+  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -60,6 +61,10 @@ public class CovarianceCase extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
+    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValues = CompletableFuture.completedFuture(new Tuple<>(
+      new HashSet<>(), new HashSet<>()
+    ));
+
    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
@@ -67,19 +72,18 @@ public class CovarianceCase extends VarianceCase {

    /* FORK ANFANG */
    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
-    typeUnifyTask.addChildTask(forkOrig);
    // schedule compute() on another thread
    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
-      (currentThreadResult) -> {
+    resultValues = resultValues.thenCombine(forkOrigFuture,
+      (prevResults, currentThreadResult) -> {
        forkOrig.context.logger().debug("final Orig -1");
        forkOrig.closeLogFile();
-        return new ComputationResults(currentThreadResult);
+        return new Tuple<>(currentThreadResult, prevResults.getSecond());
      });

    //forks.add(forkOrig);
-    if (typeUnifyTask.isExecutionCancelled()) {
-      return resultValues;
+    if (typeUnifyTask.myIsCancelled()) {
+      throw new UnifyCancelException();
    }
    /* FORK ENDE */

@@ -105,17 +109,16 @@ public class CovarianceCase extends VarianceCase {
      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
      newElems.add(nSaL);
      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
-      typeUnifyTask.addChildTask(fork);
      // schedule compute() on another thread
      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
      resultValues = resultValues.thenCombine(forkFuture,
        (prevResults, fork_res) -> {
-          if (typeUnifyTask.isExecutionCancelled()) {
-            return prevResults;
+          if (typeUnifyTask.myIsCancelled()) {
+            throw new UnifyCancelException();
          }
          context.logger().debug(() -> "fork_res: " + fork_res.toString());
          context.logger().debug(() -> Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.addForkResult(fork_res);
+          prevResults.getSecond().add(fork_res);
          if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
            aParDef.add(fork.getNextSetElement());
          }
@@ -125,8 +128,8 @@ public class CovarianceCase extends VarianceCase {
        }
      );

-      if (typeUnifyTask.isExecutionCancelled()) {
-        return resultValues;
+      if (typeUnifyTask.myIsCancelled()) {
+        throw new UnifyCancelException();
      }
    }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java
@@ -170,66 +170,30 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		left.add(p2);
 		left.add(p4);
 		*/
+		

-		Set<UnifyPair> lefteq = new HashSet<>();
-		Set<UnifyPair> leftle = new HashSet<>();
-		Set<UnifyPair> leftlewc = new HashSet<>();
-		Set<UnifyPair> lefteqOder = new HashSet<>();
-		Set<UnifyPair> lefteqRet = new HashSet<>();
-		Set<UnifyPair> leftleOder = new HashSet<>();
-		for (var x : left) {
-			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
-			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
-			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
-
-			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) lefteq.add(x);
-			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) leftle.add(x);
-			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) leftlewc.add(x);
-
-			UnifyPair y = x.getGroundBasePair();
-			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
-			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
-			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
-				lefteqOder.add(x);
-			}
-			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
-				lefteqRet.add(x);
-			}
-			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
-				leftleOder.add(x);
-			}
-		}
-
-
-		Set<UnifyPair> righteq = new HashSet<>();
-		Set<UnifyPair> rightle = new HashSet<>();
-		Set<UnifyPair> rightlewc = new HashSet<>();
-		Set<UnifyPair> righteqOder = new HashSet<>();
-		Set<UnifyPair> righteqRet = new HashSet<>();
-		Set<UnifyPair> rightleOder = new HashSet<>();
-		for (var x : right) {
-			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
-			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
-			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
-
-			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) righteq.add(x);
-			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) 	rightle.add(x);
-			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) rightlewc.add(x);
-
-			UnifyPair y = x.getGroundBasePair();
-			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
-			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
-			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
-				righteqOder.add(x);
-			}
-			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
-				righteqRet.add(x);
-			}
-			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
-				rightleOder.add(x);
-			}
-		}
-
+		Set<UnifyPair> lefteq = left.stream()
+				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> righteq = right.stream()
+				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> leftle = left.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> rightle = right.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> leftlewc = left.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> rightlewc = right.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
+				.collect(Collectors.toCollection(HashSet::new));
 		//context.logger().info(left.toString());
 		//Fall 2
 		//if (lefteq.iterator().next().getLhsType().getName().equals("AJO")) {
@@ -237,14 +201,54 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		//}
 		
 		//ODER-CONSTRAINT
-		// Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
-		// Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));

+		Set<UnifyPair> lefteqOder = left.stream()
+				.filter(x -> { UnifyPair y = x.getGroundBasePair();
+				/*try {
+					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("y: " + y.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("y.getLhsType() : " + y.getLhsType() .toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("y.getRhsType(): " + y.getRhsType().toString() +"\n");
+					((FiniteClosure)fc).logFile.write("x.getPairOp(): " + x.getPairOp().toString() +"\n\n");
+					}
+					catch (IOException ie) {
+					}	*/
+	               return (y.getLhsType() instanceof PlaceholderType && 
+	            		   !(y.getRhsType() instanceof PlaceholderType) && 
+	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
+				.collect(Collectors.toCollection(HashSet::new));
 		left.removeAll(lefteqOder);
-		left.removeAll(lefteqRet);
+		Set<UnifyPair> righteqOder = right.stream()
+				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
+	               return (y.getLhsType() instanceof PlaceholderType && 
+	            		   !(y.getRhsType() instanceof PlaceholderType) && 
+	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
+				.collect(Collectors.toCollection(HashSet::new));
 		right.removeAll(righteqOder);
+		Set<UnifyPair> lefteqRet = left.stream()
+				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
+	               return (y.getRhsType() instanceof PlaceholderType && 
+	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
+				.collect(Collectors.toCollection(HashSet::new));
+		left.removeAll(lefteqRet);
+		Set<UnifyPair> righteqRet = right.stream()
+				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
+	               return (y.getRhsType() instanceof PlaceholderType && 
+	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
+				.collect(Collectors.toCollection(HashSet::new));
 		right.removeAll(righteqRet);
-
+		Set<UnifyPair> leftleOder = left.stream()
+				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> rightleOder = right.stream()
+				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		
 		/*
 		synchronized(this) {
 					try {
@@ -269,43 +273,59 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		int compareEq;
 		if (lefteqOder.size() == 1 && righteqOder.size() == 1 && lefteqRet.size() == 1 && righteqRet.size() == 1) {
 			Match m = new Match();
-			compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair());
-
-			if (compareEq == -1) {
-				ArrayList<UnifyPair> matchList =
-						rightleOder.stream().map(x -> {
-								UnifyPair leftElem = leftleOder.stream()
+			if ((compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair())) == -1) {
+				ArrayList<UnifyPair> matchList = 
+						rightleOder.stream().map(x -> { 
+							UnifyPair leftElem = leftleOder.stream()
 														     .filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-														     .findAny().orElseThrow();
-								return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);}
-							)
-							.collect(Collectors.toCollection(ArrayList::new));
-
-				return (m.match(matchList).isPresent()) ? -1 : 0;
+														     .findAny().get(); 
+							return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);})
+											.collect(Collectors.toCollection(ArrayList::new));
+				if (m.match(matchList).isPresent()) {
+					//try { ((FiniteClosure)fc).logFile.write("result1: -1 \n\n"); } catch (IOException ie) {}
+					return -1;
+				}
+				else {
+					//try { ((FiniteClosure)fc).logFile.write("result1: 0 \n\n"); } catch (IOException ie) {}
+					return 0;
+				}
 			} else if (compareEq == 1) {
-				ArrayList<UnifyPair> matchList =
-						leftleOder.stream().map(x -> {
+				ArrayList<UnifyPair> matchList = 
+						leftleOder.stream().map(x -> { 
 							UnifyPair rightElem = rightleOder.stream()
-								.filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-								.findAny().orElseThrow();
-							return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);}
-						)
-						.collect(Collectors.toCollection(ArrayList::new));
-				return (m.match(matchList).isPresent()) ? 1 : 0;
+									                        .filter(y -> 
+									                        	y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
+									                        .findAny().get(); 
+														return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);})
+											.collect(Collectors.toCollection(ArrayList::new));
+				if (m.match(matchList).isPresent()) {
+					//try { ((FiniteClosure)fc).logFile.write("result2: 1 \n\n"); } catch (IOException ie) {}
+					return 1;
+				}
+				else {
+					//try { ((FiniteClosure)fc).logFile.write("result2: 0 \n\n"); } catch (IOException ie) {}
+					return 0;
+				}
 			} else {
 				/*
-					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("lefteqOder: " + lefteqOder.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
-					((FiniteClosure)fc).logFile.flush();
+				synchronized(this) {
+					try {
+						((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
+						((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
+						((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
+						((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
+						((FiniteClosure)fc).logFile.write("lefteqOder: " + lefteqOder.toString() +"\n");
+						((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
+						((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
+						((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
+						((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
+						((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
+						((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
+						((FiniteClosure)fc).logFile.flush();
+					}
+					catch (IOException ie) {
+					}
+				}
 				*/
 				return 0;
 			}
@@ -372,12 +392,12 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				//TODO: Hier wird bei Wildcards nicht das richtige compare aufgerufen PL 18-04-20
 				Pair<Integer, Set<UnifyPair>> int_Unifier = compare(lseq.getRhsType(), rseq.getRhsType());
 				Unifier uni = new Unifier();
-				int_Unifier.getValue().orElseThrow().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
-				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName())
+				int_Unifier.getValue().get().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName()) 
 					|| leftlewc.isEmpty() || rightlewc.isEmpty()) return int_Unifier.getKey();
 				else {
-					Set <UnifyPair> lsleuni = leftlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
-					Set <UnifyPair> rsleuni = rightlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> lsleuni = leftlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> rsleuni = rightlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
 					BinaryOperator<HashMap<UnifyType,UnifyPair>> combiner = (x,y) -> { x.putAll(y); return x;};
 				
 					HashMap<UnifyType,UnifyPair> hm;
@@ -398,7 +418,6 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				}
 			} else {
 				if (!leftlewc.isEmpty()) {
-					/*
 					Set<UnifyPair> subst;
 					subst = leftlewc.stream().map(x -> { 
 						if (x.getLhsType() instanceof PlaceholderType) {
@@ -407,7 +426,6 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						else {
 							return new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT);
 						}}).collect(Collectors.toCollection(HashSet::new));
-					 */
 					Unifier uni = new Unifier();
 					lseq = uni.apply(lseq);
 				}
--- a/src/main/java/de/dhbwstuttgart/util/Logger.java
+++ b/src/main/java/de/dhbwstuttgart/util/Logger.java
@@ -2,14 +2,11 @@ package de.dhbwstuttgart.util;

 import com.diogonunes.jcolor.Attribute;
 import de.dhbwstuttgart.core.ConsoleInterface;
-import de.dhbwstuttgart.server.SocketServer;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 import java.nio.file.Path;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
 import java.util.Arrays;
 import java.util.Objects;
 import java.util.function.Supplier;
@@ -19,12 +16,11 @@ import static com.diogonunes.jcolor.Ansi.colorize;

 public class Logger {

-  public static final Logger NULL_LOGGER = new NullLogger();
-  private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-
  protected final Writer writer;
  protected final String prefix;

+  public static Logger NULL_LOGGER = new NullLogger();
+
  public Logger() {
    this(null, "");
  }
@@ -58,7 +54,7 @@ public class Logger {
  /**
   * Create a new logger object that inherits the writer of the given logger object
   *
-   * @param logger    The old logger object that will provide the writer
+   * @param logger    The old logger object, that will provide the writer
   * @return          The new prefix for the new logger object
   */
  public static Logger inherit(Logger logger, String newPrefix) {
@@ -88,15 +84,7 @@ public class Logger {
   */
  protected void print(String s, LogLevel logLevel) {
    String coloredPrefix = this.getPrefix(logLevel);
-
-    // if we are running the server, prepend the timestamp
-    if(SocketServer.isServerRunning()) {
-      String timestamp = LocalDateTime.now().format(timeFormatter);
-      coloredPrefix = "[" + timestamp + "] " + coloredPrefix;
-    }
-
-    // output to the correct output-stream
-    if (logLevel.getValue() == LogLevel.ERROR.getValue()) {
+    if (logLevel.isHigherOrEqualTo(LogLevel.ERROR)) {
      System.out.println(coloredPrefix + s);
    }
    else {
@@ -236,7 +224,7 @@ public class Logger {
        " | " + stackTraceElement.toString()
      ).collect(Collectors.joining("\n"));

-    // if there is a cause printed afterward, announce it with the print of the exception
+    // if there will be a cause printed afterward, announce it with the print of the exception
    if (throwable.getCause() != null) {
      s += "\n\nCaused by: ";
    }