Skip to content

GitLab

Commit d65e7fe3 authored by Nils Richerzhagen's avatar Nils Richerzhagen
Browse files

Deleted FluctuatingPeerCountChurnModel

parent d9b11eb6
Hide whitespace changes
Inline Side-by-side
src/de/tud/kom/p2psim/impl/churn/FluctuatingPeerCountChurnModel.java deleted 100644 → 0
View file @ d9b11eb6
/*
* Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
*
* This file is part of PeerfactSim.KOM.
*
* PeerfactSim.KOM is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* PeerfactSim.KOM is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with PeerfactSim.KOM. If not, see <http://www.gnu.org/licenses/>.
*
*/
package de.tud.kom.p2psim.impl.churn;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Random;
import de.tud.kom.p2psim.api.churn.ChurnModel;
import de.tud.kom.p2psim.api.common.SimHost;
import de.tud.kom.p2psim.api.network.SimNetInterface;
import de.tud.kom.p2psim.impl.scenario.DefaultConfigurator;
import de.tud.kom.p2psim.impl.simengine.Simulator;
import de.tudarmstadt.maki.simonstrator.api.Randoms;
import de.tudarmstadt.maki.simonstrator.api.Time;
import de.tudarmstadt.maki.simonstrator.api.util.XMLConfigurableConstructor;
/**
* random arrival/leaving rate during simulation for a prefixed interval
*
* Intervals for rates fix, peaks fix, darüber geben sich arrical/leaving rates.
*
* Session length fixund nur arrival/leaving rate in lower und upper bound
* randoms
*
*
* Bursts:
*
* Burst joining duration 10 minutes.
*
* Min session length 10 minutes.
*
* @author Nils Richerzhagen
* @version 1.0, Feb 18, 2015
*/
public class FluctuatingPeerCountChurnModel implements ChurnModel {
private final String filename;
private final String commentsDelimiter = "#";
private final String SEP = ",";
private final long _burstJoinInterval = 10 * Time.MINUTE;
private final long _minBurstLength = 10 * Time.MINUTE;
private LinkedList<ChurnInfo> churnInfos = new LinkedList<ChurnInfo>();
/**
* Maximum number of online clients for non-fluctuation phase. Defined
* during configuration.
*/
private final int defaultPeersOnline;
/**
* Inter-arrival time as specified during configuration
*/
private final long initialInterArrivalTime;
private List<SimHost> hosts;
private final Random random = Randoms
.getRandom(FluctuatingPeerCountChurnModel.class);
private long lastJoin = -1;
// private Map<Long, ClientSessionInfo> clientSessionInfos = new LinkedHashMap<Long, ClientSessionInfo>();
private Map<SimHost, LinkedList<ClientChurnInfo>> clientChurnInfos;
// private PriorityQueue<ClientSessionInfo> clientsSortedByOfflineTime;
@XMLConfigurableConstructor({ "file", "defaultPeersOnline",
"interArrivalTime" })
public FluctuatingPeerCountChurnModel(String file, int defaultPeersOnline,
long interArrivalTime) {
this.filename = file;
this.defaultPeersOnline = defaultPeersOnline;
this.initialInterArrivalTime = interArrivalTime;
}
@Override
public long getNextUptime(SimHost host) {
long currentTime = Time.getCurrentTime();
LinkedList<ClientChurnInfo> churnInfos = clientChurnInfos.get(host);
return churnInfos.getFirst().joiningAt - currentTime;
// ChurnInfo currentChurnInfo = null;
// if (!churnInfos.isEmpty()) {
// currentChurnInfo = churnInfos.getFirst();
// /*
// * ChurnInfo is old. Remove old one and overwrite currentChurnInfo
// */
// if (currentChurnInfo.getEndTime() < currentTime) {
// churnInfos.removeFirst();
// currentChurnInfo = churnInfos.getFirst();
// }
// }
//
// /*
// * Join all clients until default (min) number of clients is achieved.
// */
// if (clientsSortedByOfflineTime.size() < defaultPeersOnline) {
// /*
// * Initially, join peers until the peer threshold is reached.
// */
// if (lastJoin < 0) {
// lastJoin = currentTime;
// }
// long currentJoin = lastJoin + initialInterArrivalTime;
// ClientSessionInfo info = new ClientSessionInfo(currentJoin);
// clientsSortedByOfflineTime.add(info);
// clientSessionInfos.put(host.getHostId(), info);
//
// lastJoin = currentJoin;
// return info.joiningAt - currentTime;
// }
//
//
// if (currentChurnInfo != null
// && currentChurnInfo.getStartTime() <= currentTime
// && (currentChurnInfo.getStartTime()
// + currentChurnInfo.getIntervalLength()) > currentTime) {
// /*
// * Is in next churn info: churnStart < currentTime < churnEnd
// *
// * Join or leave peers in a burst according to current churnInfo.
// *
// * Info: the peak is reached with the churnInfo - numberOfClients
// */
//
// long churnCrowdInterArrivalTime = currentChurnInfo
// .getIntervalLength()
// / (currentChurnInfo.getNumberOfClients()
// - defaultPeersOnline);
// long currentJoin = lastJoin + churnCrowdInterArrivalTime;
// ClientSessionInfo info = new ClientSessionInfo(currentJoin);
// clientSessionInfos.put(host.getHostId(), info);
//
// lastJoin = currentJoin;
// return info.joiningAt - currentTime;
//
// } else if (clientsSortedByOfflineTime.size() < defaultPeersOnline) {
// /*
// * Initially, join peers until the peer threshold is reached.
// */
// if (lastJoin < 0) {
// lastJoin = currentTime;
// }
// long currentJoin = lastJoin + initialInterArrivalTime;
// ClientSessionInfo info = new ClientSessionInfo(currentJoin);
// clientsSortedByOfflineTime.add(info);
// clientSessionInfos.put(host.getHostId(), info);
//
// lastJoin = currentJoin;
// return info.joiningAt - currentTime;
// } else {
// /*
// * After reaching the peer threshold, only peers that went offline
// * are replaced to keep the threshold.
// */
// ClientSessionInfo nextToGoOffline = clientsSortedByOfflineTime
// .poll();
//
// if (nextToGoOffline == null) {
// throw new AssertionError();
// } else {
// // Use the next time a peer goes offline as joining time.
// long currentJoin = nextToGoOffline.leavingAt;
// ClientSessionInfo info = new ClientSessionInfo(currentJoin);
// clientsSortedByOfflineTime.add(info);
// clientSessionInfos.put(host.getHostId(), info);
//
// lastJoin = currentJoin;
// return info.joiningAt - currentTime;
// }
// }
}
@Override
public long getNextDowntime(SimHost host) {
LinkedList<ClientChurnInfo> churnInfos = clientChurnInfos.get(host);
// (churnInfos.removeFirst());
// return info.sessionLength;
return 0;
}
@Override
public void prepare(List<SimHost> churnHosts) {
hosts = new LinkedList<SimHost>(churnHosts);
for (SimHost host : churnHosts) {
for (SimNetInterface netI : host.getNetworkComponent()
.getSimNetworkInterfaces()) {
if (netI.isOnline()) {
netI.goOffline();
}
}
}
// clientsSortedByOfflineTime = new PriorityQueue<FluctuatingPeerCountChurnModel.ClientSessionInfo>(
// (int) Math.ceil(hosts.size() / 10.0), COMP_OFFLINE_TIME);
parseTrace(filename);
computeChurnPerNode();
}
// /**
// * Comparator used to sort client infos by offline time
// */
// private static final Comparator<ClientSessionInfo> COMP_OFFLINE_TIME = new Comparator<FluctuatingPeerCountChurnModel.ClientSessionInfo>() {
// @Override
// public int compare(ClientSessionInfo o1, ClientSessionInfo o2) {
// return ((Long) o1.leavingAt).compareTo(o2.leavingAt);
// }
// };
public long getSessionLength() {
// FIXME Hosts s
return 3 * Time.HOUR;
}
public int getDefaultPeersOnline() {
return defaultPeersOnline;
}
private void computeChurnPerNode(){
/**
* Compute a list (onlineStart, intervalLength) per host.
*/
clientChurnInfos = new LinkedHashMap<SimHost, LinkedList<ClientChurnInfo>>();
int count = 0;
for (SimHost host : hosts) {
count ++;
LinkedList<ClientChurnInfo> clientChurnInfos = new LinkedList<ClientChurnInfo>();
/*
* As long as the defaultNumberOfPeers is not achieved just fill list with one item per Host.
*/
if(count <= defaultPeersOnline){
if (lastJoin < 0) {
lastJoin = 0;
}
long currentJoin = lastJoin + initialInterArrivalTime;
lastJoin = currentJoin;
// FIXME Session length for nodes that stay online?
clientChurnInfos.add(new ClientChurnInfo(currentJoin, Simulator.getEndTime()));
}
/*
* Nodes that may go offline multiple times. Defined by churnInfos via csv file.
*/
else if(count > defaultPeersOnline){
for (ChurnInfo churnInfo : churnInfos) {
long currentStartTime = churnInfo.getStartTime();
long currentBurstLength = churnInfo.getBurstLength();
// when burst starts + x-ter Node times inter arrival rate
long currentJoin = currentStartTime + (count - defaultPeersOnline) * churnInfo.getInterArrivalRate();
assert currentJoin >= currentStartTime;
if(count <= churnInfo.getNumberOfClients()){
clientChurnInfos.add(new ClientChurnInfo(currentJoin, currentBurstLength));
}
}
}
// clientChurnInfos.put(host, clientChurnInfos);
System.out.println(host.getId().value() + " churnInfoAdded");
}
}
private void parseTrace(String filename) {
System.out.println("==============================");
System.out.println("Reading trace from " + filename);
/*
* This parser works for the following csv file structure.
*
* startTime, intervalLength, numberOfClients
*
*/
BufferedReader csv = null;
boolean entrySuccessfullyRead = false;
try {
csv = new BufferedReader(new FileReader(filename));
long previousEndTime = 0;
while (csv.ready()) {
String line = csv.readLine();
if (line.length() == 0 || line.startsWith(commentsDelimiter))
continue;
if (line.indexOf(SEP) > -1) {
String[] parts = line.split(SEP);
if (parts.length == 3) {
try {
long startTime = DefaultConfigurator.parseNumber(
parts[0].replaceAll("\\s+", ""),
Long.class);
long burstLength = DefaultConfigurator
.parseNumber(
parts[1].replaceAll("\\s+", ""),
Long.class);
int numberOfClients = DefaultConfigurator
.parseNumber(
parts[2].replaceAll("\\s+", ""),
Integer.class);
// Insanity Checks
assert startTime >= previousEndTime : "Start time for next fluctuation must be greater than previous end time.";
assert burstLength < _minBurstLength : "The minimal length of the burst must be at least 10m.";
previousEndTime = startTime + burstLength;
churnInfos.add(new ChurnInfo(startTime,
burstLength, numberOfClients));
entrySuccessfullyRead = true;
} catch (NumberFormatException e) {
// Ignore leading comments
if (entrySuccessfullyRead) {
// System.err.println("CSV ParseError " +
// line);
}
}
} else {
throw new AssertionError("To many/few columns in CSV.");
}
}
}
} catch (Exception e) {
System.err.println("Could not open " + filename);
throw new RuntimeException("Could not open " + filename);
} finally {
if (csv != null) {
try {
csv.close();
} catch (IOException e) {
//
}
}
}
}
// /**
// * Client session information
// */
// private class ClientSessionInfo {
//
// public final long joiningAt;
//
// public final long leavingAt;
//
// public final long sessionLength;
//
// public ClientSessionInfo(long joiningAt) {
// this.sessionLength = getSessionLength();
// this.joiningAt = joiningAt;
// this.leavingAt = joiningAt + sessionLength;
// }
//
// }
/**
*
*/
private class ClientChurnInfo {
public final long joiningAt;
public final long leavingAt;
public ClientChurnInfo(long joiningAt, long sessionLength) {
this.joiningAt = joiningAt;
this.leavingAt = joiningAt + sessionLength;
}
}
/**
* Churn Info for the fluctuation intervals.
*
* @author Nils Richerzhagen
*/
private class ChurnInfo {
/**
* The time the burst starts.
*/
private long startTime;
/**
* The time the nodes stay online.
*/
private long burstLength;
/**
* The max number of nodes that join during that burst.
*/
private int numberOfClients;
public ChurnInfo(long startTime, long burstLength,
int numberOfClients) {
this.startTime = startTime;
this.burstLength = burstLength;
this.numberOfClients = numberOfClients;
}
public long getStartTime() {
return startTime;
}
public long getBurstLength() {
return burstLength;
}
public int getNumberOfClients() {
return numberOfClients;
}
//
// public long getEndTime() {
// return startTime + burstLength;
// }
/**
* Computed for the burst join window of 10 minutes.
*
* @return interArrivalRate
*/
public long getInterArrivalRate() {
return _burstJoinInterval / (numberOfClients - getDefaultPeersOnline());
}
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment