Fixing bugs with how measurements&phases are recorded for control points.
authorIsaac Dooley <isaacdooley@hope.cs.uiuc.edu>
Thu, 14 Jan 2010 21:17:52 +0000 (15:17 -0600)
committerIsaac Dooley <isaacdooley@hope.cs.uiuc.edu>
Thu, 14 Jan 2010 21:17:52 +0000 (15:17 -0600)
src/ck-cp/controlPoints.C
src/ck-cp/controlPoints.h

index dc58f716249ecd63b20103f9c9273e53f66cd62e..e95b12dedaf460e8a006dbda5be76f1cc9b3cce0 100644 (file)
@@ -181,7 +181,7 @@ controlPointManager::controlPointManager(){
     alreadyRequestedIdleTime = false;
     alreadyRequestedAll = false;
     
-    instrumentedPhase newPhase;
+    instrumentedPhase * newPhase = new instrumentedPhase();
     allData.phases.push_back(newPhase);   
     
     dataFilename = (char*)malloc(128);
@@ -258,29 +258,29 @@ controlPointManager::controlPointManager(){
       while(line[0] == '#')
        getline(infile,line); 
 
-      instrumentedPhase ips;
+      instrumentedPhase * ips = new instrumentedPhase();
 
       std::istringstream iss(line);
 
       // Read memory usage for phase
-      iss >> ips.memoryUsageMB;
+      iss >> ips->memoryUsageMB;
       //     CkPrintf("Memory usage loaded from file: %d\n", ips.memoryUsageMB);
 
-      iss >> ips.idleTime.min;
-      iss >> ips.idleTime.avg;
-      iss >> ips.idleTime.max;
+      iss >> ips->idleTime.min;
+      iss >> ips->idleTime.avg;
+      iss >> ips->idleTime.max;
 
       // Read control point values
       for(int cp=0;cp<numControlPointNames;cp++){
        int cpvalue;
        iss >> cpvalue;
-       ips.controlPoints.insert(make_pair(names[cp],cpvalue));
+       ips->controlPoints.insert(make_pair(names[cp],cpvalue));
       }
 
       double time;
 
       while(iss >> time){
-       ips.times.push_back(time);
+       ips->times.push_back(time);
 #if DEBUGPRINT > 5
        CkPrintf("read time %lf from file\n", time);
 #endif
@@ -299,9 +299,11 @@ controlPointManager::controlPointManager(){
   void controlPointManager::writeDataFile(){
     CkPrintf("============= writeDataFile() ============\n");
     ofstream outfile(dataFilename);
-    //    allData.phases.push_back(thisPhaseData);
     allData.cleanupNames();
 
+    //  string s = allData.toString();
+    //  CkPrintf("At end: \n %s\n", s.c_str());
+
     allData.verify();
     allData.filterOutIncompletePhases();
 
@@ -537,7 +539,7 @@ controlPointManager::controlPointManager(){
   instrumentedPhase * controlPointManager::currentPhaseData(){
     int s = allData.phases.size();
     CkAssert(s>=1);
-    return &(allData.phases[s-1]);
+    return allData.phases[s-1];
   }
  
 
@@ -545,7 +547,7 @@ controlPointManager::controlPointManager(){
   instrumentedPhase * controlPointManager::previousPhaseData(){
     int s = allData.phases.size();
     if(s >= 2 && phase_id > 0) {
-      return &(allData.phases[s-2]);
+      return allData.phases[s-2];
     } else {
       return NULL;
     }
@@ -555,7 +557,7 @@ controlPointManager::controlPointManager(){
   instrumentedPhase * controlPointManager::twoAgoPhaseData(){
     int s = allData.phases.size();
     if(s >= 3 && phase_id > 0) {
-      return &(allData.phases[s-3]);
+      return allData.phases[s-3];
     } else {
       return NULL;
     }
@@ -630,7 +632,7 @@ controlPointManager::controlPointManager(){
     
 
     // Create new entry for the phase we are starting now
-    instrumentedPhase newPhase;
+    instrumentedPhase * newPhase = new instrumentedPhase();
     allData.phases.push_back(newPhase);
     
     CkPrintf("Now in phase %d allData.phases.size()=%d\n", phase_id, allData.phases.size());
@@ -737,7 +739,7 @@ controlPointManager::controlPointManager(){
     double *over = data+3;
     double *mem = data+6;
 
-    std::string b = allData.toString();
+    //    std::string b = allData.toString();
 
     instrumentedPhase* prevPhase = previousPhaseData();
     if(prevPhase != NULL){
@@ -746,18 +748,16 @@ controlPointManager::controlPointManager(){
       prevPhase->idleTime.max = idle[2];
       
       prevPhase->memoryUsageMB = mem[0];
-
       
-      CkPrintf("Stored idle time min=%lf mem=%lf in prevPhase=%p\n", (double)prevPhase->idleTime.min, (double)prevPhase->memoryUsageMB, prevPhase);
-      prevPhase->print();
-      CkPrintf("prevPhase=%p number of timings=%d\n", prevPhase, prevPhase->times.size() );
-
-      std::string a = allData.toString();
+      CkPrintf("Stored idle time min=%lf, mem=%lf in prevPhase=%p\n", (double)prevPhase->idleTime.min, (double)prevPhase->memoryUsageMB, prevPhase);
 
-      CkPrintf("Before:\n%s\nAfter:\n%s\n\n", b.c_str(), a.c_str());
-      
+      //      prevPhase->print();
+      // CkPrintf("prevPhase=%p number of timings=%d\n", prevPhase, prevPhase->times.size() );
 
+      //      std::string a = allData.toString();
 
+      //CkPrintf("Before:\n%s\nAfter:\n%s\n\n", b.c_str(), a.c_str());
+      
     } else {
       CkPrintf("There is no previous phase to store measurements\n");
     }
@@ -1077,15 +1077,15 @@ void controlPointManager::generatePlan() {
     static bool firstTime = true;
     if(firstTime){
       firstTime = false;
-      instrumentedPhase best = allData.findBest(); 
+      instrumentedPhase *best = allData.findBest(); 
       CkPrintf("Best known phase is:\n");
-      best.print();
+      best->print();
       CkPrintf("\n");
       
       std::map<std::string, std::pair<int,int> >::const_iterator cpsIter;
       for(cpsIter=controlPointSpace.begin(); cpsIter != controlPointSpace.end(); ++cpsIter) {
        const std::string &name = cpsIter->first;
-       newControlPoints[name] =  best.controlPoints[name];
+       newControlPoints[name] =  best->controlPoints[name];
       }
     }
 
@@ -1173,9 +1173,9 @@ void controlPointManager::generatePlan() {
     //  nearby it, with a radius decreasing as phases increase
 
     CkPrintf("Finding best phase\n");
-    instrumentedPhase bestPhase = allData.findBest();  
+    instrumentedPhase *bestPhase = allData.findBest();  
     CkPrintf("best found:\n"); 
-    bestPhase.print(); 
+    bestPhase->print(); 
     CkPrintf("\n"); 
     
 
@@ -1190,7 +1190,7 @@ void controlPointManager::generatePlan() {
       const int minValue = bounds.first;
       const int maxValue = bounds.second;
       
-      const int before = bestPhase.controlPoints[name];   
+      const int before = bestPhase->controlPoints[name];   
   
       const int range = (maxValue-minValue+1)*(1.0-progress);
 
@@ -1239,18 +1239,18 @@ void controlPointManager::generatePlan() {
   
     // Increment until finding an unused configuration
     allData.cleanupNames(); // put -1 values in for any control points missing
-    std::vector<instrumentedPhase> &phases = allData.phases;     
+    std::vector<instrumentedPhase*> &phases = allData.phases;     
 
     while(true){
     
-      std::vector<instrumentedPhase>::iterator piter; 
+      std::vector<instrumentedPhase*>::iterator piter; 
       bool testedConfiguration = false; 
       for(piter = phases.begin(); piter != phases.end(); piter++){ 
       
        // Test if the configuration matches this phase
        bool match = true;
        for(int j=0;j<numDimensions;j++){
-         match &= piter->controlPoints[names[j]] == config[j];
+         match &= (*piter)->controlPoints[names[j]] == config[j];
        }
       
        if(match){
@@ -1284,12 +1284,12 @@ void controlPointManager::generatePlan() {
        config[i]= (lowerBounds[i]+upperBounds[i]) / 2;
       }
     }
-  
 
     // results are now in config[i]
     
     for(int i=0; i<numDimensions; i++){
       newControlPoints[names[i]] = config[i];
+      CkPrintf("Exhaustive search chose:   %s   -> %d\n", names[i].c_str(), config[i]);
     }
 
 
@@ -1314,10 +1314,11 @@ int controlPoint(const char *name, int lb, int ub){
   int result;
 
   // if we already have control point values for phase, return them
-  if( thisPhaseData->controlPoints.count(std::string(name))>0 ){
+  if( thisPhaseData->controlPoints.count(std::string(name))>0 && thisPhaseData->controlPoints[std::string(name)]>=0 ){
+    CkPrintf("Already have control point values for phase. %s -> %d\n", name, (int)(thisPhaseData->controlPoints[std::string(name)]) );
     return thisPhaseData->controlPoints[std::string(name)];
   }
-
+  
 
   if( phase_id < 4 ){
     // For the first few phases, just use the lower bound. 
@@ -1326,20 +1327,24 @@ int controlPoint(const char *name, int lb, int ub){
   } else if(controlPointSpace.count(std::string(name)) == 0){
     // if this is the first time we've seen the CP, then return the lower bound
     result = lb;
+    
   }  else {
     // Generate a plan one time for each phase
     controlPointManagerProxy.ckLocalBranch()->generatePlan();
     
-    // Return the planned value:
+    // Use the planned value:
     result = controlPointManagerProxy.ckLocalBranch()->newControlPoints[std::string(name)];
-    CkPrintf("Control Point \"%s\" for phase %d is: %d\n", name, phase_id, result);
     
   }
 
   CkAssert(isInRange(result,ub,lb));
-  thisPhaseData->controlPoints.insert(std::make_pair(std::string(name),result)); 
+  thisPhaseData->controlPoints[std::string(name)] = result; // was insert() 
+
   controlPointSpace.insert(std::make_pair(std::string(name),std::make_pair(lb,ub))); 
 
+  CkPrintf("Control Point \"%s\" for phase %d is: %d\n", name, phase_id, result);
+  //  thisPhaseData->print();
+  
   return result;
 }
 
index d39d5072fa581ea75ef3b7f33209bfca099e93bb..9abc9f1173e83f5a69045826a393a75d52c13bba 100644 (file)
@@ -305,17 +305,17 @@ class instrumentedData {
 public:
 
   /// Stores all known instrumented phases(loaded from file, or from this run)
-  std::vector<instrumentedPhase> phases;
+  std::vector<instrumentedPhase*> phases;
 
   /// get control point names for all phases
   std::set<std::string> getNames(){
     std::set<std::string> names;
     
-    std::vector<instrumentedPhase>::iterator iter;
+    std::vector<instrumentedPhase*>::iterator iter;
     for(iter = phases.begin();iter!=phases.end();iter++) {
       
       std::map<std::string,int>::iterator iter2;
-      for(iter2 = iter->controlPoints.begin(); iter2 != iter->controlPoints.end(); iter2++){
+      for(iter2 = (*iter)->controlPoints.begin(); iter2 != (*iter)->controlPoints.end(); iter2++){
        names.insert(iter2->first);
       }
       
@@ -328,9 +328,9 @@ public:
   void cleanupNames(){
     std::set<std::string> names = getNames();
     
-    std::vector<instrumentedPhase>::iterator iter;
+    std::vector<instrumentedPhase*>::iterator iter;
     for(iter = phases.begin();iter!=phases.end();iter++) {
-      iter->addAllNames(names);
+      (*iter)->addAllNames(names);
     }
   }
 
@@ -339,9 +339,9 @@ public:
   bool filterOutOnePhase(){
 #if 1
     // Note: calling erase on a vector will invalidate any iterators beyond the deletion point
-    std::vector<instrumentedPhase>::iterator iter;
+    std::vector<instrumentedPhase*>::iterator iter;
     for(iter = phases.begin(); iter != phases.end(); iter++) {
-      if(! iter->hasValidControlPointValues()  || iter->times.size()==0){
+      if(! (*iter)->hasValidControlPointValues()  || (*iter)->times.size()==0){
        // CkPrintf("Filtered out a phase with incomplete control point values\n");
        phases.erase(iter);
        return true;
@@ -373,7 +373,7 @@ public:
     
     if(phases.size() > 0){
       
-      std::map<std::string,int> &ps = phases[0].controlPoints; 
+      std::map<std::string,int> &ps = phases[0]->controlPoints; 
       std::map<std::string,int>::iterator cpiter;
 
       // SCHEMA:
@@ -389,16 +389,16 @@ public:
       s << "# DATA:\n";
       s << "# first field is memory usage (MB). Then there are the " << ps.size()  << " control points values, followed by one or more timings" << "\n";
       s << "# number of control point sets: " << phases.size() << "\n";
-      std::vector<instrumentedPhase>::iterator runiter;
+      std::vector<instrumentedPhase*>::iterator runiter;
       for(runiter=phases.begin();runiter!=phases.end();runiter++){
        
        // Print the memory usage
-        s << runiter->memoryUsageMB << "    "; 
+       s << (*runiter)->memoryUsageMB << "    "; 
 
-        s << runiter->idleTime.min << " " << runiter->idleTime.avg << " " << runiter->idleTime.max << "   ";
+       s << (*runiter)->idleTime.min << " " << (*runiter)->idleTime.avg << " " << (*runiter)->idleTime.max << "   ";
 
        // Print the control point values
-       for(cpiter = runiter->controlPoints.begin(); cpiter != runiter->controlPoints.end(); cpiter++){ 
+       for(cpiter = (*runiter)->controlPoints.begin(); cpiter != (*runiter)->controlPoints.end(); cpiter++){ 
          s << cpiter->second << " "; 
        }
 
@@ -406,7 +406,7 @@ public:
 
        // Print the times
        std::vector<double>::iterator titer;
-       for(titer = runiter->times.begin(); titer != runiter->times.end(); titer++){
+       for(titer = (*runiter)->times.begin(); titer != (*runiter)->times.end(); titer++){
          s << *titer << " ";
        }
 
@@ -424,23 +424,24 @@ public:
   /// Verify that all our phases of data have the same sets of control point names
   void verify(){
     if(phases.size() > 1){
-      instrumentedPhase firstpoint = phases[0];
-      std::vector<instrumentedPhase>::iterator iter;
+      instrumentedPhase *firstpoint = phases[0];
+      std::vector<instrumentedPhase*>::iterator iter;
       for(iter = phases.begin();iter!=phases.end();iter++){
-       CkAssert( firstpoint.hasSameKeysAs(*iter));
+       CkAssert( firstpoint->hasSameKeysAs(*(*iter)));
       }  
     } 
   }
 
 
   // Find the fastest time from previous runs
-  instrumentedPhase findBest(){
+  instrumentedPhase* findBest(){
     CkAssert(phases.size()>1);
 
     double total_time = 0.0; // total for all times
     int total_count = 0;
 
-    instrumentedPhase best_phase;
+    instrumentedPhase * best_phase;
+
 #if OLDMAXDOUBLE
     double best_phase_avgtime = std::numeric_limits<double>::max();
 #else
@@ -449,9 +450,9 @@ public:
 
     int valid_phase_count = 0;
 
-    std::vector<instrumentedPhase>::iterator iter;
+    std::vector<instrumentedPhase*>::iterator iter;
     for(iter = phases.begin();iter!=phases.end();iter++){
-      if(iter->hasValidControlPointValues()){
+      if((*iter)->hasValidControlPointValues()){
        valid_phase_count++;
 
        double total_for_phase = 0.0;
@@ -459,7 +460,7 @@ public:
 
        // iterate over all times for this control point configuration
        std::vector<double>::iterator titer;
-       for(titer = iter->times.begin(); titer != iter->times.end(); titer++){
+       for(titer = (*iter)->times.begin(); titer != (*iter)->times.end(); titer++){
          total_count++;
          total_time += *titer;
          total_for_phase += *titer;
@@ -488,9 +489,9 @@ public:
     // Compute standard deviation
     double sumx=0.0;
     for(iter = phases.begin();iter!=phases.end();iter++){
-      if(iter->hasValidControlPointValues()){
+      if((*iter)->hasValidControlPointValues()){
        std::vector<double>::iterator titer;
-       for(titer = iter->times.begin(); titer != iter->times.end(); titer++){
+       for(titer = (*iter)->times.begin(); titer != (*iter)->times.end(); titer++){
          sumx += (avg - *titer)*(avg - *titer);
        } 
       }