Files in this item

FilesDescriptionFormat

application/pdf

application/pdfRajesh_Kumar.pdf (711kB)
(no description provided)PDF

Description

Title:Efficient execution of fine-grained actors on multicore processors
Author(s):Kumar, Rajesh
Director of Research:Agha, Gul A.
Doctoral Committee Chair(s):Agha, Gul A.
Doctoral Committee Member(s):Marinov, Darko; Johnson, Ralph E.; Miller, Mark S.
Department / Program:Computer Science
Discipline:Computer Science
Degree Granting Institution:University of Illinois at Urbana-Champaign
Degree:Ph.D.
Genre:Dissertation
Subject(s):multicore
efficiency
performance
actor model
concurrency
parallelism
programming
ActorFoundry
games
Abstract:The Actor model is a promising model for programming new computing platforms such as the multicores and cloud computers, primarily due to features such as inherent concurrency and isolation of state. However, the model is often perceived to be fundamentally inefficient on stock multicore processors. Consequently, we find that standard semantic properties of the model, including encapsulation and fairness, are ignored even by languages and frameworks that claim to be based on the Actor model. In this work, we propose and implement both static (compiler) and dynamic (runtime) techniques that overcome these perceived inefficiencies, while retaining key actor semantics, even in a framework setting. We compare the performance of ActorFoundry with other frameworks for small benchmarks and programs. The results suggest that key actor semantics can be supported in an actor framework without compromising execution efficiency. We also validate our results for a large real-world application, i.e. a Java game called Quantum having more than 25k lines of code. Quantum is a real-time strategy game, which employs a few threads for handling IO, UI and network events. We port the Quantum game to ActorFoundry, so that the asynchrony due to threads and communication between them is expressed using actors and messages. Next, we introduce additional concurrency in Quantum by actorizing all game objects. This results in relatively fine-grained actors. We are able to run a game instance with more than 10,000 game objects, which keeps an 8-core computer at full throttle. According to our knowledge, this is the largest execution of a real client-side actor program. The performance is comparable to an Actor framework implementation that does not provide the standard actor semantics. Moreover, our set of static (compiler) and dynamic (runtime) techniques allow an actor framework to compare well against a shared memory model in terms of execution efficiency.
Issue Date:2013-05-28
URI:http://hdl.handle.net/2142/44758
Rights Information:Copyright 2013 Rajesh Kumar
Date Available in IDEALS:2013-05-28
2015-05-28
Date Deposited:2013-05


This item appears in the following Collection(s)

Item Statistics