CAS Project Presentation

Andrea Marcozzi

12/04/2007

Dipartimento di Scienze

dell’Informazione, Università di

Bologna

Outline

! Aim of the project

! ResourceWorld

! Project Specifications

! Peersim guidelines

! Clustering Coefficient and Average Path

Length

Aim of the project

! The aim of this project is to take an

existing protocol for P2P networks

called ResourceWorld

! To propose 2 modifications of such

protocol

! Analyze the results obtained with this

two modifications in order to understand

the global emergent mechanism

ResourceWorld

ResourceWorld Introduction

! In several peer-to-peer applications, systemsrequire their member nodes to behave in asocially beneficial way

! This approach is in contrast with the principle ofclassical individual rationality that states agentsshould select actions that maximize theirindividual utility

! ResourceWorld is a simple locally adaptiveprotocol that claim to produce socially rationaloutcomes through a process of self-organisationeven though nodes only act on their own utilityvalues

The ResourceWorld scenario

! We consider a situation in which there arepopulations of peer nodes that can storeand serve some number of resources (i.e.:Files)

! Each node has its own single nativeresource that it wishes to serve to someusers community achieving somespecified service level

! In each interaction, nodes get anappropriate utility

The ResourceWorld Model (I)

! Let’s consider a P2P overlay network in whicheach node has the following state:

– Strategy bit, A ! {0,1} (indicates if the nodeis altruistic or not)

– Skill, S ! {1,2,3,4,5} (indicates the resourceof the node)

– Neighbour list (max 20 neighbours)

! Periodically, with probability 0.5, nodes receivea request to be completed (Job, J !{1,2,3,4,5})

! Periodically, with a small probability, tworandom nodes are selected and their utilitiesare compared (SLAC)

System architecture

0. Newscast

(Peer Sampling Service)

1. SLACER

2. RW

(Application)

utility

Random node

(movement)

Cooperative

neighbor

Three protocol: Newscast,

SLACER, ResourceWorld (RW)

The ResourceWorld Model (II) ResourceWorld Pseudo-code

At each cycle with probability 0.5:

each node i receives a certain job

if ( Si == job) then Ui += 1;

else

if ( STRATi == true ) then

for all neighbors j with random order

if ( Sj == job) then

Ui += -0.25;

Uj += 1;

With probability 0.2 the SLAC algorithm takes place

Experiments (parameters)! Peersim (http://peersim.sf.net)

! SLAC

! Network size: 4000 nodes

! Network degree: 20

! Initial topology: random

! Single node initialization:

– Strategy bit: 0 (defect)

– Skill: random

! Mutation: (MRT = 0.01; MRS = 0.005)

! Payoffs:

– Benefits from 0.1 to 2.0 by 0.1 steps

– Costs from 0.1 to 2.0 by 0.1 steps

! 10 runs for each experiments meaning

20 X 20 X 10 runs

Experiments (results) (I)

The utility measure we used to evaluate the

performances of the model is the Pcj : the

percentage of completed jobs

We found that to obtain a Pcj > 80%, the

Benefit payoff must be greater or equal

than the Cost payoff

When Cost > Benefit, we obtain a very low Pcj

When Cost = Benefit, the system takes longer

to reach Pcj > 80%

Experiments (results) (II)

ResourceWorld Conclusions

! We took the ResourceWorld model and

modified both benefit and cost utilities to

explore a large space of possible values

! In each case we checked if the protocol

maximized the collective utility or not

Project Specification

Implementation part

! Define 2 new mechanism of “Jobpassing”

– Pass only to altruistic nodes

– Job executed by altruistic nodes only

– Ordered visit of neighbors list

– Recursive job passing (small degree)

– …

! The global emergent mechanism mustbe understood

– Results must be compared and explainedwhatever they are

Beware not to cheat!

! Everything is based on local knowledge

! Other nodes’ state known only when

interacting with them

! It’s forbidden to chose nodes directly

from the network structure

– No global knowledge

– Only local views available for each node

Elaboration of the Data

! Examine the effects of the newproposed mechanisms (throughObservers):

– Cooperation• Cooperation level (Percentage of coop nodes)

• Percentage of completed jobs (Pcj)

• Time for cooperation and Pcj

– Topology• Clustering coefficient (CC)

• Average path length (APL)

• Network Snapshots

Elaboration of the Data (II)

! Examine initial settings effects on

performances

– Network size

– Network degree

– Skills number

– SLACER dropping parameter (W)

Provided code

! The package casProject provides:– Slacer

• Slacer protocol

• SLACERapp must be extended

• BooleanStrategyObserver (cooperating nodes)

• SlacerGraphPrinter (observer for snapshots)

– casProjectApp• casProject is the code you must write (extends

SLACERapp)

• casProjectObserver (Percentage of cooperating nodes)

! Additional Classes– If you need some additional mechanism feel free to

implement and use it!• New specific observer

Peersim Guidelines

Implementing new classes

! All the new code should be included in

classes implementing one (or more) of

the main peersim interfaces

– CDProtocol

– Linkable

– Control

Implementing CDProtocol interface

! peersim.cdsim.CDProtocol provides asingle method to describe protocolactions

– Void nextCycle (Node node, intprotocolID);

•node is the current running node

•protocolID is the protocol id in the currentnode protocol stack

– In nextCycle() any action performed by eachnode at each simulation cycle should beimplemented

Implementing Linkable interface

! peersim.core.Linkable provides abstract

methods for node view management

– public int degree();

– public Node getNeighbor(int i);

– public boolean addNeighbor(Node neighbor);

– public boolean contains(Node neighbor);

Implementing Control interface

! peersim.core.Control provides a single

method to describe global network

actions

– boolean execute();

! In execute(); any action performed at

each simulation cycle for global

management

Defining configuration parameters

! It is possible that components need

parameters to be passed by

configuration file

! peersim.config.Configuration provides

utilities to read parameters from

configuration file

– Numeric values

CDProtocol implementation example

public class casProject extends SLACERapp{

// configuration parameter definition

public static final String PAR_SKILLS = "numskills";

public casProject(String prefix) {

numSkills=Configuration.getInt(prefix+"."+PAR_SKILLS,5);

}

public void nextCycle( Node node, int protocolID ){

// protocol behavior

}

Control implementation examplepublic class casProjectObserver implements Control

{

public static final String PAR_PROT = "protocol";

public casProjectObserver(String name){

this.name = name;

pid = Configuration.getInt(name + "." + PAR_PROT);

}

public boolean execute(){

IncrementalStats queries=new IncrementalStats();

IncrementalStats completed=new IncrementalStats();

for (int i = 0; i<Network.size(); i++){

casProject protocol = (casProject) Network.get(i).getProtocol(pid);

queries.add(protocol.queries);

completed.add(protocol.completed);

}

double ratioComp=((double)completed.getSum()) / queries.getSum();

System.out.println(ratioComp);

Return false;

}

Configuration File (I)#random.seed 1150540268549

simulation.cycles 300

network.Shuffle

network.size 4000

protocol.0 example.newscast.SimpleNewscast

protocol.0.cache 20

protocol.1 slacer.Slacer

protocol.1.degree 20

protocol.1.linkable 0

protocol.1.application 2

protocol.1.reprprob 0.20

protocol.1.mutation 1

protocol.1.tagmutation 0.01

protocol.2 slacer.casProjectApp.casProject

protocol.2.linkable 1

protocol.2.numskills 5

protocol.2.queryprob 0.5

protocol.2.completed 1

protocol.2.processed -0.2

General settings

Protocols settings

Configuration File (II)init.0 peersim.dynamics.WireKOut

init.0.protocol 0

init.0.k 20

init.1 slacer.SlacerInitializer

init.1.protocol 1

init.1.isolateprob 1

init.1.copyprob 1

init.2 slacer.casProjectApp.casProjectStrategyInitializer

init.2.protocol 2

init.2.quantity 0

Init.2.numskills 5

Init.2.skill_m 0.001

Init.2.strat_m 0.001

init.3 peersim.dynamics.WireKOut

init.3.protocol 1

init.3.k 20

Init.3.undirected

control.ob0 slacer.BooleanStrategyObserver

control.ob0.protocol 2

control.ob1 slacer.casProjectApp.casProjectObserver

control.ob1.protocol 2

Control settings:

initialization

Configuration File (II)

control.ob0 slacer.BooleanStrategyObserver

control.ob0.protocol 2

control.ob1 slacer.casProjectApp.casProjectObserver

control.ob1.protocol 2

control.ob2 slacer.SlacerGraphPrinter

control.ob2.protocol 1

control.ob2.outf RWplot/

control.ob2.format dot

control.ob2.period 20

control.ob4 peersim.reports.GraphStats

control.ob4.protocol 1

control.ob4.period 50

control.ob4.nl 100

control.ob4.nc 100

Control settings:

Observers

Working with Peersim

Getting Peersim

! Peersim is available at

http://peersim.sourceforge.net

! Java 5 must be used, SunJava

JDK5.0(J2SE 1.5.0)

Compiling and Launching

! The easiest way for compiling peersim is

through this command:

javac -cp .:jep-2.3.0.jar:djep-1.0.0.jar `find . -name "*.java"`

To run a simulation the command you should

use is:

java -cp .:peersim-1.0.1.jar:jep-2.3.0.jar:djep-1.0.0.jar

peersim.Simulator slacer/casProjectApp/RW-conf1

Plotting the results

! Log files can easily be plotted using

Gnuplot or dragging them into Excel

! For the Network Snapshots, an easy

linux utility called Neato can be used

! For further information on Gnuplot and

Neato go to:– http://www.gnuplot.info/documentation.html

– http://www.graphviz.org/Documentation/neatoguide.pdf

Clustering Coefficient and

Average Path Length

Clustering Coefficient (CC)

! The CC for node i is the proportion of:

– links between the vertices within itsneighbourhood

– the number of links that could possiblyexist in i neighborhood

! If the graph is directed the number of

possible links is:

! It the graph is undirected the number

of possible links is:

! Network CC:

– Is the average of every node’s CC

!

ki(k

i"1)

!

ki(k

i"1)

2

Average Path Length (APL)

! Path length between node i and node j

– Minimum number of hops needed to gofrom i to j

– If j is a neighbor of i, the path length is 1

! APL is defined as the average number

of steps along the shortest paths for all

possible pairs of network nodes

Small World Networks

! A network with high CC and lo APL is said tobe a Small World Network

! A Small World Network is a class of randomgraphs where most nodes are not neighborsof one another, but most nodes can bereached from every other by a small numberof hops or steps

! Examples– People acquaintance (social networks)

– Internet connectivity

– Gene networks

Calculating CC and APL with

Peersim

! Use the component:

peersim.reports.GraphStats

! Parameters:

– Protocol: the id of the protocol on which calculate

the CC and APL

– Period: every how many cycles

– nl: number indicating the dimension of the sample

of nodes on which to calculate the APL

– nc: number indicating the dimension of the sample

of nodes on which to calculate the APL

If you need any help

! Peersim resources page:http://peersim.sf.net

! These slides on:http://www.cs.unibo.it/~marcozzi

! For any questions:marcozzi@cs.unibo.it

! Find me: Dip. Scienzedell’Informazione, Lab C, floor -1

References

! Hales, D. and Arteconi, S. (2006) Slacer: A self-organizingprotocol for coordination in p2p networks. IEEE IntelligentSystems

! Hales, D. (2004) From selfish nodes to cooperativenetworks - emergent link based incentives in peer-to-peernetworks. In Proc. of the 4th IEEE InternationalConference on Peer-to-Peer Computing (P2P2004). IEEEComputer Soc. Press

! Marcozzi, A. and Hales, D. (2006) Emergent SocialRationality in a Peer-to-Peer System. Technical ReportUBLCS-2006-23, University of Bologna, Department ofComputer Science