complexity.java

发布/订阅系统路由重配算法,可应用于ad hoc环境

package sim;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.LineNumberReader;
import java.io.PrintWriter;
import java.util.Properties;

import com.Message;

import broker.Broker;
import broker.Destination;





public class Complexity extends Simulation{
	double costsBefore = 0.0;
	double costsAfter = 0.0;
	double costsHeuristic = 0.0;
	double costsReconfiguration = 0.0;
	int measurement = 1;
	
	double communicationHeuristic = 0.0;
	double processingHeuristic = 0.0;
	double heuristicCosts = 0.0;
		
	double communicationReconfiguration = 0.0;
	double processingReconfiguration = 0.0;
	double reconfigurationCosts = 0.0;

	
	
	public Complexity(Properties properties){
		super(properties);
		//System.out.println("Complexity started.");
	}
	
	public void setup() {
		
		// create the overlay and broker network
		try{
			net = Network.loadOverlay(this);
		}catch(Exception e){
			System.out.println(e);
			e.printStackTrace();
			System.exit(-1);
		}
		net.scaleCommunicationCosts();
		net.assignProcessingCosts();
		net.scaleProcessingCosts();
		net.assignLoad();
		net.scaleLoad();
		net.createRandomTree();

		// create the applications
		application = Application.createApplication(this);
		application.assignTo(net);

		// schedule Measurement Events
		scheduleEventAt(1000, new MeasureStartEvent());
		scheduleEventAt(1750, new Event(){
			public void handle(){
				net.clearCaches();
			}
		});
		scheduleEventAt(2001, new MeasureStopEvent());
		scheduleEventAt(2002, new Event() {
			public void handle() {
				net.startHeuristic();
			}
		});
		scheduleEventAt(25000, new Event(){
			public void handle(){
				if(measureEvent == null) {
					costs = 0;
					processingCosts = 0;
					communicationCosts = 0;
					communicationHeuristic = 0;
					processingHeuristic = 0;
					heuristicCosts = 0;
					communicationReconfiguration = 0;
					processingReconfiguration = 0;
					reconfigurationCosts = 0;
					
					measureEvent = new MeasureEvent();
					scheduleEventIn(measureInterval, measureEvent);
				}
			}
		});
		scheduleEventAt(26001, new MeasureStopEvent());
		scheduleEventAt(26002, new StopEvent());
		
	}
	
	public void measure(){
		if(measurement==1){
			costsBefore = costs;
			measurement++;
		}else if(measurement==2){
			costsHeuristic = heuristicCosts;
			costsReconfiguration = reconfigurationCosts;
			costsAfter = costs;

			out.println("# [costs before]\t[costs after]\t[heuristic costs]\t[reconfiguration costs]");
			out.println(costsBefore+"\t"+costsAfter+"\t"+costsHeuristic+"\t"+costsReconfiguration);
		}
		heuristicCosts = 0;
		processingHeuristic = 0;
		communicationHeuristic = 0;
		costs = 0;
		processingCosts = 0;
		communicationCosts = 0;
		measureEvent=new MeasureEvent();
		scheduleEventIn(measureInterval,measureEvent);
	}
	
	public void collectStatisticsSending(Destination from, Destination to, Message message) {
		
		double c;
		
		if(from.isClient() || to.isClient()){
			return;
    	}
		
		c = net.getCommunicationCosts((Broker)from,(Broker)to);

		
		if(message.getType()==Message.HEURISTIC){
			heuristicCosts += c;
			communicationHeuristic += c;
		}else if(message.getType()==Message.RECONFIGURATION){
			reconfigurationCosts += c;
			communicationHeuristic += c;
		}
		
    	costs += c;
    	communicationCosts += c;
    }
	
	public void collectStatisticsProcessing(Broker broker, Message message) {
		double p;
		
		p = net.getProcessingCosts(broker);
		if(message.getType()==Message.HEURISTIC){
			heuristicCosts += p;
			processingHeuristic += p;
		} else if(message.getType()==Message.RECONFIGURATION){
			reconfigurationCosts +=p;
			processingReconfiguration +=p;
		}

		costs += p;
		processingCosts += p;
	}
	
	
	// STATIC PART
	static String networkDir = "top/";

	static String[] networks = {"top_100_a",
		                        "top_100_b",
		                        "top_100_c",
		                        "top_100_d",
		                        "top_100_e"};
	
	static long[] networkSeeds = { 2394177302872702300L,
		                           5491205459211568959L,
		                           6702859405044936401L,
		                          -7938216953269608096L,
		                           3900736743843357023L};
	
	static long[] applicationSeeds = {-6116623287133684022L,
		                               7023269272318161570L,
		                              -6446803547478866606L,
		                              -5911061522510162924L,
		                               5363981162406371824L};

	static long[] brokerSeeds = {-906974798751154824L,
		                         2277394977345846158L,
		                         7218781717204194475L,
		                          168881650990619758L,
		                         4568175092141916468L};


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		try{
			if(args[0].equalsIgnoreCase("MAKE_EXPERIMENT")){
				makeExperiment();
			}else if(args[0].equalsIgnoreCase("COLLECT_RESULTS")){
				collectResults();
			}

		}catch(Exception e){
			System.err.println(e);
			e.printStackTrace();
			System.exit(-1);
		}
	}
		
	private static void makeExperiment() throws Exception{
		File f;
		String expDir;
		String expFile;
		PrintWriter out;
		
		expDir = "exp/complexity/";
		f = new File(expDir);
		f.mkdirs();
		
		for(int net=0; net<networks.length; net++){
			
		
			for(int i=2; i<16; i++){
				
				expFile = expDir+networks[net]+"_"+i;
				out = new PrintWriter(new FileWriter(expFile+".exp"),true);

				out.println("# experiment: complexity "+i);
				out.println();
				out.println("# general:");
				out.println("simulation=sim.Complexity");
				out.println("outFile="+expFile+".rst");
				out.println("netFile="+networkDir+networks[net]);
				out.println("measureInterval=1000");
				out.println();
				out.println("# random seeds");
				out.println("networkSeed="+networkSeeds[net]);
				out.println("applicationSeed="+applicationSeeds[net]);
				out.println("brokerSeed="+brokerSeeds[net]);
				out.println();
				out.println("# network");
				out.println("minCommunicationCosts=0");
				out.println("maxCommunicationCosts=10");
				out.println("minProcessingCosts=0");
				out.println("maxProcessingCosts=10");
				out.println("minLoad=1");
				out.println("maxLoad=10");
				out.println("communicationDelayConstant=0");
				out.println("communicationDelayFactor=1");
				out.println("processingDelayConstant=0");
				out.println("processingDelayFactor=0.001");
				out.println();
				out.println("# application");
				out.println("numberOfJobs=50");
				out.println("numberOfSubscribers=9");
				out.println("publicationInterval=EXPONENTIAL");
				out.println("publicationConstant=0.2");
				out.println("reassignmentInterval=CONSTANT");
				out.println("reassignmentConstant=100000");
				out.println("locality=0.75");
				out.println("localityPower=2");
				out.println();
				out.println("# broker");
				out.println("heuristic=COSTS_AND_INTERESTS");
				out.println("cacheSize=8192");
				out.println("filterSize=100000");
				out.println("broadcastInterval=250");
				out.println("updateInterval=400");
				out.println("order=UNORDERED");
				out.println("environmentSize="+i);
				out.println("numberOfHashs=5");
				out.flush();
				out.close();
			}
		}
		
	}
	
	
	private static void collectResults() throws Exception{
		String expDir;
		String expFile;
		PrintWriter out;
		LineNumberReader in;
		String line;
		String[]  tokens;
		double b;
		double a;
		double h;
		double r;
		double percentImprovement;
		double pImp;
		double pHeu;
		double pRec;
		double percentHeuristic;
		double percentReconfiguration;
		
		expDir = "exp/complexity/";
		out = new PrintWriter(new FileWriter(expDir+"RESULTS"),true);
		out.println("# [environmentSize]\t[improvement]\t[heuristic costs%]\t[reconfiguration costs%]");
		for(int i=2; i<16; i++){
		
			percentImprovement = percentHeuristic = percentReconfiguration = 0;
			for(int net = 0; net < networks.length; net++){
				expFile = expDir+networks[net]+"_"+i+".rst";
				in = new LineNumberReader(new FileReader(expFile));
				b=a=h=r=0;
				while((line=in.readLine())!=null){
					if(line.startsWith("#") || line.equals("")){
						continue;
					}
					tokens = line.split("\t");
					b = Double.parseDouble(tokens[0]);
					a = Double.parseDouble(tokens[1]);
					h = Double.parseDouble(tokens[2]);
					r = Double.parseDouble(tokens[3]);
				}
				percentImprovement += (a*100.0d/b);
				percentHeuristic += (h*100.0d/a);
				percentReconfiguration += (r*100.0d/a);
				
				in.close();
			}
			pImp = percentImprovement/((double)networks.length);
			pHeu = percentHeuristic/((double)networks.length);
			pRec = percentReconfiguration/((double)networks.length);
			out.println(i+"\t"+(100d-pImp)+"\t"+pHeu+"\t"+pRec);
		}
		out.flush();
		out.close();
	}
}