-
Elisa Gonzalez Boix,
Philipp Haller,
Alessandro Ricci,
and Carlos A. Varela, editors.
Proceedings of the 4th International Workshop on Programming based on Actors Agents & Decentralized Control, AGERE 2014, Portland, OR, USA, October 20-24, 2014,
2014.
ACM.
Keyword(s): concurrent programming,
programming languages.
Abstract: |
The 4th International Workshop on Programming based on Actors, Agents, and Decentralized Control (AGERE!) is a unique venue in the research landscape bringing together researchers and practitioners interested in actors, agents and, more generally, high-level paradigms emphasizing decentralized control in thinking, modeling, developing, and reasoning about programs and software systems. The fundamental turn of software into concurrency and distribution is not only a matter of performance, but also of design and abstraction. It calls for programming paradigms that, compared to current mainstream paradigms, would allow us to more naturally think about, design, develop, execute, debug, and profile systems exhibiting different degrees of concurrency, autonomy, decentralization of control, and physical distribution. AGERE! is an ACM SIGPLAN workshop dedicated to focusing on and developing research on programming systems, languages and applications based on actors, agents and any related programming paradigm promoting a decentralized mindset in solving problems and in developing systems to implement such solutions. All stages of software development are considered interesting for the workshop, including requirements, modeling, formalization, prototyping, design, implementation, tooling, testing, and any other means of producing running software based on actors and agents as first-class abstractions. The scope of the workshop includes aspects that concern both the theory and the practice of design and programming using such paradigms, so as to bring together researchers working on models, languages and technologies, as well as practitioners using such technologies to develop real-world systems and applications. AGERE! 2014 received 14 submissions, of which 9 full papers were accepted to be included in these proceedings. Since the first edition, a main objective of the workshop has been to explore and foster the adoption of actors, agents and paradigms based on a decentralized control as a more high-level and effective alternative --- from an abstraction point of view in particular --- to mainstream approaches such as multi-threaded programming. Among others, this calls for devising technologies featuring a good level of maturity and performance. This is reflected by the contributions accepted in this edition. |
@proceedings{varela-agere-2014,
editor = {Elisa Gonzalez Boix and Philipp Haller and Alessandro Ricci and Carlos A. Varela},
title = {{Proceedings of the 4th International Workshop on Programming based on Actors Agents & Decentralized Control, AGERE 2014, Portland, OR, USA, October 20-24, 2014}},
booktitle = {AGERE 2014 Workshop Proceedings},
publisher = {ACM},
year = {2014},
url = {http://dl.acm.org/citation.cfm?id
= 2687357&CFID = 784586504&CFTOKEN = 85922668},
keywords = {concurrent programming, programming languages},
abstract = {The 4th International Workshop on Programming based on Actors, Agents, and Decentralized Control (AGERE!) is a unique venue in the research landscape bringing together researchers and practitioners interested in actors, agents and, more generally, high-level paradigms emphasizing decentralized control in thinking, modeling, developing, and reasoning about programs and software systems. The fundamental turn of software into concurrency and distribution is not only a matter of performance, but also of design and abstraction. It calls for programming paradigms that, compared to current mainstream paradigms, would allow us to more naturally think about, design, develop, execute, debug, and profile systems exhibiting different degrees of concurrency, autonomy, decentralization of control, and physical distribution. AGERE! is an ACM SIGPLAN workshop dedicated to focusing on and developing research on programming systems, languages and applications based on actors, agents and any related programming paradigm promoting a decentralized mindset in solving problems and in developing systems to implement such solutions. All stages of software development are considered interesting for the workshop, including requirements, modeling, formalization, prototyping, design, implementation, tooling, testing, and any other means of producing running software based on actors and agents as first-class abstractions. The scope of the workshop includes aspects that concern both the theory and the practice of design and programming using such paradigms, so as to bring together researchers working on models, languages and technologies, as well as practitioners using such technologies to develop real-world systems and applications. AGERE! 2014 received 14 submissions, of which 9 full papers were accepted to be included in these proceedings. Since the first edition, a main objective of the workshop has been to explore and foster the adoption of actors, agents and paradigms based on a decentralized control as a more high-level and effective alternative --- from an abstraction point of view in particular --- to mainstream approaches such as multi-threaded programming. Among others, this calls for devising technologies featuring a good level of maturity and performance. This is reflected by the contributions accepted in this edition.}
}
-
Travis Desell and Carlos A. Varela.
SALSA Lite: A Hash-Based Actor Runtime for Efficient Local Concurrency.
In Concurrent Objects and Beyond,
volume 8665 of Lecture Notes in Computer Science,
pages 144-166.
Springer Berlin Heidelberg,
2014.
ISBN: 978-3-662-44470-2.
Keyword(s): distributed computing,
concurrent programming,
programming languages,
actor model.
Abstract: |
As modern computer processors continue becoming more parallel, the actor model plays an increasingly important role in helping develop correct concurrent systems. In this paper, we consider efficient runtime strategies for non-distributed actor programming languages. While the focus is on a non-distributed implementation, it serves as a platform for a future efficient distributed implementation. Actors extend the object model by combining state and behavior with a thread of control, which can significantly simplify concurrent programming. Further, with asynchronous communication, no shared memory, and the fact an actor only processes one message at a time, it is possible to easily implement transparent distributed message passing and actor mobility. This paper discusses SALSA Lite, a completely re-designed actor runtime system engineered to maximize performance. The new runtime consists of a highly optimized core for lightweight actor creation, message passing, and message processing, which is used to implement more advanced coordination constructs. This new runtime is novel in two ways. First, by default the runtime automatically maps the lightweight actors to threads, allowing the number of threads used by a program to be specified at runtime transparently, without any changes to the code. Further, language constructs allow programmers to have first class control over how actors are mapped to threads (creating new threads if needed). Second, the runtime directly maps actor garbage collection to object garbage collection, allowing non-distributed SALSA programs to use Java’s garbage collection “for free”. This runtime is shown to have comparable or better performance for basic actor constructs (message passing and actor creation) than other popular actor languages: Erlang, Scala, and Kilim. |
@incollection{dessell-varela-cob-2014,
year = {2014},
isbn = {978-3-662-44470-2},
booktitle = {Concurrent Objects and Beyond},
volume = {8665},
series = {Lecture Notes in Computer Science},
doi = {10.1007/978-3-662-44471-9_7},
title = {SALSA Lite: A Hash-Based Actor Runtime for Efficient Local Concurrency},
url = {http://dx.doi.org/10.1007/978-3-662-44471-9_7},
publisher = {Springer Berlin Heidelberg},
author = {Desell, Travis and Varela, Carlos A.},
pages = {144-166},
keywords = {distributed computing, concurrent programming, programming languages, actor model},
pdf = "http://wcl.cs.rpi.edu/papers/2014_cob.pdf",
abstract = {As modern computer processors continue becoming more parallel, the actor model plays an increasingly important role in helping develop correct concurrent systems. In this paper, we consider efficient runtime strategies for non-distributed actor programming languages. While the focus is on a non-distributed implementation, it serves as a platform for a future efficient distributed implementation. Actors extend the object model by combining state and behavior with a thread of control, which can significantly simplify concurrent programming. Further, with asynchronous communication, no shared memory, and the fact an actor only processes one message at a time, it is possible to easily implement transparent distributed message passing and actor mobility. This paper discusses SALSA Lite, a completely re-designed actor runtime system engineered to maximize performance. The new runtime consists of a highly optimized core for lightweight actor creation, message passing, and message processing, which is used to implement more advanced coordination constructs. This new runtime is novel in two ways. First, by default the runtime automatically maps the lightweight actors to threads, allowing the number of threads used by a program to be specified at runtime transparently, without any changes to the code. Further, language constructs allow programmers to have first class control over how actors are mapped to threads (creating new threads if needed). Second, the runtime directly maps actor garbage collection to object garbage collection, allowing non-distributed SALSA programs to use Java’s garbage collection “for free”. This runtime is shown to have comparable or better performance for basic actor constructs (message passing and actor creation) than other popular actor languages: Erlang, Scala, and Kilim.}
}
-
Ian W. Dunn.
Proving Correctness of Actor Systems using FIFO Communication.
Master's thesis,
Rensselaer Polytechnic Institute,
May 2014.
Keyword(s): distributed computing,
concurrent programming,
internet programming languages,
actor model,
formal verification.
Abstract: |
We are developing a hierarchy of theories to reason about actor systems, with the ability to reuse proofs formalized at an abstract level in reasoning about concrete actor programs. Several actor languages, e.g., the ABCL family of languages, implement First-In First-Out (FIFO) communication between actors. Furthermore, many practical systems require FIFO communication for correctness. In previous work, Musser and Varela formalized properties including monotonicity of actor local states, guaranteed message delivery, and general con- sequences of fairness. While the actor model requires fairness, it does not require FIFO communication. In this thesis, we extend the actor reasoning framework to enable proving correctness of systems which require FIFO communication. This is done by extending the actor framework within the Athena proof system, in which proofs are both humanreadable and machine- checkable, taking advantage of its library of algebraic and relational theories. We introduce three new theories into the actor model framework of Athena. All three of these theories are developed at the abstract level, enabling the use of them in many concrete programs. The first two of these theories introduce sequence numbers into the messages passed between actors, one for sending and one for receiving. We take advantage of the monotonicity of actor transitions to show that send sequence numbers and receive sequence numbers will only ever increase. The third new theory begins to prove the ordering of messages given an order of the sequence numbers. We use results from the first two theories to show that if two messages are about to be sent or received, then the order in which the messages are sent or received is dictated by the sequence numbers. We then use that result to show that two messages must be received in the same order in which they were sent. We continue on to show an example of an actor system, based on the computation of the Sieve of Eratosthenes, that requires FIFO communication in order to be able to prove correctness of its computation. |
@MastersThesis{dunn-msthesis-2014,
author = {Ian W. Dunn},
title = {Proving Correctness of Actor Systems using FIFO Communication},
school = {Rensselaer Polytechnic Institute},
year = 2014,
month = {May},
pdf = {http://wcl.cs.rpi.edu/theses/DunnMSThesis.pdf},
keywords = {distributed computing, concurrent programming, internet programming languages, actor model, formal verification},
abstract = {We are developing a hierarchy of theories to reason about actor systems, with the ability to reuse proofs formalized at an abstract level in reasoning about concrete actor programs. Several actor languages, e.g., the ABCL family of languages, implement First-In First-Out (FIFO) communication between actors. Furthermore, many practical systems require FIFO communication for correctness. In previous work, Musser and Varela formalized properties including monotonicity of actor local states, guaranteed message delivery, and general con- sequences of fairness. While the actor model requires fairness, it does not require FIFO communication. In this thesis, we extend the actor reasoning framework to enable proving correctness of systems which require FIFO communication. This is done by extending the actor framework within the Athena proof system, in which proofs are both humanreadable and machine- checkable, taking advantage of its library of algebraic and relational theories. We introduce three new theories into the actor model framework of Athena. All three of these theories are developed at the abstract level, enabling the use of them in many concrete programs. The first two of these theories introduce sequence numbers into the messages passed between actors, one for sending and one for receiving. We take advantage of the monotonicity of actor transitions to show that send sequence numbers and receive sequence numbers will only ever increase. The third new theory begins to prove the ordering of messages given an order of the sequence numbers. We use results from the first two theories to show that if two messages are about to be sent or received, then the order in which the messages are sent or received is dictated by the sequence numbers. We then use that result to show that two messages must be received in the same order in which they were sent. We continue on to show an example of an actor system, based on the computation of the Sieve of Eratosthenes, that requires FIFO communication in order to be able to prove correctness of its computation.}
}
-
Jonathan Goldszmidt.
A Look Into Virtual Machine Malleability.
Master's thesis,
Rensselaer Polytechnic Institute,
May 2014.
Keyword(s): virtual machines malleability,
distributed computing.
Abstract: |
Many have leveraged virtual machine cloning, migration and other features of virtualization to improve and guarantee high availability and performance of their applications. Virtual machine malleability is the ability to split and merge virtual machines based on demand and performance, to improve virtualization functionality. The splitting function will take a virtual machine with a workload of N independent processes and split the independent processes into at most N virtual machines. Similarly, the merging function will take at most N previously-split virtual machines and merge their independent processes into a single virtual machine. There has been previous research in malleability at the application layer. However, most of the benefits of application layer malleability can also be realized at the virtual machine layer. These benefits include dynamic workload reconfigurability while affording better transparency. The benefits provided by virtual machine malleability can be put into 3 categories: scalability and elasticity, energy improvements and process scheduling. Traditionally, the approach of application scaling at the application layer involves writing an application with malleability in mind. Using our method of scaling, applications do not need to be written with malleability in mind to be able to scale, as long as the application workloads are independent or they can communicate over a network. The approach of energy optimization typically involves consolidating virtual machines onto fewer hosts and putting idle hosts in a low power or off state. Although this method works quite well, certain virtual machine configurations cannot be consolidated without significantly impacting performance. Using virtual machine malleability, processes running on a virtual machine that is on an overloaded physical machine can be split across multiple virtual machines, each with a smaller resource footprint. Each of these split machines can then be consolidated without causing the physical hosts to become overloaded. Such flexibility in virtual machine scheduling enables better energy consumption. Our experiments with virtual machine malleability show that application scalability is possible with negligible performance degradation, that it is possible to dynamically reconfigure workloads to achieve set resource utilization, which in turn improves energy utilization. We evaluate scalability and elasticity by splitting and merging virtual machines running many instances of the same CPU intensive process. Our evaluation of splitting and merging demonstrates linear performance changes. Finally, we discuss some future work which includes the design of middleware for managing virtual machine malleability. |
@MastersThesis{goldsj3-vmmalleability-2014,
author = {Jonathan Goldszmidt},
title = {A Look Into Virtual Machine Malleability},
school = {Rensselaer Polytechnic Institute},
year = 2014,
month = {May},
pdf = {http://wcl.cs.rpi.edu/theses/jonathangoldszmidt-master.pdf},
keywords = {virtual machines malleability, distributed computing},
abstract = {Many have leveraged virtual machine cloning, migration and other features of virtualization to improve and guarantee high availability and performance of their applications. Virtual machine malleability is the ability to split and merge virtual machines based on demand and performance, to improve virtualization functionality. The splitting function will take a virtual machine with a workload of N independent processes and split the independent processes into at most N virtual machines. Similarly, the merging function will take at most N previously-split virtual machines and merge their independent processes into a single virtual machine. There has been previous research in malleability at the application layer. However, most of the benefits of application layer malleability can also be realized at the virtual machine layer. These benefits include dynamic workload reconfigurability while affording better transparency. The benefits provided by virtual machine malleability can be put into 3 categories: scalability and elasticity, energy improvements and process scheduling. Traditionally, the approach of application scaling at the application layer involves writing an application with malleability in mind. Using our method of scaling, applications do not need to be written with malleability in mind to be able to scale, as long as the application workloads are independent or they can communicate over a network. The approach of energy optimization typically involves consolidating virtual machines onto fewer hosts and putting idle hosts in a low power or off state. Although this method works quite well, certain virtual machine configurations cannot be consolidated without significantly impacting performance. Using virtual machine malleability, processes running on a virtual machine that is on an overloaded physical machine can be split across multiple virtual machines, each with a smaller resource footprint. Each of these split machines can then be consolidated without causing the physical hosts to become overloaded. Such flexibility in virtual machine scheduling enables better energy consumption. Our experiments with virtual machine malleability show that application scalability is possible with negligible performance degradation, that it is possible to dynamically reconfigure workloads to achieve set resource utilization, which in turn improves energy utilization. We evaluate scalability and elasticity by splitting and merging virtual machines running many instances of the same CPU intensive process. Our evaluation of splitting and merging demonstrates linear performance changes. Finally, we discuss some future work which includes the design of middleware for managing virtual machine malleability.}
}
-
Phillip Kuang.
Implementation of the Transactor Model: Fault Tolerant Distributed Computing using Asynchronous Local Checkpointing.
Master's thesis,
Rensselaer Polytechnic Institute,
July 2014.
Keyword(s): distributed computing,
concurrent programming,
coordination models,
internet programming languages.
Abstract: |
The Transactor model, an extension to the Actor Model, is a well-formulated way to model distributed concurrent systems while maintaining a global distributed state. This model provides semantics to track dependencies among loosely-coupled distributed components that ensures fault tolerance through a two-phase commit protocol and issues rollbacks in the presence of failures or state inconsistency. We seek to introduce an implementation of this model through a transactor language as an extension of an existing actor language and highlight the capabilities of this programming model. We developed our transactor language using SALSA, an actor language developed as a dialect of Java. This transactor language will in turn be a dialect of SALSA, which similarly will compile into Java code. We first develop our transactor language as a basic SALSA/Java library in conjunction with the SALSA Java library. This library implements the fundamental semantics of the transactor model following the defined transition rules. We then provide example programs written using this library such as the reference cell, banking transfer, and the house purchase transaction. Furthermore, we seek to expand our language by introducing a state storage property known as the Universal Storage Location as an extension of the Universal Actor Name and Universal Actor Locator in SALSA that levies a Storage Service to maintain checkpointed transactor states. We also introduce the Consistent Transaction Protocol and Ping Director that improves upon the Universal Checkpointing Protocol to aid transactor programs in reaching globally consistent states and perform reliable transactions. |
@MastersThesis{kuang-transactor-2014,
author = {Phillip Kuang},
title = {Implementation of the Transactor Model: Fault Tolerant Distributed Computing using Asynchronous Local Checkpointing},
school = {Rensselaer Polytechnic Institute},
year = 2014,
month = {July},
pdf = {http://wcl.cs.rpi.edu/theses/KuangMSThesis.pdf},
keywords = {distributed computing, concurrent programming, coordination models, internet programming languages},
abstract = {The Transactor model, an extension to the Actor Model, is a well-formulated way to model distributed concurrent systems while maintaining a global distributed state. This model provides semantics to track dependencies among loosely-coupled distributed components that ensures fault tolerance through a two-phase commit protocol and issues rollbacks in the presence of failures or state inconsistency. We seek to introduce an implementation of this model through a transactor language as an extension of an existing actor language and highlight the capabilities of this programming model. We developed our transactor language using SALSA, an actor language developed as a dialect of Java. This transactor language will in turn be a dialect of SALSA, which similarly will compile into Java code. We first develop our transactor language as a basic SALSA/Java library in conjunction with the SALSA Java library. This library implements the fundamental semantics of the transactor model following the defined transition rules. We then provide example programs written using this library such as the reference cell, banking transfer, and the house purchase transaction. Furthermore, we seek to expand our language by introducing a state storage property known as the Universal Storage Location as an extension of the Universal Actor Name and Universal Actor Locator in SALSA that levies a Storage Service to maintain checkpointed transactor states. We also introduce the Consistent Transaction Protocol and Ping Director that improves upon the Universal Checkpointing Protocol to aid transactor programs in reaching globally consistent states and perform reliable transactions.}
}
-
Pratik Patel.
Speeding Up and Augmenting Mobile Device Applications using Actors and Cloud Computing.
Master's thesis,
Rensselaer Polytechnic Institute,
December 2014.
Keyword(s): distributed computing,
concurrent programming.
Abstract: |
The use of mobile devices has been steadily increasing, for example, smartphones are expected to be used by 69.4% of people worldwide by 2017. User expectations have also increased as the computational capabilities of mobile devices improve. As a result, software applications need to perform ever more complex and data-intensive tasks to address user expectations. Because of resource limitations in mobile devices (e.g., battery, limited network connectivity) we investigate the cloud computing paradigm as a means of augmenting mobile device capabilities. In this thesis, we first study the potential reduction in computation time for a mobile device application that offloads part or all of its execution to remote resources, such as a tablet, a laptop, a desktop, or a private/public cloud. Second, we apply the actor model of concurrent computation to reconfigure a distributed application from the mobile device to the cloud. Specifically, we use the SALSA actor programming language, which allows developers to easily create computationally intensive applications that can be broken apart and migrated to various computational resources. Since SALSA programs compile down to Java byte code, we can readily run them in the Android Operating System through an extension to the SALSA language. Lastly, we aim for a separation of concerns by specifying policies that govern when and where to move actors, separately from the functional application code. Using our Mobile Cloud Computing using Actors (MobileCCA) approach, as applied to a face recognition task, we observed speedups on average of ~5x in the private cloud with respect to doing the computation on the mobile device. Furthermore, we were able to perform the face recognition task on a database of 1000 faces for 400 people, a task beyond the resource capabilities of the mobile device alone. MobileCCA therefore illustrates not only the potential to speedup computations in mobile devices and save battery, but also to enhance the power of mobile applications. |
@MastersThesis{patelp8-mobilecca-2014,
author = {Pratik Patel},
title = {Speeding Up and Augmenting Mobile Device Applications using Actors and Cloud Computing},
school = {Rensselaer Polytechnic Institute},
year = 2014,
month = {December},
pdf = {http://wcl.cs.rpi.edu/theses/pratikpatel-master.pdf},
keywords = {distributed computing, concurrent programming},
abstract = {The use of mobile devices has been steadily increasing, for example, smartphones are expected to be used by 69.4% of people worldwide by 2017. User expectations have also increased as the computational capabilities of mobile devices improve. As a result, software applications need to perform ever more complex and data-intensive tasks to address user expectations. Because of resource limitations in mobile devices (e.g., battery, limited network connectivity) we investigate the cloud computing paradigm as a means of augmenting mobile device capabilities. In this thesis, we first study the potential reduction in computation time for a mobile device application that offloads part or all of its execution to remote resources, such as a tablet, a laptop, a desktop, or a private/public cloud. Second, we apply the actor model of concurrent computation to reconfigure a distributed application from the mobile device to the cloud. Specifically, we use the SALSA actor programming language, which allows developers to easily create computationally intensive applications that can be broken apart and migrated to various computational resources. Since SALSA programs compile down to Java byte code, we can readily run them in the Android Operating System through an extension to the SALSA language. Lastly, we aim for a separation of concerns by specifying policies that govern when and where to move actors, separately from the functional application code. Using our Mobile Cloud Computing using Actors (MobileCCA) approach, as applied to a face recognition task, we observed speedups on average of ~5x in the private cloud with respect to doing the computation on the mobile device. Furthermore, we were able to perform the face recognition task on a database of 1000 faces for 400 people, a task beyond the resource capabilities of the mobile device alone. MobileCCA therefore illustrates not only the potential to speedup computations in mobile devices and save battery, but also to enhance the power of mobile applications.}
}