code
TRANSCRIPT
public class NextCycle extends FullNextCycle {
// ============== fields ===============================================
/**
* Gives the list of protocols (whitespace separated) that need to be
* iterated over.
* @config
*/
private static final String PAR_PROTS = "protocol";
private final int[] pids;
// =============== initialization ======================================
/**
* reads configuration parameters and the {@link Scheduler}s.
*/
public NextCycle(String prefix) {
super(prefix);
String prots = Configuration.getString(prefix+"."+PAR_PROTS);
String[] protnames = prots.split("\\s");
pids = new int[protnames.length];
for(int i=0; i<protnames.length; ++i)
{
pids[i] = Configuration.lookupPid(protnames[i]);
}
}
// =============== methods =============================================
/**
* Execute the configured protocols on all nodes.
* It works exactly as {@link FullNextCycle#execute}, only just the configured
* protocols are iterated over.
*/
public boolean execute() {
final int cycle=CDState.getCycle();
if( shuffle ) rperm.reset( Network.size() );
for(int j=0; j<Network.size(); ++j)
{
Node node = null;
if( getpair_rand )
node = Network.get(CDState.r.nextInt(Network.size()));
else if( shuffle )
node = Network.get(rperm.next());
else
node = Network.get(j);
if( !node.isUp() ) continue;
CDState.setNode(node);
CDState.setCycleT(j);
for(int pid: pids)
{
// Check if the protocol should be executed, given the
// associated scheduler.
if (!protSchedules[pid].active(cycle))
continue;
CDState.setPid(pid);
Protocol protocol = node.getProtocol(pid);
if( protocol instanceof CDProtocol )
{
((CDProtocol)protocol).nextCycle(node, pid);
if( !node.isUp() ) break;
}
}
}
return false;
}
}
public ConfigProperties( String[] pars, String resource ) {
try
{
if( resource != null )
{
loadSystemResource(resource);
System.err.println("ConfigProperties: System resource "
+resource+" loaded.");
}
}
catch( Exception e )
{
System.err.println("ConfigProperties: " + e );
}
if( pars == null || pars.length == 0 ) return;
for (int i=0; i < pars.length; i++)
{
try
{
load( pars[i] );
System.err.println(
"ConfigProperties: File "+pars[i]+" loaded.");
pars[i] = "";
}
catch( IOException e )
{
try
{
loadPropertyString( pars[i] );
System.err.println("ConfigProperties: Property '" +
pars[i] + "' set.");
}
catch( Exception e2 )
{
System.err.println("ConfigProperties: " + e2 );
}
}
catch( Exception e )
{
System.err.println("ConfigProperties: " + e );
}
}
}
/**
* Constructs a ConfigProperty object by loading a file by calling
* {@link #load}.
* @param fileName The name of the configuration file.
*/
public ConfigProperties( String fileName ) throws IOException {
load( fileName );
}
/**
* Calls super constructor.
*/
public ConfigProperties( Properties props ) {
super( props );
}
/**
* Calls {@link #ConfigProperties(String[],String)} with resource set to null.
*/
public ConfigProperties( String[] pars ) {
this( pars, null );
}
// =========== Public methods ========================================
/**
* Loads given file. Calls <code>Properties.load</code> with a file
* input stream to the given file.
*/
public void load( String fileName ) throws IOException {
FileInputStream fis = new FileInputStream( fileName );
load( fis );
fis.close();
}
/**
* Adds the properties from the given property file. Searches in the class path
* for the file with the given name.
*/
public void loadSystemResource( String n ) throws IOException {
ClassLoader cl = getClass().getClassLoader();
load( cl.getResourceAsStream( n ) );
}
/**
* Appends a property defined in the given string.
* The string is considered as a property file line.
* It is converted to a byte array according to the
* default character encoding and then loaded by the
* <code>Properties.load</code> method. This means that the ISO-8859-1
* (or compatible) encoding is assumed.
*/
public void loadPropertyString( String prop ) throws IOException {
StringBuffer sb = new StringBuffer();
sb.append( prop ).append( "\n" );
load( new ByteArrayInputStream(sb.toString().getBytes()) );
}
}
public interface Node extends Fallible, Cloneable
{
/**
* Prefix of the parameters that defines protocols.
* @config
*/
public static final String PAR_PROT = "protocol";
/**
* Returns the <code>i</code>-th protocol in this node. If <code>i</code>
* is not a valid protocol id
* (negative or larger than or equal to the number of protocols), then it throws
* IndexOutOfBoundsException.
*/
public Protocol getProtocol(int i);
/**
* Returns the number of protocols included in this node.
*/
public int protocolSize();
/**
* Sets the index of this node in the internal representation of the node list.
* Applications should not use this method. It is defined as public simply
* because it is not possible to define it otherwise.
* Using this method will result in
* undefined behavior. It is provided for the core system.
*/
public void setIndex(int index);
/**
* Returns the index of this node. It is such that
* <code>Network.get(n.getIndex())</code> returns n. This index can
* change during a simulation, it is not a fixed id. If you need that, use
* {@link #getID}.
* @see Network#get
*/
public int getIndex();
/**
* Returns the unique ID of the node. It is guaranteed that the ID is unique
* during the entire simulation, that is, there will be no different Node
* objects with the same ID in the system during one invocation of the JVM.
* Preferably nodes
* should implement <code>hashCode()</code> based on this ID.
*/
public long getID();
/**
* Clones the node. It is defined as part of the interface
* to change the access right to public and to get rid of the
* <code>throws</code> clause.
*/
public Object clone();
}
public DynamicNetwork(String prefix)
{
add = Configuration.getDouble(prefix + "." + PAR_ADD);
substitute = Configuration.contains(prefix + "." + PAR_SUBST);
Object[] tmp = Configuration.getInstanceArray(prefix + "." + PAR_INIT);
inits = new NodeInitializer[tmp.length];
for (int i = 0; i < tmp.length; ++i) {
//System.out.println("Inits " + tmp[i]);
inits[i] = (NodeInitializer) tmp[i];
}
maxsize=Configuration.getInt(prefix+"."+PAR_MAX,Integer.MAX_VALUE);
minsize = Configuration.getInt(prefix + "." + PAR_MIN, 0);
}
public SearchDataInitializer(String prefix) { keywords = Configuration.getLong(prefix + "." + PAR_KEYWORDS); protocolID = Configuration.getPid(prefix + "." + PAR_PROT); query_nodes = Configuration.getInt(prefix + "." + PAR_QUERY_NODES, Network.size()); max_queries = Configuration.getInt(prefix + "." + PAR_MAX_QUERIES, 0);
query_interval = Configuration.getInt( prefix + "." + PAR_QUERY_INTERVAL, 10); maxCycles = Configuration.getInt(prefix + "." + PAR_MAX_CYLES, 100);
} // Methods // --------------------------------------------------------------------- /** * Fills a {@link SearchProtocol} with the keywords representing the
* documents it holds. It is called for each node. * @param proto * the protocol instance to initialize */ private void initializeData(SearchProtocol proto) { // create the stored keywords // number of keywords held by the node (poisson) int storageSize = CommonState.r.nextPoisson(1 + keywords / 1000);
/* generates a distribution of keyIDs along with their frequencies */
Map<Integer, Integer> keyStorage = makeKeyMap(storageSize); proto.addKeyStorage(keyStorage);
}
/** * Fills a {@link SearchProtocol} with the queries it will initiate. * @param proto * the protocol to initialize */
private void initializeQueries(SearchProtocol proto) {
int cycle = -1;
int nqueries = 0; while (true) { cycle += (1 + CommonState.r.nextPoisson(query_interval));
System.err.println("cycle: " + cycle); if (cycle > (maxCycles - proto.ttl)) {
System.err .println("Warn: the TTL probably too large for maxCycles...");
break; }
if (max_queries > 0 && ++nqueries > max_queries) { // System.err.println("Warn: ");
break; }
// number of keywords in the query (exponential) int querySize = (int) Math.ceil(nextExponential(1.5));
System.err.println("query size: " + querySize); int[] query = makeKeyArray(querySize);
proto.addQueryData(cycle, query); }
} /**
* Generate a set of (keyID, frequency) pairs of the specified size. * @param size * The size of the desired set * @return
*/ private Map<Integer, Integer> makeKeyMap(int size) { HashMap<Integer, Integer> keys = new HashMap<Integer, Integer>();
while (keys.size() < size) { int key = (int) Math.ceil(nextPower(keywords / (double) 100, 1.0));
if (key > keywords) /* * keyIDs grater than the max key number are * trashed */
continue;
Integer ikey = Integer.valueOf(key); Integer oldValue = (Integer) keys.get(ikey);
int newval = (oldValue == null ? 1 : oldValue.intValue() + 1); keys.put(ikey, Integer.valueOf(newval));
} return keys; }
private int[] makeKeyArray(int size) {
HashSet<Integer> keys = new HashSet<Integer>(); while (keys.size() < size) { int key = (int) Math.ceil(nextPower(keywords / (double) 100, 1.0));
if (key > keywords)
continue;
keys.add(Integer.valueOf(key)); }
int[] result = new int[size]; Object[] ikeys = keys.toArray();
for (int i = 0; i < size; ++i) { result[i] = ((Integer) ikeys[i]).intValue();
} return result; }
public boolean execute() {
for (int i = 0; i < Network.size(); ++i) { SearchProtocol proto = ((SearchProtocol) Network.get(i) .getProtocol(protocolID));
initializeData(proto); if (i < query_nodes)
initializeQueries(proto); } return false;
}
/** * Extracts random values according to a power distribution. * * @param base * base * @param a * scaling exponent * @return
*/
private static double nextPower(double base, double a) { return base / Math.pow(CommonState.r.nextDouble(), a) - base;
}
public double nextExponential(double b) {
return -1 * b * Math.log(CommonState.r.nextDouble());
}
} public SearchObserver(String name) {
this.name = name;
// Other parameters from config file:
pid = Configuration.getPid(name + "." + PAR_PROT);
verbosity = Configuration.getInt(name + "." + PAR_VERBOSITY, 0);
cleanCache = Configuration.contains(name + "." + PAR_CLEAN_CACHE);
}
public void printItemsStatistics(HashMap messageStats) {
Iterator iterStats = messageStats.values().iterator();
while (iterStats.hasNext()) {
SearchStats stats = (SearchStats) iterStats.next();
if (verbosity == 0 && stats.getAge() < stats.getTtl())
continue;
System.out.println(name + ": " + CommonState.getIntTime() + " "
+ stats.toString());
// System.out.println(stats); } }
}
public SearchStats(int seq, int age, int ttl) { this.nbSeen = 0;
this.nbHits = 0;
this.nbMessages = 0;
// this.nbExtraProbes = 0;
this.seq = seq;
this.age = age;
this.ttl = ttl;
} // Methods public void update(int msgs, int hits) {
++nbSeen; nbHits += hits;
nbMessages += msgs; }
public String toString() { return ("" + seq + "\t" + age + "\t" + nbSeen + "\t" + nbHits + "\t" + nbMessages);
} public int getAge() {
return age; }
public void setAge(int age) {
this.age = age; }
public int getTtl() { return ttl;
} public void setTtl(int ttl) {
this.ttl = ttl; }
public int getNbSeen() { return nbSeen;
}}
public SMessage(Node originator, int type, int hops, int[] payload) { this.originator = originator;
this.type = type;
this.hops = hops; this.payload = payload;
this.seq = ++seq_generator; this.start = CDState.getCycle();
} public Object clone() throws CloneNotSupportedException {
SMessage m = (SMessage) super.clone(); return m;
} // Methods public int hashCode() {
return seq; }
public boolean equals(Object obj) { return (obj instanceof SMessage) && (((SMessage) obj).seq == this.seq);
} public String toString() {
return "SMessage[" + seq + "] hops=" + hops; }
} /** Creates a new instance of RWProtocol */ public RWProtocol(String prefix) { super(prefix);
walkers = Configuration.getInt(prefix + "." + PAR_WALKERS, 1); }
// "Passive" behaviour implementation: process key similarity and notifies // any match and forwards messages.
public void process(SMessage mes) {
// checks for hits and notifies originator if any:
boolean match = this.match(mes.payload);
if (match) this.notifyOriginator(mes);
// forwards the message to a random neighbor:
Node neighbor = this.getRNDNeighbor();
this.forward(neighbor, mes);
}
// "active" behaviour implementation: makes query
public void nextCycle(peersim.core.Node node, int protocolID) {
super.nextCycle(node, protocolID);
// this will handle incoming messages
int[] data = this.pickQueryData(); // if we have to produce a query...
if (data != null) {
System.err.println("DATA");
SMessage m = new SMessage(node, SMessage.QRY, 0, data);
// System.err.println("sending to " + view.size() + " neighbours: " // + m);
// For ttl <=3 we use flooding and for ttl >3 we use K-Walker Random Walk where K is prespecified walker number.
if (ttl <=3){
for (int i = 0; i <= this.degree(); i++) {
this.send((Node) this.getNeighbor(i), m);}
}else {
for (int i = 0; i < this.walkers; i++) {
this.send((Node) this.getNeighbor(i), m);}
} }
}
# PEERSIM EXAMPLE iSEARCH
random.seed 1234567890
simulation.cycles 100
control.0 peersim.cdsim.Shuffle
network.size 10000
#network.maxsize 1000
include.protocol Hybrid_Search
protocol.topo peersim.core.IdleProtocol
protocol.topo.capacity 10
protocol.Hybrid_Search peersim.extras.gj.isearch.RWProtocol
#protocol.Hybrid_Search.linkable topo
protocol.Hybrid_Search.ttl 20
init.0 peersim.dynamics.WireKOut
#init.0.protocol topo
init.0.protocol Hybrid_Search
init.0.k 20
init.1 peersim.extras.gj.isearch.SearchDataInitializer
init.1.protocol Hybrid_Search
init.1.keywords 1000
init.1.query_nodes 1
init.1.query_interval 1
init.1.max_queries 1
control.0 peersim.extras.gj.isearch.SearchObserver
control.0.protocol Hybrid_Search
control.0.verbosity 1
control.1 peersim.reports.DegreeStats
control.1.protocol Hybrid_Search
control.1.method list