X-Git-Url: https://git.donarmstrong.com/?p=mothur.git;a=blobdiff_plain;f=parsimony.cpp;h=b12ca1fe742240a4c80e96d0d82bcb2ef612fa18;hp=6ec6c57823a9055b6b70a97b9b9b06b6bb00074b;hb=df7e3ff9f68ef157b0328a2d353c3258c5d45d89;hpb=19fcbbdba99658f5eca244803280f9ee7f9f6607

diff --git a/parsimony.cpp b/parsimony.cpp
index 6ec6c57..b12ca1f 100644
--- a/parsimony.cpp
+++ b/parsimony.cpp
@@ -15,17 +15,19 @@ EstOutput Parsimony::getValues(Tree* t, int p, string o) {
 	try {
 		processors = p;
 		outputDir = o;
+        CountTable* ct = t->getCountTable();
 		
 		//if the users enters no groups then give them the score of all groups
-		int numGroups = m->Groups.size();
+		vector<string> mGroups = m->getGroups();
+		int numGroups = mGroups.size();
 		
 		//calculate number of comparsions
 		int numComp = 0;
 		vector< vector<string> > namesOfGroupCombos;
 		for (int r=0; r<numGroups; r++) { 
-			for (int l = r+1; l < numGroups; l++) {
+			for (int l = 0; l < r; l++) {
 				numComp++;
-				vector<string> groups; groups.push_back(m->Groups[r]); groups.push_back(m->Groups[l]);
+				vector<string> groups; groups.push_back(mGroups[r]); groups.push_back(mGroups[l]);
 				//cout << globaldata->Groups[r] << '\t' << globaldata->Groups[l] << endl;
 				namesOfGroupCombos.push_back(groups);
 			}
@@ -36,46 +38,34 @@ EstOutput Parsimony::getValues(Tree* t, int p, string o) {
 			vector<string> groups;
 			if (numGroups == 0) {
 				//get score for all users groups
-				for (int i = 0; i < tmap->namesOfGroups.size(); i++) {
-					if (tmap->namesOfGroups[i] != "xxx") {
-						groups.push_back(tmap->namesOfGroups[i]);
+				vector<string> tGroups = ct->getNamesOfGroups();
+				for (int i = 0; i < tGroups.size(); i++) {
+					if (tGroups[i] != "xxx") {
+						groups.push_back(tGroups[i]);
 						//cout << tmap->namesOfGroups[i] << endl;
 					}
 				}
 				namesOfGroupCombos.push_back(groups);
 			}else {
-				for (int i = 0; i < m->Groups.size(); i++) {
-					groups.push_back(m->Groups[i]);
+				for (int i = 0; i < mGroups.size(); i++) {
+					groups.push_back(mGroups[i]);
 					//cout << globaldata->Groups[i] << endl;
 				}
 				namesOfGroupCombos.push_back(groups);
 			}
 		}
-		
-	#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
-		if(processors == 1){
-			data = driver(t, namesOfGroupCombos, 0, namesOfGroupCombos.size());
-		}else{
-			lines.clear();
-			int numPairs = namesOfGroupCombos.size();
-			
-			int numPairsPerProcessor = numPairs / processors;
-			
-			for (int i = 0; i < processors; i++) {
-				int startPos = i * numPairsPerProcessor;
-				
-				if(i == processors - 1){
-					numPairsPerProcessor = numPairs - i * numPairsPerProcessor;
-				}
-				
-				lines.push_back(linePair(startPos, numPairsPerProcessor));
-			}
-			
-			data = createProcesses(t, namesOfGroupCombos);
-		}
-	#else
-		data = driver(t, namesOfGroupCombos, 0, namesOfGroupCombos.size());
-	#endif
+        
+        lines.clear();
+        int numPairs = namesOfGroupCombos.size();
+        int numPairsPerProcessor = numPairs / processors;
+        
+        for (int i = 0; i < processors; i++) {
+            int startPos = i * numPairsPerProcessor;
+            if(i == processors - 1){ numPairsPerProcessor = numPairs - i * numPairsPerProcessor; }
+            lines.push_back(linePair(startPos, numPairsPerProcessor));
+        }
+        
+        data = createProcesses(t, namesOfGroupCombos, ct);
 		
 		return data;
 		
@@ -87,14 +77,15 @@ EstOutput Parsimony::getValues(Tree* t, int p, string o) {
 }
 /**************************************************************************************************/
 
-EstOutput Parsimony::createProcesses(Tree* t, vector< vector<string> > namesOfGroupCombos) {
+EstOutput Parsimony::createProcesses(Tree* t, vector< vector<string> > namesOfGroupCombos, CountTable* ct) {
 	try {
-#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
-		int process = 1;
+        int process = 1;
 		vector<int> processIDS;
 		
 		EstOutput results;
-		
+
+#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
+				
 		//loop through and create all the processes you want
 		while (process != processors) {
 			int pid = fork();
@@ -104,7 +95,7 @@ EstOutput Parsimony::createProcesses(Tree* t, vector< vector<string> > namesOfGr
 				process++;
 			}else if (pid == 0){
 				EstOutput myresults;
-				myresults = driver(t, namesOfGroupCombos, lines[process].start, lines[process].num);
+				myresults = driver(t, namesOfGroupCombos, lines[process].start, lines[process].num, ct);
 				
 				if (m->control_pressed) { exit(0); }
 				
@@ -124,7 +115,7 @@ EstOutput Parsimony::createProcesses(Tree* t, vector< vector<string> > namesOfGr
 			}
 		}
 		
-		results = driver(t, namesOfGroupCombos, lines[0].start, lines[0].num);
+		results = driver(t, namesOfGroupCombos, lines[0].start, lines[0].num, ct);
 		
 		//force parent to wait until all the processes are done
 		for (int i=0;i<processIDS.size();i++) { 
@@ -157,9 +148,47 @@ EstOutput Parsimony::createProcesses(Tree* t, vector< vector<string> > namesOfGr
 			in.close();
 			m->mothurRemove(s);
 		}
+#else
+        //fill in functions
+        vector<parsData*> pDataArray;
+		DWORD   dwThreadIdArray[processors-1];
+		HANDLE  hThreadArray[processors-1];
+        vector<CountTable*> cts;
+        vector<Tree*> trees;
+		
+		//Create processor worker threads.
+		for( int i=1; i<processors; i++ ){
+            CountTable* copyCount = new CountTable();
+            copyCount->copy(ct);
+            Tree* copyTree = new Tree(copyCount);
+            copyTree->getCopy(t);
+            
+            cts.push_back(copyCount);
+            trees.push_back(copyTree);
+            
+            parsData* temppars = new parsData(m, lines[i].start, lines[i].num, namesOfGroupCombos, copyTree, copyCount);
+			pDataArray.push_back(temppars);
+			processIDS.push_back(i);
+            
+			hThreadArray[i-1] = CreateThread(NULL, 0, MyParsimonyThreadFunction, pDataArray[i-1], 0, &dwThreadIdArray[i-1]);
+		}
+		
+		results = driver(t, namesOfGroupCombos, lines[0].start, lines[0].num, ct);
+		
+		//Wait until all threads have terminated.
+		WaitForMultipleObjects(processors-1, hThreadArray, TRUE, INFINITE);
+		
+		//Close all thread handles and free memory allocations.
+		for(int i=0; i < pDataArray.size(); i++){
+            for (int j = 0; j < pDataArray[i]->results.size(); j++) {  results.push_back(pDataArray[i]->results[j]);  }
+			delete cts[i];
+            delete trees[i];
+			CloseHandle(hThreadArray[i]);
+			delete pDataArray[i];
+		}
 		
-		return results;
 #endif		
+        return results;
 	}
 	catch(exception& e) {
 		m->errorOut(e, "Parsimony", "createProcesses");
@@ -167,12 +196,12 @@ EstOutput Parsimony::createProcesses(Tree* t, vector< vector<string> > namesOfGr
 	}
 }
 /**************************************************************************************************/
-EstOutput Parsimony::driver(Tree* t, vector< vector<string> > namesOfGroupCombos, int start, int num) { 
+EstOutput Parsimony::driver(Tree* t, vector< vector<string> > namesOfGroupCombos, int start, int num, CountTable* ct) { 
 	try {
 		
 		EstOutput results; results.resize(num);
 		
-		Tree* copyTree = new Tree(tmap);
+		Tree* copyTree = new Tree(ct);
 		int count = 0;
 		
 		for (int h = start; h < (start+num); h++) {