RACOON: A framework to design
Cooperative Systems resilient to selfish nodes
Guido Lena Cota ⇤ Gabriele Gianini
Ernesto Damiani
Sonia Ben Mokhtar
Lionel Brunie
LIRIS-CNRS-Insa Lyon
Universit`a degli Studi di Milano
Abstract
In this work we present RACOON: a design and simulation framework for building selfish-resilient cooperative systems. RACOON enforces cooperation by making nodes accountable for their actions, so that selfish behaviours are less
convenient to adopt. This is realized by deploying: (1) an
accountability mechanism to audit nodes and detect deviations; and (2) a reputation management system to assign positive/negative incentives (depending on the result of the audit). The configuration of these mechanisms is supported by
a semi-automatic approach, which is based on Game-Theory
driven simulations.
Using RACOON, a cooperative system is designed in
four phases: specification, augmentation, GT analysis, and
simulation. In the first phase, the system designer specifies the target system as a collection of deterministic finite
state machines. Also, the designer specifies a set of selfishresilience and performance objectives that the system must
fulfill. The framework includes a specification model to simplify this process. In the augmentation phase, RACOON proceeds with the automatic integration of the cooperation enforcement mechanisms presented above. Then, the framework extends the initial specification with new states and
transitions that model also selfish behaviours. The gametheoretic analysis phase takes as input the augmented specification of the target system, and uses GT - specifically, the
concept of Nash Equilibria - to predict the behaviour of selfish nodes. The previous two phases, in practice, result in the
automatic generation of a model of selfishness that may affect the target system. Finally, the GT predictions are used
to simulate and analyse the behaviour of the cooperative system when in the presence of selfish nodes. The outcome of
the simulations is a satisfactory configuration of the cooperation enforcement mechanisms, which reaches all the objectives set by the system designer.
We evaluated RACOON by designing two cooperative
systems: a P2P live streaming, and an anonymous communications system. Simulations, as well as a real deployment
of the applications on a testbed comprising 100 nodes, show
that the systems achieve both resilience to selfish nodes and
high performance.
Cooperative Systems are among the applications generating
the most traffic in today’s Internet. Cooperative systems include peer-to-peer (P2P) instant messaging and voice over
IP (e.g., Skype), P2P file sharing (e.g., BitTorrent), and P2P
live streaming (e.g., P2PTV, Popcorn Time). The success of
these systems mainly resides in their high scalability and
robustness to failures, without requiring costly dedicated
servers. These properties arise from the cooperation between
nodes, which share their (communication and computation)
resources with others. However, cooperative systems suffer
from selfish nodes that strategically withdraw from cooperation whenever it is convenient (e.g., receiving video data,
without sharing data with others, to save bandwidth).
The problem of selfishness in cooperative systems is hard
to tackle, because the solution has to satisfy conflicting requirements. On the one hand, it should provide the desired
resilience to selfish behaviours. On the other hand, it should
impose minimal overhead, and be easy to implement, operate and maintain. For these reasons, designing cooperative
systems is a challenging task.
In spite of much research in this field, there is no fully satisfactory solution that meets all the above requirements. The
main contribution comes from Game Theory (GT), which
appears to be the natural tool for analysing interactions
among self-interested nodes. In GT approaches, the system designer lists the set of deviations that can be performed
by selfish nodes. Then, he has to provide a countermeasure for each deviation. Finally, the system designer has to
prove that the best strategy for selfish nodes is not to deviate
(i.e., proving the system be a Nash Equilibrium). However,
carrying out this process is complex, time consuming, and
error prone. Moreover, establishing cooperation is usually
the only goal of GT solutions, with system performance regarded as a secondary issue. In this context, the challenge is
to devise a practical methodology for finding a satisfactory
trade-off between selfish-resilience and performance.
⇤ PhD
Student - Presenter
1
2015/4/10
SUPERVISORS:
Gabriele GIANINI
[email protected]
[email protected]
Lionel BRUNIE
Ernesto DAMIANI
[email protected]
[email protected]
Guido LENA COTA
[email protected]
MOTIVATION
How popular are CSs in the Internet?
CSs suffers from selsh nodes that cooperate
only when doing so is convenient for them.
● Designing a CS that is able to tolerate sel)sh
nodes is a challenging task.
Upstream Trafc Share (%)
100
P2P
Real-Time Entertainment
SEMI-AUTOMATIC
framework for the design
GENERIC
and con)guration of CSs
GAME-THEORY
BASED
resilient to sel)sh nodes.
A
Others (e.g. Marketplaces,
Communication)
Europe
Trade
video
chunks
CONTRIBUTION
Storage
0
p1
p0
Web Browsing
Asia N. America
100
the P2P Live Streaming use case
●
Sandvine's Global Internet Phenomena Report 2H 2014
50
Selshness in CS:
(log scale)
RACOON
A framework to design selsh-resilient
Cooperative Systems (CS)
p2
10
p3
3
p4
Acceptable degradation
p5
0
25
50
% Chunks Missed by Users
AUTHOR:
Sonia BEN MOKHTAR
1
100
75
% Selsh Nodes
RACOON FRAMEWORK OVERVIEW
System Designer
1
RACOON Semi-Automatic Toolset
Augmentation
Specication
SELFISH
RESILIENT
SYSTEM
4
3
2
Game-theoretic analysis
Simulation
Alice
Bob
tim
eo
ut
2
<1
Augmentation
π3 ,π4
π5 ,π6
t
Bob
π7 ,π8
4
se
pon
res
Rationality
model
se
pon
res
π1 ,π2
de
vR
eq
ue
st
ue
s
Simulator
setting
tim
eo
ut
Conf.
eo
ut
System
Objectives
tim
COOP. ENFORCEMENT
Mechanisms
req
Simulation
π9 ,π10
3
Alice.request
s11
Selsh Strategy
(i.e., Nash Equilibrium)
Game Mapping
s3
Augmented
Specication
Alice.request
Bob.timeout
s43
Alice
s11
s5
Bob
π1 ,π2
s2
π3 ,π4
ACCOUNTABILITY to detect sel)sh nodes;
✔
REPUTATION as incentives to reward
Application
COOP. ENFORCEMENT
Account.
cooperation and sanction deviations,
eventually evicting nodes from the CS.
P2P Live Streaming
1st Use Case
Lines
of Code
%
Reusable
71
52.1
Simulator
1800
71.7
Prototype
3060
63.7
Reputation
Specication
Communication System
10
contribution
ΔReputationi < 0
>0
<0
Anonymous
Communication
2nd Use Case
Lines
of Code
(log scale)
The utility ui of a sel)sh node i that plays the strategy σi is:
RACOON - Prototype
deployed on Grid'5000
(100 Nodes)
1
0,1
Acceptable degradation
Traditional Live
Streaming (100 Nodes)
0
10 20 30 40 50 60 70 80 90 100
% Selsh Nodes
%
Reusable
Specication
61
53.3
Simulator
1530
72.3
% Onions Missed by Users
Sel)sh nodes aim at playing the strategy that maximizes their utility.
ΔReputationi > 0
π9 ,π10
RACOON - Simulation
(1000 Nodes)
What is the utility function of a selsh node?
u i =∑ cost i (σ i )+ρ(Δ Reputationi )
π7 ,π8
100
% Chunks Missed by Users(log scale)
✔
π5 ,π6
Bob
EVALUATION & RESULTS
How does RACOON enforce cooperation?
RACOON augments the original CS with
two mechanisms:
Re
qu
es
t
se
pon
res
Bob.response
Game Analysis
de
v
req
ue
st
se
pon
res
Functional
Specication
s00
tim
eo
ut
s2
Alice.devRequest
eo
ut
Alice.timeout
tim
Bob.response
tim
eo
ut
s00
100
10
1
0,1
0
10 20 30 40 50 60 70 80 90 100
RACOON – Simulation
(1000 Nodes)
Traditional Anonymous
Communication (1000
Nodes)