1. Optimizing Distributed Actor Systems for Dynamic Interactive Services
Andrew Newall, Gabriel Kliot, Ishai Menache Aditya Gopalan, Soramichi Akiyama, Mark Silberstein
Presented by Yihan Li

2. Outline
Introduction and background
Algorithm
Evaluation and results
Conclusion

3. Distributed Actor System
Interactive scalable cloud services
Actor: modeling an application as a dynamic set of lightweight communicating “objects”
To build a complex system such a on-line games

4. Hard to maintain low-latency with large system
Motivation
Hard to maintain low-latency with large system
Inter-server communication
Remote Procedure Calls (RPC)
Inappropriate thread allocation

5. Goals
Low end-to-end latency
Actor partitioning
Thread allocation
Reducing the CPU utilization
Higher throughput
Smaller cluster

6. Orleans (I) .NET-based and Open-source Fault tolerance
Seamlessly migrate actors
Middleware can optimize the system performance transparently to application

7. Orleans (II) Place actors randomly
Migrating active actors
Staged Event Driven Architecture (SEDA)
Receive message
Execute application logic
Send message

8. SEDA Architecture of a Server in Orleans

9. Latency
Actor locality
Thread allocation

10. Execution Flow

11. Static Actor Assignment Policy
Optimizing the placement for a particular actor interaction graph
However, the interaction graph will change
Dynamic actor assignment policy
Communication locality
Load balancing

12. Server Thread Allocation
Server request latency (msec) with different thread allocations

13. Problems Actor placement RPC Skewed and unbalanced actor distribution
Server thread allocation
Changing sever work load

14. Locality-Aware Actor Partitioning
Two goals
Balanced partitioning of actors
Co-locating frequently interacting actors together

15. Balanced Graph Partitioning Problem
Given n available servers, we seek to partition the graph vertices into n disjoined balanced sets such that the sum of edge weights crossing the partitions is minimized.

16. Total Communication Cost

17. Imbalance Tolerance Parameter
The new partition should be balanced
||Vp|-|Vq|| ≤ δ

18. Assumptions
All actors consume a similar amount of memory and compute resources
Light weight
Rarely compute-bound
Overhead of migrating actors is low
Limited number of migrated actors

19. Decide Candidate Sets Transfer score Candidate set High transfer score
Exchange set
Balance constraint

20. Algorithm

21. Latency-Optimized Thread Allocation
Goal: Minimize the server response time
Number of thread in each SEDA stage
Load and processing characteristics
Low-overhead
Short respond time

22. SEDA Model Notation

23. Per-queue Latency and Penalty
Penalty is caused by context switching

24. Optimization Problem for Latency Minimization
The stage services events at least as fast as they arrive
It captures the relationship among the
number of allocated threads and associated
service rate
It ensures that the available resource at the server are not exceeded

25. Thread Allocation
Closed-form solution

26. Evaluation
Testbed
The experiments are performed on a cluster of 10 servers, each with AMD 2x4 2.1 GHz Opteron processors, 16GB of RAM. All servers run 64 bit Windows Server 2008 R2 and .NET 4.5 framework. We use 15 additional frontend servers to generate client requests.

27. Design of Experiments (I)
Halo
100K concurrent players, and game pool of 1000 idle players
Randomly pick 8 players together
Each game last 20 to 30 minutes
Each player plays three to five games
Each player stays in system 100 min on average
New player arrives following Poisson process
Change rate is 1% of the communication graph per minute

28. Results (I)

29. Results (II)

30. Results (III)

31. Conclusion
ActOp automatically adjusting the location of actors with changing communication graph
Thread allocation optimization does provide extra latency reduction
The principles and techniques are general to other actor system

32. Thank you