VTechWorks staff will be away for the Thanksgiving holiday beginning at noon on Wednesday, November 27, through Friday, November 29. We will resume normal operations on Monday, December 2. Thank you for your patience.

Browsing by Author "Mukherji, Manibrata"

Now showing 1 - 4 of 4
  • Thumbnail Image
    ACT++ 2.0: A Class Library for Concurrent Programming in C++ Using Actors
    Kafura, Dennis G.; Mukherji, Manibrata; Lavender, R. Gregory (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    ACT++ 2.0 is the most recent version of a class library for concurrent programming in C++. The underlying model of concurrent computation is the Actor model. Programs in ACT++ consist of a collection of active objects called actors. Actors execute concurrently and cooperate by sending request and reply messages. An agent, termed the behavior of an actor, is responsible for processing a single request message and for specifying a replacement behavior which processes the next available request message. One of the salient features of ACT++ is its ability to handle the Inheritance Anomaly---the interference between the inheritance mechanism of object-oriented languages and the specification of synchronization constraints in the methods of a class---using the notion of behavior sets. ACT++ has been implemented on the Sequent Symmetry multiprocessor using the PRESTO threads package.
  • Thumbnail Image
    The Design and Implementation of Concurrent Input/Output Facilities in ACT++ 2.0
    Kafura, Dennis G.; Mukherji, Manibrata (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    ACT++ 2.0 is the most recent version of a class library for concurrent programming in C++. Programs in ACT++ consist of a collection of active objects called actors. Actors execute concurrently and cooperate by sending request and reply messages. An agent, termed the behavior of an actor, is responsible for processing a single request message and for specifying a replacement behavior which processes the next available request message. One of the salient features of ACT++ is its realization of I/O as an actor operation. A special type of actor, called an interface actor, provides a high level interface for a file. Interface actors are sent request messages whenever I/O is necessary and can also transparently perform asynchronous I/O. ACT++ has been implemented on the Sequent Symmetry multiprocessor using the PRESTO threads package.
  • Thumbnail Image
    The implementation of ACT++ on a shared memory multiprocessor
    Mukherji, Manibrata (Virginia Tech, 1992)
    ACT++ is a programming environment in which concurrent programs can be written in C++. The underlying model of concurrent computation is the Actor model. Programs in ACT++ consist of a collection of active objects called actors. Several actors execute simultaneously and cooperate with each other by sending request and reply messages. Request messages are processed by agents called behaviors of the actor. Each behavior of an actor is responsible for specifying a replacement behavior which processes the next available request message. One of the salient features of ACT++ is its ability to handle the Inheritance Anomaly - the interference between the inheritance mechanism of C++ and the specification of synchronization constraints in the methods of a class - using the notion of behavior sets. Another feature of ACT++ is its realization of I/O as an actor operation. A special type of actor, called an interface actor, provides a high level interface for a particular device which is sent request messages whenever I/O is necessary. The interface actors can also transparently perform asynchronous I/O. ACT++ has been successfully implemented on the Sequent Symmetry multiprocessor using the PRESTO lightweight threads package.
  • Thumbnail Image
    Specification of multi-object coordination schemes using coordinating environments
    Mukherji, Manibrata (Virginia Tech, 1995)
    This dissertation proposes a coordination model for concurrent object-oriented programming languages (COOPLs). The model, termed Coordinating Environments (CEs), prescribes coordination among concurrently executing objects that compute as a group to achieve a common task or goal. The model represents coordination constraints and coordinating actions in a structured manner by grouping them into syntactic entities called Coordinating Behaviors (CBs). A group coordinator, termed a Coordinating Environment object (CE object), reduces the intrusive effects of coordination by transparently observing message-acceptance and method-termination events in components and triggering one or more coordinating actions on them. The conflict between the issues of information hiding (for better encapsulation) and information externalization (to enable coordination) is partially resolved by requiring components to provide state-interrogation methods. This allows a CE object to obtain and use local state information of components for the purpose of coordination. A method for developing reusable coordination specifications in C++ is described. The method consists of two major steps: defining an abstract Coordinating Environment class (CE class) to capture the coordination problem in an abstract manner and then defining a concrete CE class (a subclass of the abstract CE class) to map the coordination effect embodied in the abstract CE class to a specific coordination problem. The method makes extensive use of the inheritance, polymorphism, and dynamic binding mechanisms of C++. Seven coordination problems, ranging from the coordination of a panel of buttons to the coordination of a multi-car elevator system, are specified to illustrate the method. A detailed design of the major components of the CEs model is also described. The issues involved in using formal abstractions for coordinating process-agents specified in the Calculus of Communicating Systems (CCS) are also investigated. Using CCS directly to specify coordination has two weaknesses. First, coordination is modeled at a very low level in CCS by making agents engage in explicit communications. Such low-level specifications are poor candidates for specifying designs of software components that must satisfy software engineering criteria such as separation of concerns and reusability. Second, when the computation steps of the composition of agents are determined using the Expansion Law of CCS, many terms are generated that represent incorrect coordination sequences among the agents. Thus, the need for a calculus that addresses both the issue of concurrency and communication and the issue of effectively managing the communication among concurrent agents (that is, coordination) is identified, and the Calculus of Coordinating Environments (CCE) is proposed as a first step towards satisfying that need.