added threading support

horeilly1101 · Jun 15, 2019 · 8b8690c · 8b8690c
1 parent d521147
commit 8b8690c
Show file tree

Hide file tree

Showing 4 changed files with 47 additions and 13 deletions.
diff --git a/src/main/java/com/deriv/expression/ExpressionUtils.java b/src/main/java/com/deriv/expression/ExpressionUtils.java
@@ -1,9 +1,8 @@
 package com.deriv.expression;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 import java.util.function.Function;
 
 import static java.util.stream.Collectors.joining;
@@ -62,4 +61,12 @@ static <T> List<T> shallowCopy(List<T> lst) {
   static <T> String mapAndJoin(Collection<T> inputCollection, Function<T, String> mapping, String delimiter) {
     return inputCollection.stream().map(mapping).collect(joining(delimiter));
   }
+
+  static <T> Optional<T> oGetFuture(Future<Optional<T>> futureOptional) {
+    try {
+      return futureOptional.get();
+    } catch (InterruptedException | ExecutionException e){
+      return Optional.empty();
+    }
+  }
 }
diff --git a/src/main/java/com/deriv/expression/Log.java b/src/main/java/com/deriv/expression/Log.java
@@ -1,10 +1,14 @@
 package com.deriv.expression;
 
+import com.deriv.util.ThreadManager;
+
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.Future;
 
 import static com.deriv.expression.Constant.*;
 import static com.deriv.expression.Mult.*;
+import static com.deriv.expression.ExpressionUtils.*;
 
 /**
  * A log is the logarithm of an Expression. (I should note that throughout the code
@@ -95,11 +99,13 @@ public String toLaTex() {
 
   @Override
   public Optional<Expression> evaluate(Variable var, Expression val) {
+    Future<Optional<Expression>> futureBase = ThreadManager.submitTask(() -> _result.evaluate(var, val));
+
     return _base.evaluate(var, val)
-               .flatMap(ba -> _result.evaluate(var, val)
-                                  .flatMap(re -> re.isConstant() && re.asConstant().getVal() <= 0
-                                                     ? Optional.empty()
-                                                     : Optional.of(log(ba, re))));
+               .flatMap(ba -> oGetFuture(futureBase)
+                       .flatMap(re -> re.isConstant() && re.asConstant().getVal() <= 0
+                               ? Optional.empty()
+                               : Optional.of(log(ba, re))));
   }
 
   @Override

diff --git a/src/main/java/com/deriv/expression/Power.java b/src/main/java/com/deriv/expression/Power.java
@@ -1,6 +1,8 @@
 package com.deriv.expression;
 
 import com.deriv.expression.simplifier.PowerSimplifier;
+import com.deriv.util.ThreadManager;
+
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.Future;
@@ -126,12 +128,14 @@ public String toLaTex() {
 
   @Override
   public Optional<Expression> evaluate(Variable var, Expression input) {
+    Future<Optional<Expression>> futureExponent = ThreadManager.submitTask(() -> _exponent.evaluate(var, input));
+
     return _base.evaluate(var, input)
-               .flatMap(ba -> _exponent.evaluate(var, input)
-                                // make sure we're not dividing by zero
-                                 .flatMap(ex -> ba.equals(addID()) && ex.isNegative()
-                                                 ? Optional.empty()
-                                                 : Optional.of(power(ba, ex))));
+               .flatMap(ba -> ExpressionUtils.oGetFuture(futureExponent)
+                       .flatMap(ex -> ba.equals(addID()) && ex.isNegative()
+                               // make sure we're not dividing by zero
+                               ? Optional.empty()
+                               : Optional.of(power(ba, ex))));
   }
 
   @Override

diff --git a/src/main/java/com/deriv/util/ThreadManager.java b/src/main/java/com/deriv/util/ThreadManager.java
@@ -0,0 +1,17 @@
+package com.deriv.util;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+/**
+ * Thin wrapper around a thread pool.
+ */
+public class ThreadManager {
+    private static final ExecutorService EXECUTOR_SERVICE = Executors.newCachedThreadPool();
+
+    public static <T> Future<T> submitTask(Callable<T> computation) {
+        return EXECUTOR_SERVICE.submit(computation);
+    }
+}