PeerSim vs NeuroGrid: Parameters

Configuration File samples


PeerSim (Event-Driven)

random.seed 1234567891
simulation.endtime 10^6
simulation.logtime 10^3
simulation.experiments 50
network.size 10^6
network.node peersim.core.GeneralNode

MINDELAY 10 # Minimum delay is 10 ms
MAXDELAY 400 # Maximum delay is 400 ms
DROP 0.0 # Drop probability is 0
protocol.urt UniformRandomTransport
{
mindelay MINDELAY
maxdelay MAXDELAY
}
protocol.tr UnreliableTransport
{
# Messages are actually delivered by urt
transport urt
# Here, we drop them with probability DROP
drop DROP
}

# A simple implementation of Linkable that does nothing;
# just stores a set of neighbors
protocol.link IdleProtocol
# The protocol defined in the previous slides
protocol.my GossipProtocol
{
# Use the unreliable trasport defined above
transport tr
# Use the random topology defined above
protocol link
# Use the default value for prob
}

# Initialize link with 20 neighbors at random
init.rndgraph WireKOut
{
k 20
protocol link
}
# Traffic generator
control.traffic TrafficGenerator
{
# Inject traffic on my protocol
protocol my
# Every 1000ms (1s)
step 1000
}




NeuroGrid (Advanced)

SIMULATION_TYPE=com.neurogrid.simulation.NeuroGridNetwork

LOG_FILE=ng_simulation.log
SUMMARY_LOG_FILE=ng_sum_simulation.log
ARCHITECTURE_LOG_FILE=ng_arch_simulation.log
PROBE_LOG_FILE=ng_probe_simulation.log
SEARCH_LOG_FILE=ng_search.log
LOG_DIRECTORY=output/adv_neurogrid

APPLET=false

NO_KEYWORDS=200
NO_DOCUMENTS=1000
NO_KEYWORDS_PER_DOCUMENT=2
NO_NODES=1000
NO_HONEST_NODES=300
NO_DOCUMENTS_PER_NODE=3
MAX_KNOWLEDGE_PER_NODE=100
NO_CONNECTIONS_PER_NODE=3
MAX_CONNECTIONS_PER_NODE=3
NO_SEARCH_KEYWORDS=1

START_TTL=7

MAX_FORWARDING_DEGREE=5
MIN_FORWARDING_DEGREE=1
INTERNAL_LOOP=100
PROBE_LOOP=101
NO_PROBES=10
GROWTH_LOOP=101
STATS_LOOP=50

RECIPROCAL_CONNECTIONS=true
RING_TOPOLOGY=false
DOC_KEYWORD_ZIPF_DISTRIBUTION=false
NODE_DOC_ZIPF_DISTRIBUTION=false
RANDOM_SEARCHES=false
RANDOM_FORWARDING=false
FUZZY_SEARCHES=false

PeerSim vs NeuroGrid: Statistics

According to this HOWTO, PeerSim generates the following statistics about query packets:

• queryID
• message TTL
• number of times the packets has been seen
• number of successful packet hits
• total number of messages sent for this query

The NeuroGrid advanced simulation produces the following log files containing statistics:

• MAIN_LOG_FILE - loop, No matches, TTL, message transfers, Nodes reached, possible matches
• SUMMARY_LOG_FILE - loop, No matches (ave,stdev), TTL (ave,stdev), message transfers (ave,stdev), Nodes reached (ave,stdev), proportion matches (ave,stdev), efficiency (ave,stdev)
• ARCHITECTURE_LOG_FILE - loop, total nodes, total conns, total knowledge, total knowledge links, message transfers
• PROBE_LOG_FILE - loop, total nodes, ttl (ave,stdev,max,min)

PeerSim vs NeuroGrid: Protocols

PeerSim has a collection of internally developed protocols for the BISON project which can model P2P networks. They are the following:

• OverStat is a collection of aggregation protocols. Aggregation is a collective term for a set of functions aimed at providing statistical information over distributed systems, such as the average load of the nodes or the size of the network.
• SG-1 is a protocol for self-organizing and maintaining a superpeer based topology.
• The Peer sampling service, that can be used as a source of random peers by participating peers.
• The T-Man protocol can be used to build a wide range of different topologies using only a ranking function that defines the preference of each node for neighbors.
• The PdProtocol plays the Prisoner Dilemma between nodes in a network to achieve cooperation. It is based on a socially inspired mechanism (based on "tags") applied to P2P networks.
• The SLACER protocol generates a cooperative artificial social network (ASN) in a P2P overlay.

On the other hand, the NeuroGrid simulator supports the following protocols according to its FAQs:

• Gnutella
• Freenet
• NeuroGrid
• Pastry
• Chord

Peersim vs Neurogrid: Java Classes

Peersim has the following classes:

• Node - The P2P network is composed of nodes. A node is a container of protocols. The node interface provides access to the protocols it holds, and to a fixed ID of the node.
• CDProtocol - It is a specific protocol, that is designed to run in the cycle-driven model. Such a protocol simply defines an operation to be performed at each cycle.
• Linkable - Typically implemented by protocols, this interface provides a service to other protocols to access a set of neighbor nodes. The instances of the same linkable protocol class over the nodes define an overlay network.
• Control - Classes implementing this interface can be scheduled for execution at certain points during the simulation. These classes typically observe or modify the simulation.

Neurogrid has the following:

• Keyword - coordinates the keyword ids and the storage of keywords in hashtables, while farming out the exact nature of the keyword String representation to its child classes.
• Document - coordinates the document ids and the storage of documents in hashtables, while farming out representational details to child classes. In addition documents are assumed to contain a number of keywords, an assumption that bares out for some simulations but not for others.
• Message - contains a number of variables generic across messages, specifically a time to live (TTL) counter and three Node references, regarding where the message is now, where is was immediately previously and where it originated.
• Node - contains more data structures: a map of connections to other nodes, MultiHashtables (that support mappings of multiple values to the same key) that map keywords and document ids to specific content. It also contains a knowledge base that can store information about other nodes, a table of seen messages, a message inbox and most importantly a MessageHandler.
• Network - populate the the nodes with documents, create documents, etc.

Peersim vs Neurogrid: Releases

Peersim 1.0.1 was released last April 21, 2006. Nothing much has changed since the last release, since this one only contains bug fixes for Peersim 1.0.

As for Neurogrid, the latest simulator release (0.2.1) was released last June 24, 2003.

Past Forward

To summarize my activities so far:

I studied and designed the strategy, algorithms and the testbed application (Anthill) to be used, despite the lack of documentation and tutorials of the testbed. However, Anthill was discontinued in favor of a more scalable and lightweight simulator called Peersim. Aside from this, I investigated other simulation tools, hence, I also consider Neurogrid. I am now in the process of implementing the simulated P2P systems.

Gantt Chart

After a very long hiatus, I finally have an update on my thesis. Here's the updated Gantt Chart:

More updates will be posted soon. Stay tuned!