vs.cc

题描述的是一个旅行商要到几个城市去

      }
    }
    fclose (fp);

  } else {
    // process from rtts

    while (stamp < ROUNDS) {
      // pick random sample

      rawLatencySample = 0;
      bool myIdValidity = false;
      while (!myIdValidity) {
        myId = unifRand (0, nodeCount);
        myIdValidity = validNode[myId];
      }

      if (neighborCount > 0) {
        int neighborId = unifRand (0, neighborCount);
        yourId = neighbors[myId][neighborId];
      } else {
        yourId = myId;
        while (yourId == myId || !validNode[yourId] || rtts[myId][yourId] <= 0) {
          yourId = unifRand (0, nodeCount);
        }
      }
      assert (validNode[yourId]);
      rawLatencySample = rtts[myId][yourId];
      ASSERT (rawLatencySample > 0);

      node[myId].processSample (stamp, myId, yourId, rawLatencySample);
      perSecondOutput (stamp);

      if (debug) {
      if (myId == 1739) {
	printf ("r %d me %d you %d s %f\n",
		stamp, myId, yourId, rawLatencySample);
      }
      if (myId == 2) {
	printf ("r %d me %d you %d s %f\n",
		stamp, myId, yourId, rawLatencySample);
      }
      }
      stamp++;
    }

  }

  // make sure to ignore anybody who never did anything
  // validNode is only defined with latency matrix

  if (sysCoordFP != NULL || appCoordFP != NULL || nodeFP != NULL) {

    for (int i = 0; i < nodeCount; i++) {
      //if (validNode[i] && node[i].lastUpdateTo > 0) {
      if (node[i].lastUpdateTo > 0) {

        if (sysCoordFP != NULL) {
          fprintf (sysCoordFP, "%d ", i);
          node[i].printCoord (sysCoordFP);
          fprintf (sysCoordFP, "\n");
        }

        if (appCoordFP != NULL) {
          fprintf (appCoordFP, "%d ", i);
          node[i].printCoord (appCoordFP);
          fprintf (appCoordFP, "\n");
        }

        if (nodeFP != NULL) {
          fprintf (nodeFP, "%d ", i);
          node[i].printStat (nodeFP);
          fprintf (nodeFP, "\n");
        }
      }
    }
  }

  // currently only used for relative error,
  // but could be used for any pair-wise comparison
  if (reFP != NULL || sumreFP != NULL) {
    for (int myId = 0; myId < nodeCount; myId++) {
      if (node[myId].lastUpdateTo > 0) {
        vector<double> sys_errors;
        vector<double> app_errors;
        for (int yourId = 0; yourId < nodeCount; yourId++) {
          if (yourId != myId) {
            if (node[yourId].lastUpdateTo > 0) {    
              float median = 0;
              float sys_relativeErrorAB = 0;
              float app_relativeErrorAB = 0;

              float sys_distanceAB =
                node[myId].vec->getEuclideanDistance (node[yourId].vec);
              float app_distanceAB =
                node[myId].appVector->getEuclideanDistance (node[yourId].appVector);

              if (rtts != NULL) {
                median = rtts[myId][yourId];
                sys_relativeErrorAB = fabs(sys_distanceAB - median) / median;
                app_relativeErrorAB = fabs(app_distanceAB - median) / median;
              }

              if (median > 0) {
                if (reFP != NULL) {
                  //fprintf (reFP, "%d %d %f %f\n", myId, yourId, 
		  //sys_relativeErrorAB, app_relativeErrorAB);
                  fprintf (reFP, "%d %d re %f d %f l %f %d\n", myId, yourId, 
			   app_relativeErrorAB, app_distanceAB, median,
                           isNeighbor(myId, yourId));
                  


                }
                sys_errors.push_back (sys_relativeErrorAB);
                app_errors.push_back (app_relativeErrorAB);
              }    
            }
          }
        }

        if (sumreFP != NULL) {
          double sys_fifty = percentile (sys_errors, .5);
	  double sys_eighty = percentile (sys_errors, .8);
          double sys_ninetyfive = percentile (sys_errors, .95);
          double app_fifty = percentile (app_errors, .5);
	  double app_eighty = percentile (app_errors, .8);
          double app_ninetyfive = percentile (app_errors, .95);
          fprintf (sumreFP, "%d sys %f %f %f app %f %f %f\n", myId,
                   sys_fifty, sys_eighty, sys_ninetyfive,
                   app_fifty, app_eighty, app_ninetyfive);
        }

      }
    }
  }

  if (ralpFP != NULL) {

    for (int myId = 0; myId < nodeCount; myId++) {
      float ralpLoss = 0;
      float ralpSum = 0; 

      float rrlLoss = 0;
      float rrlSum = 0; 

      float narlLoss = 0;
      float narlSum = 0; 

      for (int nodeA = 0; nodeA < nodeCount; nodeA++) {
	for (int nodeB = nodeA+1; nodeB < nodeCount; nodeB++) {

	  if (myId != nodeA && myId != nodeB &&
	      rtts[myId][nodeA] > 0 && rtts[myId][nodeB] > 0 &&
	      node[myId].lastUpdateTo > 0 && node[nodeA].lastUpdateTo > 0 &&
	      node[nodeB].lastUpdateTo > 0) {

	    /*
	    float distanceA = 
	      node[myId].vec->getEuclideanDistance (node[nodeA].vec);
	    float distanceB = 
	      node[myId].vec->getEuclideanDistance (node[nodeB].vec);
	    */
	    float distanceA = 
	      node[myId].appVector->getEuclideanDistance (node[nodeA].appVector);
	    float distanceB = 
	      node[myId].appVector->getEuclideanDistance (node[nodeB].appVector);

	    float medianA = rtts[myId][nodeA];
	    float medianB = rtts[myId][nodeB];

	    float medianDifference = fabs(medianA-medianB);

	    if (debug) {
	      printf ("A %d B %d dA %f sA %f dB %f sB %f\n",
		      nodeA, nodeB,
		      distanceA, medianA,
		      distanceB, medianB);
	    }

	    rrlSum++;
	    if (medianA > medianB) {
	      if (distanceA < distanceB)
		rrlLoss++;
	    } else if (medianB > medianA) {
	      if (distanceB < distanceA)
		rrlLoss++;
	    }
                
	    narlSum += medianDifference;
	    if (medianA > medianB) {
	      if (distanceA < distanceB) 
		narlLoss += medianDifference;
	    } else if (medianB > medianA) {
	      if (distanceB < distanceA) 
		narlLoss += medianDifference;
	    }

	    if (medianA > medianB) {
	      if (distanceA < distanceB) {
		ralpLoss += medianDifference;
		ralpSum += medianA;
	      }
	    } else if (medianB > medianA) {
	      if (distanceB < distanceA) {
		ralpLoss += medianDifference;
		ralpSum += medianB;
	      }
	    }
	  }
	}
      }
      float rrlLossPct = rrlLoss/rrlSum;
      float narlLossPct = narlLoss/narlSum;
      float ralpLossPct = ralpLoss/ralpSum;
      fprintf (ralpFP, "%d %.3f %.3f %.3f\n", myId, 
	       rrlLossPct, narlLossPct, ralpLossPct);

    }
  }

    
  delete [] node;

  if (rtts != NULL) {
    for (int myId = 0; myId < nodeCount; myId++) {
      delete [] rtts[myId];
      delete [] distanceMatrixSys[myId];
      delete [] errorMatrixSys[myId];
      delete [] distanceMatrixApp[myId];
      delete [] errorMatrixApp[myId];
    }
    delete [] rtts;
    delete [] distanceMatrixSys;
    delete [] errorMatrixSys;
    delete [] distanceMatrixApp;
    delete [] errorMatrixApp;
  }

  return 0;
}

bool isNeighbor (int myId, int yourId) {
  for (int neighborId = 0; neighborId < neighborCount; neighborId++) {
    if (neighbors[myId][neighborId] == yourId) {
      return true;
    }
  }
  return false;
}

void computeDistanceMatrix () {
  int foundDistanceCount = 0;
  for (int myId = 0; myId < nodeCount; myId++) {
    if (node[myId].lastUpdateTo > 0) {
      for (int yourId = 0; yourId < nodeCount; yourId++) {
	if (yourId != myId) {
	  if (node[yourId].lastUpdateTo > 0) {    
	    float sys_distanceAB =
	      node[myId].vec->getEuclideanDistance 
	      (node[yourId].vec);
	    float app_distanceAB =
	      node[myId].appVector->getEuclideanDistance 
	      (node[yourId].appVector);
	    distanceMatrixSys[myId][yourId] = sys_distanceAB;
	    distanceMatrixApp[myId][yourId] = app_distanceAB;
	    foundDistanceCount++;
	  }
	}
      }
    }
  }
  //printf ("Found distance for %.3f nodes\n",
  //foundDistanceCount/(double)(nodeCount*nodeCount));
}
      
void computeErrorMatrix (vector<double> &errorListSys,
			 vector<double> &errorListApp) {
  int foundErrorCount = 0;
  if (rtts != NULL) {
    for (int myId = 0; myId < nodeCount; myId++) {
      if (node[myId].lastUpdateTo > 0) {
	for (int yourId = 0; yourId < nodeCount; yourId++) {
	  if (yourId != myId) {
	    if (node[yourId].lastUpdateTo > 0) {    
	      double median = rtts[myId][yourId];
	      if (median > 0 && distanceMatrixSys[myId][yourId] > 0) {
		double sys_relativeErrorAB =
		  fabs(distanceMatrixSys[myId][yourId] - median) / median;
		errorMatrixSys[myId][yourId] = sys_relativeErrorAB;
		foundErrorCount++;
		errorListSys.push_back(sys_relativeErrorAB);
              }
	      if (median > 0 && distanceMatrixApp[myId][yourId] > 0) {
		double app_relativeErrorAB =
		  fabs(distanceMatrixApp[myId][yourId] - median) / median;
		errorMatrixApp[myId][yourId] = app_relativeErrorAB;
		errorListApp.push_back(app_relativeErrorAB);
	      }
	    }
	  }
	}
      }
    }
  }
  //printf ("Found error for %.3f nodes\n",
  //foundErrorCount/(double)(nodeCount*nodeCount));
}



void perSecondOutput (int stamp) {
  if (stamp > lastFrameStamp + FRAME_INTERVAL) {
    lastFrameStamp += FRAME_INTERVAL;
    if (secFP) {

      double sys_matrix_re50 = 0;
      double sys_matrix_re95 = 0;
      double app_matrix_re50 = 0;
      double app_matrix_re95 = 0;

      if (rtts != NULL) {
	vector<double> errorListSys;
	vector<double> errorListApp;
	computeDistanceMatrix ();
	computeErrorMatrix (errorListSys,errorListApp);
	//printf ("error size %d\n", errorListSys.size());
	sys_matrix_re50 = percentile(errorListSys, .5);
	sys_matrix_re95 = percentile(errorListSys, .95);
	app_matrix_re50 = percentile(errorListApp, .5);
	app_matrix_re95 = percentile(errorListApp, .95);
      }

      double sysRawRE_50 = percentile (sec_sysRawRE_list, .5);
      //double sysRawRE_80 = percentile (sec_sysRawRE_list, .8);
      double sysRawRE_95 = percentile (sec_sysRawRE_list, .95);

      double appRawRE_50 = percentile (sec_appRawRE_list, .5);
      //double appRawRE_80 = percentile (sec_appRawRE_list, .8);
      double appRawRE_95 = percentile (sec_appRawRE_list, .95);

      fprintf (secFP, "%d num %d sm50 %.3f sm95 %.3f am50 %.3f am95 %.3f s50 %.3f s95 %.3f sDD %.3f a50 %.3f a95 %.3f aDD %.3f\n",
	       lastFrameStamp/FRAME_INTERVAL, sec_appRawRE_list.size(),
	       sys_matrix_re50, sys_matrix_re95,	       
	       app_matrix_re50, app_matrix_re95,	       
	       sysRawRE_50, sysRawRE_95, sec_sysDD_sum, 
	       appRawRE_50, appRawRE_95, sec_appDD_sum);
      if (flushSecFP)
	fflush (secFP);
      sec_sysRawRE_list.clear ();
      sec_appRawRE_list.clear ();
      sec_sysDD_sum = 0;
      sec_appDD_sum = 0;
    }

    if (strchr(outputFormat,'g') != NULL) {
      FILE *gnuplotFP = new FILE;
      openOutputFile (gnuplotFP, outputPrefix, ".gp", lastFrameStamp/FRAME_INTERVAL);

      for (int i = 0; i < nodeCount; i++) {
	if (node[i].lastUpdateTo > 0) {
	  fprintf (gnuplotFP, "%d ", i);
	  node[i].printCoord (gnuplotFP);
	  node[i].printAppCoord (gnuplotFP);
	  fprintf (gnuplotFP, "\n");
	}
      }
      closeOutputFile (gnuplotFP);

    }
  }
}