G. Agha | University of Illinois at Urbana-Champaign (original) (raw)

Papers by G. Agha

... par Rémi Bastide Spécification comportementale par réseaux de Petri : ... J'ai défini da... more ... par Rémi Bastide Spécification comportementale par réseaux de Petri : ... J'ai défini dans ma thèse [Bastide, 92] le formalisme des Objets Coopératifs, que l'on peut présenter comme une unification des paradigmes « Objets dans les RdP » et « RdP dans les Objets ». ...

Metaprogramming and computational reflection are two related concepts that allow a program to ins... more Metaprogramming and computational reflection are two related concepts that allow a program to inspect and possibly modify itself while running. Although the concepts have been explored by researchers for some time, a form of metaprogramming, namely aspect-oriented programming, is now being used by some practitioners. This paper is an attempt to understand the limitations of different forms of computational reflection in concurrent and distributed computing. It specifically studies the use of aspect-oriented programming and reflective actor libraries, and their relation to full reflection. We choose distributed monitoring as the primary example application because its requirements nicely fit the abilities of the two systems as well as illustrate their limitations.

computer.org

Page 1. xvi Reviewers Gul Agha Tamio Arai Doo-Hwan Bae Farokh B. Bastani Elisa Bertino Marion Cer... more Page 1. xvi Reviewers Gul Agha Tamio Arai Doo-Hwan Bae Farokh B. Bastani Elisa Bertino Marion Ceruti Ing-Ray Chen Jackie CY Chen Randy Chow P. Chuang Jen-Yao Chung P. Ciancarini B. Cukic Klaus-Peter Eckert S. Eisenbach Domenico Ferrari M. Fisher Masahiro Fujita Akira Fukuda V. Garg Arif Ghafoor A. Ghose Sumit Ghosh Michel Gien V. Gobel Teruo Higashino David Hislop Ichiro Iida Makoto Imase Yoshihide Ishiguro Koji Ito Yoshiaki Kakuda Kane Kim Hermann Kopetz Jeff Kramer L. LeLann Chung-Shyan Liu Michael Lyu ...

IEEE Transactions on Software Engineering, 2011

We propose a new probabilistic temporal logic iLTL which captures properties of systems whose sta... more We propose a new probabilistic temporal logic iLTL which captures properties of systems whose state can be represented by probability mass functions (pmf's). Using iLTL, we can specify reachability to a state (i.e., a pmf), as well as properties representing the aggregate (expected) behavior of a system. We then consider a class of systems whose transitions are governed by a Markov Chain-in this case, the set of states a system may be in is specified by the transitions of pmf's from all potential initial states to the final state. We then provide a model checking algorithm to check iLTL properties of such systems. Unlike existing model checking techniques, which either compute the portions of the computational paths that satisfy a specification, or evaluate properties along a single path of pmf transitions, our model checking technique enables us to do a complete analysis on the expected behaviors of large scale systems. Desirable system parameters may also be found as a counterexample of a negated goal. Finally, we illustrate the usefulness of iLTL model checking by means of two examples: assessing software reliability, and ensuring the results of administering a drug.

IEEE International Conference on Sensor Networks, Ubiquitous, and Trustworthy Computing -Vol 1 (SUTC'06)

Physical devices are increasingly regulated by embedded computers rather than analog controllers.... more Physical devices are increasingly regulated by embedded computers rather than analog controllers. Embedded computers are essentially computational engines capable of sensing the environment, actuating physical devices, carrying out data analysis and planning actions. Embedded computers can thus enable machines to become intelligent and autonomous. The next technological revolution will follow from the ability of intelligent machines to network with other

Proceedings of the twenty-second annual ACM symposium on Parallelism in algorithms and architectures, 2010

Energy consumption by computer systems has emerged as an important concern. However, the energy c... more Energy consumption by computer systems has emerged as an important concern. However, the energy consumed in executing an algorithm cannot be inferred from its performance alone: it must be modeled explicitly. This paper analyzes energy consumption of parallel algorithms executed on shared memory multicore processors. Specifically, we develop a methodology to evaluate how energy consumption of a given parallel algorithm changes as the number of cores and their frequency is varied. We use this analysis to establish the optimal number of cores to minimize the energy consumed by the execution of a parallel algorithm for a specific problem size while satisfying a given performance requirement. We study the sensitivity of our analysis to changes in parameters such as the ratio of the power consumed by a computation step versus the power consumed in accessing memory. The results show that the relation between the problem size and the optimal number of cores is relatively unaffected for a wide range of these parameters.

2008 Second IEEE International Conference on Self-Adaptive and Self-Organizing Systems, 2008

Market-based mechanisms can be used to coordinate self-interested multi-robot systems in fully di... more Market-based mechanisms can be used to coordinate self-interested multi-robot systems in fully distributed environments, where by self-interested we mean that each robot agent attempts to maximize a payoff function which accounts for both the resources consumed and the contribution made by the robot. In previous work, we have studied the effect of various market rules and bidding strategies on the global performance of the multi-robot system. However, rather than use a central monitoring and enforcement mechanisms, we rely on agents to self-report their actions. This assumes that the agents act honestly. In this paper, we drop the honesty assumption, raising the possibility that agents may exaggerate their contribution in order to increase their payoff. To address the problem of such malicious behavior, we propose an audit mechanism to maintain the integrity of reported payoffs. Our algorithm extends previous work on preventing free-riding in peer-to-peer networks. Specifically, we consider locality and mobility in multi-robot systems. We show that our approach efficiently detects malicious behaviors with a high probability.

Lecture Notes in Computer Science, 2005

A novel machine learning based approach was proposed recently as a complementary technique to the... more A novel machine learning based approach was proposed recently as a complementary technique to the acceleration based methods for verifying infinite state systems. In this method, the set of states satisfying a fixpoint property is learnt as opposed to being iteratively computed. We extend the machine learning based approach to verifying general ω-regular properties that include both safety and liveness. To achieve this, we first develop a new fixpoint based characterization for the verification of ω-regular properties. Using this characterization, we present a general framework for verifying infinite state systems. We then instantiate our approach to the context of regular model checking where states are represented as strings over a finite alphabet and the transition relation of the system is given as a finite state transducer; unlike previous learning based algorithms, we make no assumption about the transducer being length-preserving. Using Angluin's L* algorithm for learning regular languages, we develop an algorithm for verification of ω-regular properties of such infinite state systems. The algorithm is a complete verification procedure for systems for whom the fixpoint can be represented as a regular set. We have implemented the technique in a tool called Lever and use it to analyze some examples.

Lecture Notes in Computer Science, 2012

Very large scale systems of autonomous concurrent objects (Actors) require coordination models to... more Very large scale systems of autonomous concurrent objects (Actors) require coordination models to meet two competing goals. On the one hand, the coordination models must allow Actors to dynamically modify protocols in order to adapt to requirement changes over the, likely extensive, lifetime of the system. On the other hand, the coordination models must enforce protocols on potentially uncooperative Actors, while preventing deadlocks caused by malicious or faulty Actors. To meet these competing requirements, we introduce a novel, scoped semantics for Synchronizers [7,6]-a coordination model based on declarative synchronization constraints. The mechanism used to limit the scope of the synchronization constraints is based on capabilities and works without central authority. We show that the mechanism closes an attack vector in the original Synchronizer approach which allowed malicious Actors to intentionally deadlock other Actors.

Lecture Notes in Computer Science

Automatic storage management is important in highly parallel programming environments where large... more Automatic storage management is important in highly parallel programming environments where large numbers of objects and processes are being constantly created and discarded. Part of the difficulty with automatic garbage collection in systems of active objects, such as actors, is that an active object may not be garbage if it has references to other reachable objects, even when no other object has references to it. This is because an actor may at some point communicate its mail address to a reachable object thereby making itself reachable. Because messages may be pending in the network, the asynchrony of distributed networks makes it difficult to determine the current topology. Existing garbage collection schemes halt the computation process in order to determine if a currently inaccessible actor may be potentially active, thus precluding a real-time response by the system. We describe a generation based algorithm which does not require ongoing computation to be halted during garbage collection. We also outline an informal proof of the correctness of the algorithm.

Readings in Distributed Artificial Intelligence, 1988

2010 Third International Conference on Software Testing, Verification, and Validation Workshops, 2010

Multicore computing is here to stay Shared memory multithreaded programs have problems Data races... more Multicore computing is here to stay Shared memory multithreaded programs have problems Data races, deadlocks, atomicity violations...

ECOOP’ 93 — Object-Oriented Programming

We have developed language support for the expression of multiobject coordination. In our languag... more We have developed language support for the expression of multiobject coordination. In our language, coordination patterns can be speci ed abstractly, independent of the protocols needed to implement them. Coordination patterns are expressed in the form of constraints that restrict invocation of a group of objects. Constraints are de ned in terms of the interface of the objects being invoked rather than their internal representation. Invocation constraints enforce properties, such as temporal ordering and atomicity, that hold when invoking objects in a group. A constraint can permanently control access to a group of objects, thereby expressing an inherent access restriction associated with the group. Furthermore, a constraint can temporarily enforce access restrictions during the activity of individual clients. In that way, constraints can express specialized access schemes required by a group of clients. 1 Motivation Coordination of activities is a fundamental aspect of programming languages for concurrent and distributed systems. In existing languages, multi-object coordination is expressed in terms of explicit communication protocols such as two-phase commit; it is not possible to express coordination patterns independent of their implementation. The inability to abstract over multi-object coordination results in low level speci cation and reasoning. As a consequence, it is not possible to compose multiple coordination patterns without changing their implementation. Moreover, it is di cult to modify and customize the implementation of coordination patterns since the involved protocols are hard-wired into applications. Our approach is to express coordination patterns in the form of multi-object constraints. A multi-object constraint maintains certain properties such as temporal ordering and atomicity associated with invocations processed by a group of objects. Multi-object constraints are speci ed abstractly and independent of the protocols required to implement the enforced properties. A multi-object constraint restricts the freedom of objects to process invocations: whether or not an object may process an invocation depends on the current status and invocation history of a group of objects. Enforced restrictions capture a large class of multi-object coordination schemes. Consider the following examples:

Lecture Notes in Computer Science, 2002

We present a theory of may testing for asynchronous calculi with locality and no name matching. L... more We present a theory of may testing for asynchronous calculi with locality and no name matching. Locality is a non-interference property that is common in systems based on object-paradigm. Concurrent languages such as Join and Pict disallow name matching, which is akin to pointer comparison in imperative languages, to provide for an abstract semantics that would allow useful program transformations.

Proceedings of the 7th International Conference on Principles and Practice of Programming in Java, 2009

The problem of programming scalable multicore processors has renewed interest in message-passing ... more The problem of programming scalable multicore processors has renewed interest in message-passing languages and frameworks. Such languages and frameworks are typically actororiented, implementing some variant of the standard Actor semantics. This paper analyzes some of the more significant efforts to build actor-oriented frameworks for the JVM platform. It compares the frameworks in terms of their execution semantics, the communication and synchronization abstractions provided, and the representations used in the implementations. It analyzes the performance of actor-oriented frameworks to determine the costs of supporting different actor properties on JVM. The analysis suggests that with suitable optimizations, standard Actor semantics and some useful communication and synchronization abstractions may be supported with reasonable efficiency on the JVM platform.

Proceedings of the 1986 SIGPLAN workshop on Object-oriented programming -, 1986

Page 1. -5s An Overview of Actor Languages Gul Agha ... As in other object-oriented languages, ac... more Page 1. -5s An Overview of Actor Languages Gul Agha ... As in other object-oriented languages, actors en-capsulate procedural and declarative information into a single entity. Primitive actor languages are based on a pure message-passing semantics. ...

Object-oriented concurrent programming, 1987