Changeset 1721 for branches/autoquest-core-tasktrees-alignment

Timestamp:

09/04/14 10:42:11 (10 years ago)

Author:

rkrimmel

Message:

Doing a parallel Search for the pattern

File:

• branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java (modified) (9 diffs)

branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java

@@ -23 +23 @@
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
@@ -32 +33 @@
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 
@@ -77 +82 @@
 public class SequenceForTaskDetectionRuleAlignment implements ISessionScopeRule {
         
-        
-
+        public static int nThreads = Runtime.getRuntime().availableProcessors()-1;
+
+        
         private int iteration = 0;
         /**
@@ -94 +100 @@
          */
         private ITaskBuilder taskBuilder;
+        
 
         /**
@@ -649 +656 @@
                 
                 // Generate pairwise alignments
-                int size = appData.getNumberSequences().size();
-                Console.traceln(Level.INFO, "generating pairwise alignments from " + size + " sessions");
+                int numberSeqSize = appData.getNumberSequences().size();
+                Console.traceln(Level.INFO, "generating pairwise alignments from " + numberSeqSize + " sessions");
                 int count = 0;
                 
@@ -657 +664 @@
                 if(!(aligned.exists() && !aligned.isDirectory())) {
                         appData.matchseqs = new LinkedList<Match>();
-                        System.out.println(appData.matchseqs);
                         for (int i = 0; i < appData.getNumberSequences().size(); i++) {
                                 NumberSequence ns1 = appData.getNumberSequences().get(i);
                                 count++;
-                                
-                                //Print out the progress
-                                if(size>100) {
-                                        if((count%(size/100)==0)) {     
-                                                Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-                                        }
-                                }
-                                else {
-                                        Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-                                }
+                                printProgressPercentage(count,numberSeqSize);
                                 for (int j = 0; j < appData.getNumberSequences().size(); j++) {
                                         NumberSequence ns2 = appData.getNumberSequences().get(j);
@@ -690 +687 @@
 
 
-                Console.traceln(Level.INFO, "searching for patterns occuring most");
-                
-                count = 0;
-                size=appData.getMatchseqs().size();
-                Console.traceln(Level.INFO, "Pattern count is " + size);
-                // search each match in every other sequence
-                for (Iterator<Match> it = appData.getMatchseqs().iterator(); it.hasNext();) {
-                        Match pattern = it.next();
-                        count++;
-                        //Print out the progress
-                        if(size>100) {
-                                if((count%(size/100)==0)) {     
-                                        Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-                                }
-                        }
-                        else {
-                                Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-                        }
-                        // Skip sequences with more 0 events (scrolls) than other events.
-                        // Both of the pattern sequences are equally long, so the zero
-                        // counts just need to be smaller than the length of one sequence
-                        if (pattern.getFirstSequence().eventCount(0)
-                                        + pattern.getSecondSequence().eventCount(0) + 1 > pattern
-                                        .getFirstSequence().size())
-                                continue;
-
-                        for (int j = 0; j < appData.getNumberSequences().size(); j++) {
-                                LinkedList<Integer> startpositions = appData
-                                                .getNumberSequences().get(j).containsPattern(pattern);
-                                if (startpositions.size() > 0) {
-                                        for (Iterator<Integer> jt = startpositions.iterator(); jt
-                                                        .hasNext();) {
-                                                int start = jt.next();
-                                                pattern.addOccurence(new MatchOccurence(start, start
-                                                                + pattern.size(), j));
-                                        }
-
-                                }
-                        }
-                }
-
+                Console.traceln(Level.INFO, "searching for patterns occuring most with " + nThreads + " threads");
+                
+                //Prepare parallel search of matchseqs
+                ExecutorService executor = Executors.newFixedThreadPool(nThreads);
+                int matchSeqSize=appData.getMatchseqs().size();
+                int interval = Math.round(matchSeqSize/nThreads);
+                int rest = matchSeqSize % nThreads;
+                
+                for(int i =0;i<matchSeqSize-interval;i+=interval) {
+                        int offset =0;
+                        if(rest!=0) {
+                                offset=1;
+                                rest--;
+                        }
+                        int from = i;
+                        int to = i+interval+offset;
+                        System.out.println("Creating thread with matches from " + from + " to " + to);
+                        // search each match in every other sequence
+                        ParallelMatchOcurrencesFinder finder = new ParallelMatchOcurrencesFinder(appData,from,to);
+                        executor.execute(finder);
+                }
+                executor.shutdown();
+                try {
+                        executor.awaitTermination(2, TimeUnit.HOURS);
+                } catch (InterruptedException e) {
+                        // TODO Auto-generated catch block
+                        e.printStackTrace();
+                }
+                
+                
                 Console.traceln(Level.INFO, "sorting results");
                 // Sort results to get the most occurring results
@@ -839 +825 @@
                 appData.getStopWatch().stop("replacing tasks");
         }
+        
+        
+        //Print out the progress
+         private static void printProgressPercentage(int count, int size) {
+                
+                if(size>100) {
+                        if((count%(size/100)==0)) {     
+                                Console.traceln(Level.INFO,("Thread" + Thread.currentThread().getName() + ": " + Math.round((float) count/size*100))+ "%");
+                        }
+                }
+                else {
+                        Console.traceln(Level.INFO,("Thread" + Thread.currentThread().getName() + ": " +Math.round((float) count/size*100))+ "%");
+                }
+        }
+        
+         
+         
+        
+        private class ParallelMatchOcurrencesFinder implements Runnable {
+        private final RuleApplicationData appData;
+        private final int from;
+        private final int to;
+            ParallelMatchOcurrencesFinder(RuleApplicationData appData, int from, int to) {
+            this.appData = appData;
+            this.from = from;
+            this.to = to;
+        }
+        
+        @Override
+        public void run() {
+                int count = 0;
+                int size=to-from;
+                Console.traceln(Level.INFO, "Pattern count is " + size);
+                for (int i=from; i<to;i++) { {
+                        Match pattern = appData.getMatchseqs().get(i);
+                        count++;
+                        printProgressPercentage(count,size);
+                        // Skip sequences with more 0 events (scrolls) than other events.
+                        // Both of the pattern sequences are equally long, so the zero
+                        // counts just need to be smaller than the length of one sequence
+                        if (pattern.getFirstSequence().eventCount(0)
+                                        + pattern.getSecondSequence().eventCount(0) + 1 > pattern
+                                        .getFirstSequence().size())
+                                continue;
+
+                        for (int j = 0; j < appData.getNumberSequences().size(); j++) {
+                                LinkedList<Integer> startpositions = appData
+                                                .getNumberSequences().get(j).containsPattern(pattern);
+                                if (startpositions.size() > 0) {
+                                        for (Iterator<Integer> jt = startpositions.iterator(); jt
+                                                        .hasNext();) {
+                                                int start = jt.next();
+                                                pattern.addOccurence(new MatchOccurence(start, start
+                                                                + pattern.size(), j));
+                                        }
+
+                                }
+                        }
+                }  
+        }
+        }
+        }
+        
+        
+
 
         /**
@@ -895 +946 @@
                         submat= new ObjectDistanceSubstitionMatrix(6,-3,false);
                         newTasks = new LinkedList<ITask>();
-                        this.detectedAndReplacedTasks = true;
+                        
+                        //this.detectedAndReplacedTasks = true;
                 }