def sim_weighted_random(n,latencies,traces,outfiles,weights,alphas): print "Simulating Weighted Random multi-path scheme... alphas:", alphas traces_file = natsorted(glob.glob(traces[0]+'/*.cell')) for instance_file in traces_file: instance = open(instance_file,'r') instance = instance.read().split('\n')[:-1] w_out = multipath.getWeights(n,alphas) w_in = multipath.getWeights(n,alphas) # Get n circuits latencies as a multipath virtual structure of the same client for this instance mplatencies = getCircuitLatencies(latencies, n) # it is a list of list of latencies for each of m circuits. length = m # for each instance I need to create a new randomly created weights vector routes_server = [] routes_client = [] last_client_route = np.random.choice(np.arange(0,n),p = w_out) last_server_route = np.random.choice(np.arange(0,n),p = w_in) routes = [] for i in xrange(0,len(instance)): packet = instance[i] packet = packet.replace(' ','\t') #For compatibility when data is space sperated not tab separated direction = multipath.getDirfromPacket(packet) if (direction == 1): routes_server.append(-1) # Just to know that for this packet the exit does not decide the r$ last_client_route = np.random.choice(np.arange(0,n),p = w_out) routes_client.append(last_client_route) if (direction == -1): routes_client.append(-1) # Just to know that for this packet the client does not decide the$ last_server_route = np.random.choice(np.arange(0,n),p = w_in) routes_server.append(last_server_route) routes = multipath.joingClientServerRoutes(routes_client,routes_server) ##### Routes Created, next to the multipath simulation new_instance = multipath.simulate(instance,mplatencies,routes) # Simulate the multipath effect for the give$ saveInFile2(instance_file,new_instance,routes,outfiles)
def sim_bwr_blocked(n,latencies,traces,outfiles,range_): print "Simulating BWR multi-path scheme blocking last selected route..." print traces traces_file = natsorted(glob.glob(traces[0]+'/*.cell')) ranlow = int(range_.split(',')[0]) ranhigh = int(range_.split(',')[1]) for instance_file in traces_file: w_out = multipath.getWeights(n) w_in = multipath.getWeights(n) instance = open(instance_file,'r') instance = instance.read().split('\n')[:-1] mplatencies = getCircuitLatencies(latencies, n) # it is a list of list of latencies for each of m circuits. length = m routes_client = [] routes_server = [] sent_incomming = 0 sent_outgoing = 0 last_client_route = np.random.choice(np.arange(0,n),p = w_out) last_server_route = np.random.choice(np.arange(0,n),p = w_in) for i in xrange(0,len(instance)): packet = instance[i] packet = packet.replace(' ','\t') #For compatibility when data is space sperated not tab separated direction = multipath.getDirfromPacket(packet) if (direction == 1): routes_server.append(-1) # Just to know that for this packet the exit does not decide the route sent_outgoing += 1 C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights routes_client.append(last_client_route) if (sent_outgoing % C == 0): #After C cells are sent, change the circuits while(1): client_route = np.random.choice(np.arange(0,n),p = w_out) if (client_route != last_client_route): last_client_route = client_route break # In this way, we block the possibility of choosing the same circuit previously chosen if (direction == -1): routes_client.append(-1) # Just to know that for this packet the client does not decide the route routes_server.append(last_server_route) sent_incomming += 1 C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights if (sent_incomming % C == 0): #After C cells are sent, change the circuits while(1): server_route = np.random.choice(np.arange(0,n),p = w_in) if (server_route != last_server_route): last_server_route = server_route break # In this way, we block the possibility of choosing the same circuit previously chosen routes = multipath.joingClientServerRoutes(routes_client,routes_server) ##### Routes Created, next to the multipath simulation new_instance = multipath.simulate(instance,mplatencies,routes) # Simulate the multipath effect for the given latencies and routes saveInFile2(instance_file,new_instance,routes,outfiles)
def sim_bwr_var_paths(n,nmin,latencies,traces,outfiles,range_, alphas): print "Simulating bwr with variable number of paths", nmin, n traces_file = natsorted(glob.glob(traces[0]+'/*.cell')) ranlow = int(range_.split(',')[0]) ranhigh = int(range_.split(',')[1]) for instance_file in traces_file: ## First lets choose the number of circuits randomly n_random = random.randint(nmin,n) alphas = np.ones(n_random) alphas = alphas.astype(str) alphas = ','.join(alphas) w_out = multipath.getWeights(n_random, alphas) w_in = multipath.getWeights(n_random, alphas) instance = open(instance_file,'r') instance = instance.read().split('\n')[:-1] mplatencies = getCircuitLatencies(latencies, n_random) routes_client = [] routes_server = [] sent_incomming = 0 sent_outgoing = 0 last_client_route = np.random.choice(np.arange(0,n_random),p = w_out) last_server_route = np.random.choice(np.arange(0,n_random),p = w_in) #C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights for i in xrange(0,len(instance)): packet = instance[i] packet = packet.replace(' ','\t') #For compatibility when data is space sperated not tab separated direction = multipath.getDirfromPacket(packet) if (direction == 1): routes_server.append(-1) # Just to know that for this packet the exit does not decide the r$ sent_outgoing += 1 C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights routes_client.append(last_client_route) if (sent_outgoing % C == 0): #After C cells are sent, change the circuits last_client_route = np.random.choice(np.arange(0,n_random),p = w_out) if (direction == -1): routes_client.append(-1) # Just to know that for this packet the client does not decide the$ routes_server.append(last_server_route) sent_incomming += 1 C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights if (sent_incomming % C == 0): #After C cells are sent, change the circuits last_server_route = np.random.choice(np.arange(0,n_random),p = w_in) routes = multipath.joingClientServerRoutes(routes_client,routes_server) #### Routes Created, next to the multipath simulation new_instance = multipath.simulate(instance,mplatencies,routes) # Simulate the multipath effect for the give$ saveInFile2(instance_file,new_instance,routes,outfiles)
def sim_bwr_var_paths_strict(n,nmin,latencies,traces,outfiles,range_): ## Take the dataset and do: m=2 to 20%, m=3 to 20%, m=4 to 20% and m=5 to 20% of the whole dataset. ## It means that e.g., BWR2-5 Strict has almost 20% of instances split into two parts, 20% into three and so on ## BWR 4-5 Strict schould have 50/50 % to m=4 and m=5. However, experimentally we obtained couple of dozens of samples divided into m=2, and m=3. print "Simulating bwr with variable number of paths strict to avoid less than nmin Cmax and Cmind should be reduced to 15-20" traces_file = natsorted(glob.glob(traces[0]+'/*.cell')) ranlow = int(range_.split(',')[0]) ranhigh = int(range_.split(',')[1]) number_of_traces = len(traces_file) #print number_of_traces, n, nmin chunks_dataset = 100 / (n - nmin + 1) n_sel = [] #print chunks_dataset for i in range(nmin,n+1): n_sel.extend([i] * chunks_dataset) #print n_sel, len(n_sel) #print n_sel kk = 0 for instance_file in traces_file: ## First lets choose the number of circuits randomly #print instance_file, "divided into", n_random = n_sel[kk%len(n_sel)] kk += 1 #print n_random, instance_file w_out = multipath.getWeights(n_random) w_in = multipath.getWeights(n_random) instance = open(instance_file,'r') instance = instance.read().split('\n')[:-1] mplatencies = getCircuitLatencies(latencies, n_random) routes_client = [] routes_server = [] sent_incomming = 0 sent_outgoing = 0 last_client_route = np.random.choice(np.arange(0,n_random),p = w_out) last_server_route = np.random.choice(np.arange(0,n_random),p = w_in) #C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights for i in xrange(0,len(instance)): packet = instance[i] packet = packet.replace(' ','\t') #For compatibility when data is space sperated not tab separated direction = multipath.getDirfromPacket(packet) if (direction == 1): routes_server.append(-1) # Just to know that for this packet the exit does not decide the r$ sent_outgoing += 1 C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights routes_client.append(last_client_route) if (sent_outgoing % C == 0): #After C cells are sent, change the circuits while(1): client_route = np.random.choice(np.arange(0,n_random),p = w_out) if (client_route != last_client_route): last_client_route = client_route break # In this way, we block the possibility of choosing the same circuit previously chosen if (direction == -1): routes_client.append(-1) # Just to know that for this packet the client does not decide the$ routes_server.append(last_server_route) sent_incomming += 1 C = random.randint(ranlow,ranhigh) #After how many cells the scheduler sets new weights if (sent_incomming % C == 0): #After C cells are sent, change the circuits while(1): server_route = np.random.choice(np.arange(0,n_random),p = w_in) if (server_route != last_server_route): last_server_route = server_route break # In this way, we block the possibility of choosing the same circuit previously chosen routes = multipath.joingClientServerRoutes(routes_client,routes_server) #### Routes Created, next to the multipath simulation new_instance = multipath.simulate(instance,mplatencies,routes) # Simulate the multipath effect for the give$ saveInFile2(instance_file,new_instance,routes,outfiles)