{"id":{"repo_id":"uiuc","oai_identifier":"oai:www.ideals.illinois.edu:2142/44758"},"canonical_url":"https://search.dev.ndltd.org/etd/uiuc/oai:www.ideals.illinois.edu:2142/44758","repository":{"repo_id":"uiuc","name":"University of Illinois - Urbana-Champaign","base_url":"https://www.ideals.illinois.edu/oai-pmh"},"display":{"title":"Efficient execution of fine-grained actors on multicore processors","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.","abstract_html":"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.","abstract_has_math":false,"creators":["Kumar, Rajesh"],"institution":"University of Illinois at Urbana-Champaign","degree_name":"Ph.D.","degree_level":"Dissertation","degree_discipline":"Computer Science","degree_department":null,"school":null,"contributors":["Agha, Gul A.","Marinov, Darko","Johnson, Ralph E.","Miller, Mark S."],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2013,"date_issued":"2013-05-28T19:18:33Z","date_published":"2013-05-28T19:18:33Z","updated_at":"2026-07-22T22:25:34Z","subjects":["multicore","efficiency","performance","actor model","concurrency","parallelism","programming","ActorFoundry","games"],"languages":["en"],"rights":["Copyright 2013 Rajesh Kumar"],"rights_urls":[],"identifier_entries":[]},"links":{"outbound_url":"http://hdl.handle.net/2142/44758","outbound_label":"Handle","outbound_source":"dc:identifier"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Agha, Gul A.","Marinov, Darko","Johnson, Ralph E.","Miller, Mark S."]},{"key":"dc:creator","label":"Author","values":["Kumar, Rajesh"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2013-05-28T19:18:33Z","2015-05-28T10:00:39Z","2013-05"]},{"key":"dc:type","label":"Dc Type","values":["text"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Computer Science"]},{"key":"thesis:degree_level","label":"Degree Level","values":["Dissertation"]},{"key":"thesis:degree_name","label":"Degree Name","values":["Ph.D."]},{"key":"thesis:institution_name","label":"Thesis Institution Name","values":["University of Illinois at Urbana-Champaign"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["multicore","efficiency","performance","actor model","concurrency","parallelism","programming","ActorFoundry","games"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language","label":"Dc Language","values":["en"]},{"key":"dc:rights","label":"Dc Rights","values":["Copyright 2013 Rajesh Kumar"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["http://hdl.handle.net/2142/44758"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["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.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2013-04-17T21:26:49Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 2 dissertation.pdf: 711216 bytes, checksum: 181ea9a0ac6acef308c9266e37cbc374 (MD5) Kumar_Rajesh.pdf: 711216 bytes, checksum: 181ea9a0ac6acef308c9266e37cbc374 (MD5)","Made available in DSpace on 2013-05-28T19:18:33Z (GMT). No. of bitstreams: 2 Rajesh_Kumar.pdf: 711216 bytes, checksum: 181ea9a0ac6acef308c9266e37cbc374 (MD5) license.txt: 4061 bytes, checksum: 0b49ee58be42f150e4fcb4f673e34f0e (MD5)","Item marked as restricted to the 'Administrator' Group (id=1) by Seth Robbins (srobbins@illinois.edu) on 2013-05-28T19:21:30Z Item is restricted until 2015-05-28T19:21:22Z","Restriction data tranferred 2014-07-01T11:16:35-05:00 Original Data Group with Access Administrator Release Date: 2015-05-28 14:21:22 UTC Reason: Author requested closed access (OA after 2yrs) in Vireo ETD system","Limited Restriction Lifted for Item 44733 on 2015-05-28T10:00:39Z."]},{"key":"dc:title","label":"Title","values":["Efficient execution of fine-grained actors on multicore processors"]}]}],"canonical_facts":{"dc:contributor":["Agha, Gul A.","Marinov, Darko","Johnson, Ralph E.","Miller, Mark S."],"dc:creator":["Kumar, Rajesh"],"dc:date":["2013-05-28T19:18:33Z","2015-05-28T10:00:39Z","2013-05"],"dc:description":["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.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2013-04-17T21:26:49Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 2 dissertation.pdf: 711216 bytes, checksum: 181ea9a0ac6acef308c9266e37cbc374 (MD5) Kumar_Rajesh.pdf: 711216 bytes, checksum: 181ea9a0ac6acef308c9266e37cbc374 (MD5)","Made available in DSpace on 2013-05-28T19:18:33Z (GMT). No. of bitstreams: 2 Rajesh_Kumar.pdf: 711216 bytes, checksum: 181ea9a0ac6acef308c9266e37cbc374 (MD5) license.txt: 4061 bytes, checksum: 0b49ee58be42f150e4fcb4f673e34f0e (MD5)","Item marked as restricted to the 'Administrator' Group (id=1) by Seth Robbins (srobbins@illinois.edu) on 2013-05-28T19:21:30Z Item is restricted until 2015-05-28T19:21:22Z","Restriction data tranferred 2014-07-01T11:16:35-05:00 Original Data Group with Access Administrator Release Date: 2015-05-28 14:21:22 UTC Reason: Author requested closed access (OA after 2yrs) in Vireo ETD system","Limited Restriction Lifted for Item 44733 on 2015-05-28T10:00:39Z."],"dc:identifier":["http://hdl.handle.net/2142/44758"],"dc:language":["en"],"dc:rights":["Copyright 2013 Rajesh Kumar"],"dc:subject":["multicore","efficiency","performance","actor model","concurrency","parallelism","programming","ActorFoundry","games"],"dc:title":["Efficient execution of fine-grained actors on multicore processors"],"dc:type":["text"],"thesis:degree_discipline":["Computer Science"],"thesis:degree_level":["Dissertation"],"thesis:degree_name":["Ph.D."],"thesis:institution_name":["University of Illinois at Urbana-Champaign"]},"updated_at":"2026-07-22T22:25:34Z"}