From df43564aaa1252534bda52828563d52c1d713329 Mon Sep 17 00:00:00 2001 From: Lennart Hensler Date: Thu, 27 Mar 2014 18:27:14 +0100 Subject: [PATCH] Removed the deprecated function retrievers and adjusted the DataMiningActivator and the tests --- .../impl/function/TestFunctionProvider.java | 30 +++---- .../impl/function/TestFunctionRetrievers.java | 84 ------------------- .../TestSimpleFunctionRegistryAccess.java | 24 +++--- ...stSimpleFunctionRegistryRegistrations.java | 28 +++---- .../functions/FunctionRegistry.java | 3 +- .../functions/ParallelFunctionRetriever.java | 7 -- .../datamining/impl/DataMiningActivator.java | 22 +---- ...PartitioningParallelFunctionRetriever.java | 76 ----------------- .../FilteringFunctionRetrievalWorker.java | 46 ---------- .../functions/FunctionRetrievalWorker.java | 43 ---------- ...tionParallelExternalFunctionRetriever.java | 17 ---- ...ioningParallelMarkedFunctionRetriever.java | 17 ---- .../functions/SimpleFunctionRegistry.java | 72 ++++++++++++++-- 13 files changed, 105 insertions(+), 364 deletions(-) delete mode 100644 java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionRetrievers.java delete mode 100644 java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/ParallelFunctionRetriever.java delete mode 100644 java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/AbstractPartitioningParallelFunctionRetriever.java delete mode 100644 java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FilteringFunctionRetrievalWorker.java delete mode 100644 java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FunctionRetrievalWorker.java delete mode 100644 java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitionParallelExternalFunctionRetriever.java delete mode 100644 java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitioningParallelMarkedFunctionRetriever.java diff --git a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionProvider.java b/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionProvider.java index 86e7ba73266..3d242765b72 100644 --- a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionProvider.java +++ b/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionProvider.java @@ -17,10 +17,7 @@ import com.sap.sse.datamining.factories.FunctionFactory; import com.sap.sse.datamining.functions.Function; import com.sap.sse.datamining.functions.FunctionProvider; import com.sap.sse.datamining.functions.FunctionRegistry; -import com.sap.sse.datamining.functions.ParallelFunctionRetriever; import com.sap.sse.datamining.i18n.DataMiningStringMessages; -import com.sap.sse.datamining.impl.functions.PartitionParallelExternalFunctionRetriever; -import com.sap.sse.datamining.impl.functions.PartitioningParallelMarkedFunctionRetriever; import com.sap.sse.datamining.impl.functions.RegistryFunctionsProvider; import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry; import com.sap.sse.datamining.shared.dto.FunctionDTO; @@ -32,6 +29,7 @@ import com.sap.sse.datamining.test.function.test_classes.ExtendingInterface; import com.sap.sse.datamining.test.function.test_classes.ExternalLibraryClass; import com.sap.sse.datamining.test.function.test_classes.MarkedContainer; import com.sap.sse.datamining.test.function.test_classes.SimpleClassWithMarkedMethods; +import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil; import com.sap.sse.datamining.test.util.FunctionTestsUtil; import com.sap.sse.datamining.test.util.TestsUtil; @@ -43,22 +41,20 @@ public class TestFunctionProvider { @Before public void initializeFunctionRegistry() { - functionRegistry = new SimpleFunctionRegistry(); + functionRegistry = new SimpleFunctionRegistry(ConcurrencyTestsUtil.getExecutor()); - Collection> classesToScan = new HashSet<>(); - classesToScan.add(SimpleClassWithMarkedMethods.class); - classesToScan.add(DataTypeWithContext.class); - classesToScan.add(DataTypeWithContextProcessor.class); - classesToScan.add(ExtendingInterface.class); - classesToScan.add(MarkedContainer.class); - classesToScan.add(ContainerElement.class); - ParallelFunctionRetriever markedFunctionRetriever = new PartitioningParallelMarkedFunctionRetriever(classesToScan, FunctionTestsUtil.getExecutor()); - functionRegistry.registerFunctionsRetrievedBy(markedFunctionRetriever); + Collection> internalClassesToScan = new HashSet<>(); + internalClassesToScan.add(SimpleClassWithMarkedMethods.class); + internalClassesToScan.add(DataTypeWithContext.class); + internalClassesToScan.add(DataTypeWithContextProcessor.class); + internalClassesToScan.add(ExtendingInterface.class); + internalClassesToScan.add(MarkedContainer.class); + internalClassesToScan.add(ContainerElement.class); + functionRegistry.registerAllWithInternalFunctionPolicy(internalClassesToScan); - Collection> externalClasses = new HashSet<>(); - externalClasses.add(ExternalLibraryClass.class); - ParallelFunctionRetriever externalFunctionRetriever = new PartitionParallelExternalFunctionRetriever(externalClasses, FunctionTestsUtil.getExecutor()); - functionRegistry.registerFunctionsRetrievedBy(externalFunctionRetriever); + Collection> externalClassesToScan = new HashSet<>(); + externalClassesToScan.add(ExternalLibraryClass.class); + functionRegistry.registerAllWithExternalFunctionPolicy(externalClassesToScan); } @Test diff --git a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionRetrievers.java b/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionRetrievers.java deleted file mode 100644 index 976d8cd9fd0..00000000000 --- a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestFunctionRetrievers.java +++ /dev/null @@ -1,84 +0,0 @@ -package com.sap.sse.datamining.impl.function; - -import static org.hamcrest.Matchers.is; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.fail; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.concurrent.ExecutionException; - -import org.junit.Test; - -import com.sap.sse.datamining.functions.Function; -import com.sap.sse.datamining.functions.ParallelFunctionRetriever; -import com.sap.sse.datamining.impl.functions.FunctionRetrievalWorker; -import com.sap.sse.datamining.impl.functions.PartitioningParallelMarkedFunctionRetriever; -import com.sap.sse.datamining.test.function.test_classes.ExternalLibraryClass; -import com.sap.sse.datamining.test.function.test_classes.SimpleClassWithMarkedMethods; -import com.sap.sse.datamining.test.util.FunctionTestsUtil; -import com.sap.sse.datamining.test.util.OpenDataReceiver; - -public class TestFunctionRetrievers { - - @Test - public void testMarkedFunctionRetrievalWorker() { - Collection> classesToScan = new ArrayList<>(); - classesToScan.add(SimpleClassWithMarkedMethods.class); - OpenDataReceiver>> receiver = new OpenDataReceiver<>(); - - FunctionRetrievalWorker worker = FunctionRetrievalWorker.Util.createMarkedFunctionRetrievalWorker(classesToScan, receiver); - - Collection> expectedFunctions = FunctionTestsUtil.getMarkedMethodsOfSimpleClassWithMarkedMethod(); - worker.run(); - assertThat(receiver.result, is(expectedFunctions)); - } - - @Test - public void testExternalFunctionRetrievalWorker() { - Collection> classesToScan = new ArrayList<>(); - classesToScan.add(ExternalLibraryClass.class); - OpenDataReceiver>> receiver = new OpenDataReceiver<>(); - - FunctionRetrievalWorker worker = FunctionRetrievalWorker.Util.createExternalFunctionRetrievalWorker(classesToScan, receiver); - - Collection> expectedFunctions = FunctionTestsUtil.getMethodsOfExternalLibraryClass(); - worker.run(); - assertThat(receiver.result, is(expectedFunctions)); - } - - @Test - public void testFunctionRetrievalWithManyClassesToScan() { - Collection> classesToScan = getManyClassesToScan(); - classesToScan.add(SimpleClassWithMarkedMethods.class); - assertThat("Not enough classes to scan for this test.", classesToScan.size() >= getMaximumWorkerAmount(), is(true)); - - ParallelFunctionRetriever functionRetriever = new PartitioningParallelMarkedFunctionRetriever(classesToScan , FunctionTestsUtil.getExecutor()); - - Collection> expectedFunctions = FunctionTestsUtil.getMarkedMethodsOfSimpleClassWithMarkedMethod(); - try { - Collection> retrievedFunctions = new HashSet<>(functionRetriever.start(null).get()); - assertThat(retrievedFunctions, is(expectedFunctions)); - } catch (InterruptedException | ExecutionException e) { - fail("Error during the function retrieving"); - } - } - - private int getMaximumWorkerAmount() { - return (int) (FunctionTestsUtil.getExecutor().getCorePoolSize() * 0.5); - } - - private Collection> getManyClassesToScan() { - Collection> classesToScan = new ArrayList<>(); - classesToScan.add(Math.class); - classesToScan.add(Integer.class); - classesToScan.add(String.class); - classesToScan.add(Double.class); - classesToScan.add(Long.class); - classesToScan.add(Float.class); - classesToScan.add(ExternalLibraryClass.class); - return classesToScan; - } - -} diff --git a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryAccess.java b/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryAccess.java index bece3ce3d32..2607ce2715d 100644 --- a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryAccess.java +++ b/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryAccess.java @@ -11,14 +11,12 @@ import org.junit.Test; import com.sap.sse.datamining.functions.Function; import com.sap.sse.datamining.functions.FunctionRegistry; -import com.sap.sse.datamining.functions.ParallelFunctionRetriever; -import com.sap.sse.datamining.impl.functions.PartitionParallelExternalFunctionRetriever; -import com.sap.sse.datamining.impl.functions.PartitioningParallelMarkedFunctionRetriever; import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry; import com.sap.sse.datamining.test.function.test_classes.DataTypeWithContext; import com.sap.sse.datamining.test.function.test_classes.DataTypeWithContextProcessor; import com.sap.sse.datamining.test.function.test_classes.ExternalLibraryClass; import com.sap.sse.datamining.test.function.test_classes.SimpleClassWithMarkedMethods; +import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil; import com.sap.sse.datamining.test.util.FunctionTestsUtil; public class TestSimpleFunctionRegistryAccess { @@ -27,19 +25,17 @@ public class TestSimpleFunctionRegistryAccess { @Before public void initializeTheFunctionRegistry() { - functionRegistry = new SimpleFunctionRegistry(); + functionRegistry = new SimpleFunctionRegistry(ConcurrencyTestsUtil.getExecutor()); - Collection> classesToScan = new HashSet<>(); - classesToScan.add(SimpleClassWithMarkedMethods.class); - classesToScan.add(DataTypeWithContext.class); - classesToScan.add(DataTypeWithContextProcessor.class); - ParallelFunctionRetriever markedFunctionRetriever = new PartitioningParallelMarkedFunctionRetriever(classesToScan, FunctionTestsUtil.getExecutor()); - functionRegistry.registerFunctionsRetrievedBy(markedFunctionRetriever); + Collection> internalClassesToScan = new HashSet<>(); + internalClassesToScan.add(SimpleClassWithMarkedMethods.class); + internalClassesToScan.add(DataTypeWithContext.class); + internalClassesToScan.add(DataTypeWithContextProcessor.class); + functionRegistry.registerAllWithInternalFunctionPolicy(internalClassesToScan); - Collection> externalClasses = new HashSet<>(); - externalClasses.add(ExternalLibraryClass.class); - ParallelFunctionRetriever externalFunctionRetriever = new PartitionParallelExternalFunctionRetriever(externalClasses, FunctionTestsUtil.getExecutor()); - functionRegistry.registerFunctionsRetrievedBy(externalFunctionRetriever); + Collection> externalClassesToScan = new HashSet<>(); + externalClassesToScan.add(ExternalLibraryClass.class); + functionRegistry.registerAllWithExternalFunctionPolicy(externalClassesToScan); } @Test diff --git a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryRegistrations.java b/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryRegistrations.java index 50b2fcd3340..93af22a13c5 100644 --- a/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryRegistrations.java +++ b/java/com.sap.sse.datamining.test/src/com/sap/sse/datamining/impl/function/TestSimpleFunctionRegistryRegistrations.java @@ -13,12 +13,10 @@ import org.junit.Test; import com.sap.sse.datamining.factories.FunctionFactory; import com.sap.sse.datamining.functions.Function; import com.sap.sse.datamining.functions.FunctionRegistry; -import com.sap.sse.datamining.functions.ParallelFunctionRetriever; -import com.sap.sse.datamining.impl.functions.PartitionParallelExternalFunctionRetriever; -import com.sap.sse.datamining.impl.functions.PartitioningParallelMarkedFunctionRetriever; import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry; import com.sap.sse.datamining.test.function.test_classes.ExternalLibraryClass; import com.sap.sse.datamining.test.function.test_classes.SimpleClassWithMarkedMethods; +import com.sap.sse.datamining.test.util.ConcurrencyTestsUtil; import com.sap.sse.datamining.test.util.FunctionTestsUtil; public class TestSimpleFunctionRegistryRegistrations { @@ -27,7 +25,7 @@ public class TestSimpleFunctionRegistryRegistrations { public void testSimpleRegistration() { Method dimension = FunctionTestsUtil.getMethodFromSimpleClassWithMarkedMethod("dimension"); - FunctionRegistry registry = new SimpleFunctionRegistry(); + FunctionRegistry registry = new SimpleFunctionRegistry(ConcurrencyTestsUtil.getExecutor()); registry.register(dimension); Set> expectedRegisteredFunctionsAsSet = new HashSet<>(); @@ -39,8 +37,8 @@ public class TestSimpleFunctionRegistryRegistrations { @Test public void testRegistrationByFunctionRetrievers() { - FunctionRegistry registry = new SimpleFunctionRegistry(); - registerMethodsOfTestClassesViaFunctionRetrieversTo(registry); + FunctionRegistry registry = new SimpleFunctionRegistry(ConcurrencyTestsUtil.getExecutor()); + registerMethodsOfTestClasses(registry); Set> expectedRegisteredFunctionsAsSet = new HashSet<>(); expectedRegisteredFunctionsAsSet.addAll(FunctionTestsUtil.getMarkedMethodsOfSimpleClassWithMarkedMethod()); @@ -49,23 +47,21 @@ public class TestSimpleFunctionRegistryRegistrations { assertThat(registry.getAllFunctions(), is(expectedRegisteredFunctions)); } - private void registerMethodsOfTestClassesViaFunctionRetrieversTo(FunctionRegistry registry) { - Collection> classesToScan = new HashSet<>(); - classesToScan.add(SimpleClassWithMarkedMethods.class); - ParallelFunctionRetriever markedFunctionRetriever = new PartitioningParallelMarkedFunctionRetriever(classesToScan, FunctionTestsUtil.getExecutor()); - registry.registerFunctionsRetrievedBy(markedFunctionRetriever); + private void registerMethodsOfTestClasses(FunctionRegistry registry) { + Collection> internalClassesToScan = new HashSet<>(); + internalClassesToScan.add(SimpleClassWithMarkedMethods.class); + registry.registerAllWithInternalFunctionPolicy(internalClassesToScan); - Collection> externalClasses = new HashSet<>(); - externalClasses.add(ExternalLibraryClass.class); - ParallelFunctionRetriever externalFunctionRetriever = new PartitionParallelExternalFunctionRetriever(externalClasses, FunctionTestsUtil.getExecutor()); - registry.registerFunctionsRetrievedBy(externalFunctionRetriever); + Collection> externalClassesToScan = new HashSet<>(); + externalClassesToScan.add(ExternalLibraryClass.class); + registry.registerAllWithExternalFunctionPolicy(externalClassesToScan); } @Test public void testTheMultipleRegistrationOfTheSameFunction() { Method dimension = FunctionTestsUtil.getMethodFromSimpleClassWithMarkedMethod("dimension"); - FunctionRegistry registry = new SimpleFunctionRegistry(); + FunctionRegistry registry = new SimpleFunctionRegistry(ConcurrencyTestsUtil.getExecutor()); registry.register(dimension); registry.register(dimension); registry.register(dimension); diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/FunctionRegistry.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/FunctionRegistry.java index 5cce1e875d4..35f46138657 100644 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/FunctionRegistry.java +++ b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/FunctionRegistry.java @@ -7,8 +7,9 @@ public interface FunctionRegistry { public void register(Method method); public void register(Function function); - public void registerFunctionsRetrievedBy(ParallelFunctionRetriever functionRetriever); public void registerAll(Iterable> functions); + public void registerAllWithInternalFunctionPolicy(Collection> classesToScan); + public void registerAllWithExternalFunctionPolicy(Collection> externalClassesToScan); public Collection> getAllFunctions(); public Iterable> getFunctionsOf(Class declaringClass); diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/ParallelFunctionRetriever.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/ParallelFunctionRetriever.java deleted file mode 100644 index 5ac44d0de81..00000000000 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/functions/ParallelFunctionRetriever.java +++ /dev/null @@ -1,7 +0,0 @@ -package com.sap.sse.datamining.functions; - -import com.sap.sse.datamining.components.ParallelDataRetriever; - -public interface ParallelFunctionRetriever extends ParallelDataRetriever> { - -} diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningActivator.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningActivator.java index 2aa18d54d57..1244de8cec0 100644 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningActivator.java +++ b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/DataMiningActivator.java @@ -19,10 +19,7 @@ import com.sap.sse.datamining.DataMiningServer; import com.sap.sse.datamining.functions.ClassesWithFunctionsService; import com.sap.sse.datamining.functions.FunctionProvider; import com.sap.sse.datamining.functions.FunctionRegistry; -import com.sap.sse.datamining.functions.ParallelFunctionRetriever; import com.sap.sse.datamining.i18n.DataMiningStringMessages; -import com.sap.sse.datamining.impl.functions.PartitionParallelExternalFunctionRetriever; -import com.sap.sse.datamining.impl.functions.PartitioningParallelMarkedFunctionRetriever; import com.sap.sse.datamining.impl.functions.RegistryFunctionsProvider; import com.sap.sse.datamining.impl.functions.SimpleFunctionRegistry; @@ -32,7 +29,7 @@ public class DataMiningActivator implements BundleActivator { private static final int THREAD_POOL_SIZE = Math.max(Runtime.getRuntime().availableProcessors(), 3); private static BundleContext context; - private static Collection> serviceReferences; + private static Collection> serviceReferences; private static DataMiningServer dataMiningServer; private static DataMiningStringMessages stringMessages; @@ -42,7 +39,6 @@ public class DataMiningActivator implements BundleActivator { public void start(BundleContext context) throws Exception { DataMiningActivator.context = context; serviceReferences = getAllClassesWithMarkedMethodsServices(); - stringMessages = DataMiningStringMessages.Util.getDefaultStringMessages(); executor = new ThreadPoolExecutor(THREAD_POOL_SIZE, THREAD_POOL_SIZE, 60, TimeUnit.SECONDS, new LinkedBlockingQueue()); @@ -59,7 +55,7 @@ public class DataMiningActivator implements BundleActivator { } private FunctionRegistry createAndBuildFunctionRegistry() { - FunctionRegistry functionRegistry = new SimpleFunctionRegistry(); + FunctionRegistry functionRegistry = new SimpleFunctionRegistry(getExecutor()); Set> internalClassesWithMarkedMethods = new HashSet<>(); Set> externalLibraryClasses = new HashSet<>(); @@ -77,7 +73,8 @@ public class DataMiningActivator implements BundleActivator { } } - registerFunctions(internalClassesWithMarkedMethods, externalLibraryClasses, functionRegistry); + functionRegistry.registerAllWithInternalFunctionPolicy(internalClassesWithMarkedMethods); + functionRegistry.registerAllWithExternalFunctionPolicy(externalLibraryClasses); return functionRegistry; } @@ -110,17 +107,6 @@ public class DataMiningActivator implements BundleActivator { return specificServiceReferences; } - private void registerFunctions(Set> internalClassesWithMarkedMethods, - Set> externalLibraryClasses, FunctionRegistry functionRegistry) { - ParallelFunctionRetriever internalMarkedFunctionsRetriever = new PartitioningParallelMarkedFunctionRetriever( - internalClassesWithMarkedMethods, getExecutor()); - functionRegistry.registerFunctionsRetrievedBy(internalMarkedFunctionsRetriever); - - ParallelFunctionRetriever externalLibraryFunctionsRetriever = new PartitionParallelExternalFunctionRetriever( - externalLibraryClasses, getExecutor()); - functionRegistry.registerFunctionsRetrievedBy(externalLibraryFunctionsRetriever); - } - @Override public void stop(BundleContext context) throws Exception { for (ServiceReference serviceReference : serviceReferences) { diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/AbstractPartitioningParallelFunctionRetriever.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/AbstractPartitioningParallelFunctionRetriever.java deleted file mode 100644 index 84a930c9181..00000000000 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/AbstractPartitioningParallelFunctionRetriever.java +++ /dev/null @@ -1,76 +0,0 @@ -package com.sap.sse.datamining.impl.functions; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.concurrent.CopyOnWriteArrayList; -import java.util.concurrent.ThreadPoolExecutor; - -import com.sap.sse.datamining.functions.Function; -import com.sap.sse.datamining.functions.ParallelFunctionRetriever; -import com.sap.sse.datamining.impl.components.deprecated.AbstractParallelComponent; -import com.sap.sse.datamining.workers.ComponentWorker; - -public abstract class AbstractPartitioningParallelFunctionRetriever - extends AbstractParallelComponent>> - implements ParallelFunctionRetriever { - - private List> classesToScan; - - public AbstractPartitioningParallelFunctionRetriever(Collection> classesToScan, ThreadPoolExecutor executor) { - super(executor); - this.classesToScan = new ArrayList<>(classesToScan); - } - - @Override - protected void setUpWorkersFor(Void data) { - final int workerAmount = calculateMaximumAmountOfWorkers(); - if (workerAmount >= classesToScan.size()) { - simpleWorkerSetUp(); - } else { - final int partitionSize = calculatePartitionSize(workerAmount); - partitioningWorkerSetUp(partitionSize); - } - } - - public int calculatePartitionSize(final int workerAmount) { - return (int) Math.ceil((double) classesToScan.size() / workerAmount); - } - - public int calculateMaximumAmountOfWorkers() { - return (int) (getExecutor().getCorePoolSize() * 0.5); - } - - private void simpleWorkerSetUp() { - for (Class classToScan : classesToScan) { - addWorker(createWorker(classToScan)); - } - } - - private ComponentWorker>> createWorker(Class classToScan) { - Collection> classToScanAsCollection = new HashSet<>(); - classToScanAsCollection.add(classToScan); - return createWorker(classToScanAsCollection); - } - - private void partitioningWorkerSetUp(int partitionSize) { - for (int i = 0; i < classesToScan.size(); i += partitionSize) { - List> partition = classesToScan.subList(i, i + Math.min(partitionSize, classesToScan.size() - i)); - addWorker(createWorker(partition)); - } - } - - protected abstract FunctionRetrievalWorker createWorker(Iterable> classesToScan); - - @Override - protected Collection> finalizeData() { - Collection> data = new HashSet<>(); - for (Collection> results : getResults()) { - data.addAll(results); - } - return Collections.unmodifiableCollection(new CopyOnWriteArrayList>(data)); - } - -} diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FilteringFunctionRetrievalWorker.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FilteringFunctionRetrievalWorker.java deleted file mode 100644 index c1fe2df5bbc..00000000000 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FilteringFunctionRetrievalWorker.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.sap.sse.datamining.impl.functions; - -import java.lang.reflect.Method; -import java.util.Collection; -import java.util.HashSet; - -import com.sap.sse.datamining.components.FilterCriteria; -import com.sap.sse.datamining.factories.FunctionFactory; -import com.sap.sse.datamining.functions.Function; -import com.sap.sse.datamining.impl.workers.AbstractComponentWorker; - -public class FilteringFunctionRetrievalWorker extends AbstractComponentWorker>> implements - FunctionRetrievalWorker { - - private Iterable> classesToScan; - private FilterCriteria filter; - - @Override - protected Collection> doWork() { - Collection> functions = new HashSet<>(); - for (Class classToScan : classesToScan) { - functions.addAll(getFilteredMethodsFrom(classToScan)); - } - return functions; - } - - private Collection> getFilteredMethodsFrom(Class classToScan) { - Collection> functions = new HashSet<>(); - for (Method method : classToScan.getMethods()) { - if (filter != null && filter.matches(method)) { - functions.add(FunctionFactory.createMethodWrappingFunction(method)); - } - } - return functions; - } - - @Override - public void setSource(Iterable> classesToScan) { - this.classesToScan = classesToScan; - } - - public void setFilter(FilterCriteria filterCriteria) { - this.filter = filterCriteria; - } - -} diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FunctionRetrievalWorker.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FunctionRetrievalWorker.java deleted file mode 100644 index cbb82d76534..00000000000 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/FunctionRetrievalWorker.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.sap.sse.datamining.impl.functions; - -import java.lang.reflect.Method; -import java.util.Collection; - -import com.sap.sse.datamining.components.FilterCriteria; -import com.sap.sse.datamining.functions.Function; -import com.sap.sse.datamining.impl.criterias.CompoundFilterCriteria; -import com.sap.sse.datamining.impl.criterias.OrCompoundFilterCriteria; -import com.sap.sse.datamining.workers.DataRetrievalWorker; -import com.sap.sse.datamining.workers.WorkReceiver; - -public interface FunctionRetrievalWorker extends DataRetrievalWorker>, Function> { - - public static final class Util { - - public static FunctionRetrievalWorker createMarkedFunctionRetrievalWorker(Iterable> classesToScan, WorkReceiver>> receiver) { - FilteringFunctionRetrievalWorker worker = new FilteringFunctionRetrievalWorker(); - worker.setSource(classesToScan); - worker.setReceiver(receiver); - - CompoundFilterCriteria filterCriteria = new OrCompoundFilterCriteria<>(); - filterCriteria.addCriteria(new MethodIsCorrectDimensionFilterCriteria()); - filterCriteria.addCriteria(new MethodIsCorrectSideEffectFreeValueFilterCriteria()); - worker.setFilter(filterCriteria); - - return worker; - } - - public static FunctionRetrievalWorker createExternalFunctionRetrievalWorker(Iterable> classesToScan, WorkReceiver>> receiver) { - FilteringFunctionRetrievalWorker worker = new FilteringFunctionRetrievalWorker(); - worker.setSource(classesToScan); - worker.setReceiver(receiver); - - FilterCriteria filterCriteria = new MethodIsCorrectExternalFunctionFilterCriteria(); - worker.setFilter(filterCriteria); - - return worker; - } - - } - -} diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitionParallelExternalFunctionRetriever.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitionParallelExternalFunctionRetriever.java deleted file mode 100644 index 33ff624a669..00000000000 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitionParallelExternalFunctionRetriever.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.sap.sse.datamining.impl.functions; - -import java.util.Collection; -import java.util.concurrent.ThreadPoolExecutor; - -public class PartitionParallelExternalFunctionRetriever extends AbstractPartitioningParallelFunctionRetriever { - - public PartitionParallelExternalFunctionRetriever(Collection> externalClasses, ThreadPoolExecutor executor) { - super(externalClasses, executor); - } - - @Override - protected FunctionRetrievalWorker createWorker(Iterable> classesToScan) { - return FunctionRetrievalWorker.Util.createExternalFunctionRetrievalWorker(classesToScan, this); - } - -} diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitioningParallelMarkedFunctionRetriever.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitioningParallelMarkedFunctionRetriever.java deleted file mode 100644 index 5fe3965d9af..00000000000 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/PartitioningParallelMarkedFunctionRetriever.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.sap.sse.datamining.impl.functions; - -import java.util.Collection; -import java.util.concurrent.ThreadPoolExecutor; - -public class PartitioningParallelMarkedFunctionRetriever extends AbstractPartitioningParallelFunctionRetriever { - - public PartitioningParallelMarkedFunctionRetriever(Collection> classesToScan, ThreadPoolExecutor executor) { - super(classesToScan, executor); - } - - @Override - protected FunctionRetrievalWorker createWorker(Iterable> classesToScan) { - return FunctionRetrievalWorker.Util.createMarkedFunctionRetrievalWorker(classesToScan, this); - } - -} diff --git a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/SimpleFunctionRegistry.java b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/SimpleFunctionRegistry.java index e1b6e34ad91..25c57d574cf 100644 --- a/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/SimpleFunctionRegistry.java +++ b/java/com.sap.sse.datamining/src/com/sap/sse/datamining/impl/functions/SimpleFunctionRegistry.java @@ -1,39 +1,62 @@ package com.sap.sse.datamining.impl.functions; import java.lang.reflect.Method; +import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; -import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; import java.util.logging.Level; import java.util.logging.Logger; +import com.sap.sse.datamining.AdditionalResultDataBuilder; +import com.sap.sse.datamining.components.Processor; import com.sap.sse.datamining.factories.FunctionFactory; import com.sap.sse.datamining.functions.Function; import com.sap.sse.datamining.functions.FunctionRegistry; -import com.sap.sse.datamining.functions.ParallelFunctionRetriever; +import com.sap.sse.datamining.functions.FunctionRetrievalProcessor; public class SimpleFunctionRegistry implements FunctionRegistry { private static final Logger LOGGER = Logger.getLogger(SimpleFunctionRegistry.class.getName()); + + private final ExecutorService executor; + private final Processor>> functionsReceiver; private final Map, Collection>> functionsMappedByDeclaringClass; private final Map, Collection>> dimensionsMappedByDeclaringClass; - public SimpleFunctionRegistry() { + public SimpleFunctionRegistry(ExecutorService executor) { + this.executor = executor; + functionsReceiver = new FunctionsReceiver(); + functionsMappedByDeclaringClass = new HashMap<>(); dimensionsMappedByDeclaringClass = new HashMap<>(); } @Override - public void registerFunctionsRetrievedBy(ParallelFunctionRetriever functionRetriever) { + public void registerAllWithInternalFunctionPolicy(Collection> internalClassesToScan) { + FunctionRetrievalProcessor internalFunctionsRetriever = new InternalFunctionRetrievalProcessor(executor, Arrays.asList(functionsReceiver)); + internalFunctionsRetriever.onElement(internalClassesToScan); try { - Collection> functions = functionRetriever.start(null).get(); - registerAll(functions); - } catch (InterruptedException | ExecutionException exception) { - LOGGER.log(Level.SEVERE, "Error during the function retrieving. Data-Mining may not work.", exception); + internalFunctionsRetriever.finish(); + } catch (InterruptedException exception) { + LOGGER.log(Level.SEVERE, "The functions retrieval got interrupted. Data-Mining won't work!", exception); + } + } + + @Override + public void registerAllWithExternalFunctionPolicy(Collection> externalClassesToScan) { + FunctionRetrievalProcessor externalFunctionsRetriever = new ExternalFunctionRetrievalProcessor(executor, Arrays.asList(functionsReceiver)); + externalFunctionsRetriever.onElement(externalClassesToScan); + try { + externalFunctionsRetriever.finish(); + } catch (InterruptedException exception) { + LOGGER.log(Level.SEVERE, "The functions retrieval got interrupted. Data-Mining won't work!", exception); } } @@ -100,5 +123,38 @@ public class SimpleFunctionRegistry implements FunctionRegistry { } return registeredMethods; } + + private class FunctionsReceiver implements Processor>> { + + private final Lock functionsRegistrationLock; + + public FunctionsReceiver() { + functionsRegistrationLock = new ReentrantLock(); + } + + @Override + public void onElement(Collection> element) { + functionsRegistrationLock.lock(); + try { + SimpleFunctionRegistry.this.registerAll(element); + } finally { + functionsRegistrationLock.unlock(); + } + } + + @Override + public void finish() throws InterruptedException { + } + + @Override + public void abort() { + } + + @Override + public AdditionalResultDataBuilder getAdditionalResultData(AdditionalResultDataBuilder additionalDataBuilder) { + return additionalDataBuilder; + } + + } }