Abstract: Active objects are an attractive method of introducing concurrency into Java-like languages by decoupling method execution from invocation. In this paper, we show how ownership is used in the Java [14] subset language CoJava [17] to prevent deadlock associated with active object method calls. This approach builds on existing type-based approaches that eliminates data races and data-based deadlock in concurrent systems. The novel addition is the use of ownership to organize active objects, thus preventing deadlock from arising when objects are allowed to block awaiting responses from others.Typechecking is used to prevent threads from sharing mutable data, thus CoJava is free of data races and data-based deadlock. Behavioural deadlock is prevented by the use of promise objects which prevent clients from blocking indefinitely while awaiting responses. Ownership imposes a hierarchy on active objects; this allows owners to safely block while waiting for responses from owned objects. The paper also discusses the implications of this approach to specification with JML, formal reasoning about programs, and the consequences to runtime assertion checking.

Abstract: The Proactive Parallel Suite offers multiple layers of abstraction for parallel and distributed applications which include both programming and the environment/deployment abstraction layers At the core of ProActive's programming abstractions are active objects with transparent futures and wait-by-necessity Other abstractions offered by ProActive, such as typed groups , algorithmic skeletons , and hierarchical distributed components among others; are constructed on top of active objects This pluralism of abstractions offers programmers a wide choice of expressiveness for coding parallel and distributed applications Additionally, an environment/deployment layer offers abstractions that simplify the interaction with the infrastructure A deployment descriptor and a super-scheduler abstractions manage deployment of application on distributed resources, while the IC2D tool provides an abstraction to monitor debug and profile parallel and distributed applications

Abstract: ions { Action ... -> ... State ... -> ... ... } Class declarations represent a template for the set of active or non-active objects of the system. In the case of active objects the states and transitions associated to class are used to describe the dynamic behaviour of the corresponding objects. A state machine (with its events queue) is associated to each active object of the system. Nonactive objects play the role of "interfaces" towards the outside of the system, and can only be the target of signals. A system is in the end constituted by static set of objects (no dynamic object creation), and it must be an “input closed” system, i.e. the input/stimulating source must modelled as an active object interacting with the rest of the system (e.g. modelling a service). At least one active object must be defined. The abstraction rules do not play any role from the point of view of the ground behavioural semantics of the model under analysis; they define instead what we are interested to observe w.r.t. the overall system behaviour. From this point of view their role is essential for constructing trace minimizations of the graph illustrating all the possible system evolutions, and for verifying system properties through model checking.

Abstract: A remote execution agent, having low-latency access to the platform, receives from a remote application, across a communication channel imposing a round-trip delay, a plurality of invocation control directives. The remote execution agent invokes operations for execution on the platform in response to the invocation control directives, and aggregates results from the operations, returning the aggregated results to the application. In this manner, overhead such as communication round-trip delay, context switching, and the like, is reduced, compared to the application sending separate operation invocation requests to the platform and receiving the results of each. The remote execution agent manages operation results, such as passing results from a prior operation as parameters for a later one. In some embodiments, the invocation control directives include conditional operation invocation and branching.

Abstract: A method of automatically classifying a concurrency object includes intercepting a call that is configured to create the concurrency object. Concurrency type information for the concurrency object is identified based on the call. The type information indicates whether the concurrency object is a lock object or a synchronization object. The concurrency type information is associated with the concurrency object.

Abstract: Analysis of object flow during execution of individual instructions of a method within an object-oriented application provides information regarding the creation and flow of objects during an invocation of the method. This analysis information is used to track where objects enter an invocation of the method and track their path during the execution of the method. The operand stack, register, and local variables references to the objects are tracked as each instruction in the method is executed. Where objects are passed to elements outside of the method invocation is tracked as well. This tracking of object flow uses an iterative data-flow analysis. If an object is passed to the method or created within the method, the embodiments described herein may be used to determine where that object can go from that point onwards, whether to other method invocations, arrays, or data fields within the application.

Abstract: Object remoting middleware greatly facilitates creating distributed, object-oriented systems. However, developers face many situations in which a middleware’s invocation and message processing architecture fails to fully support all their requirements. This problem is caused, for instance, by limitations in realising certain invocation styles (e.g., one-way and two-way conversations) on top of a shared processing infrastructure, in adding extensions to invocation handling (i.e., add-on services such as security and inspection), and in bypassing selected steps in the invocation handling to balance resource consumption and invocation performance. Often, these limitations are caused by design and implementation decisions taken early when crafting the middleware framework. To better explain the needed decision making, and help developers to apply adaptations or guide the selection of alternatives, we present a pattern language that captures the essentials of invocation and message processing in object remoting middleware. We also outline instantiations of the patterns and their relationships in existing middleware frameworks.

Abstract: Remote method invocation is a distributed object model for the Java programming language that making distributed objects easy to implement and tousle. Remote method invocation applications are often comprised of two separate programs: a Server and a Client. A typical server application creates a number of remote objects, makes references to those remote objects accessible, and waits for clients to invoke methods on those remote objects. In view of the needs of the organization’s business and cross-platform of the system, the distributed object technology and component technology based on the java platform is an ideal choice of the large-scale distributed application system of the development of the enterprise. With respect to the current popular web-based distributed application system, from the point of the software design, this article puts forward the distributed architecture based on the java remote method invocation technology, and in the actual design and development have got more satisfactory results.

Abstract: Futures enable an efficient and easy to use programming paradigm for distributed applications. A natural way to benefit from distribution is to perform asynchronous invocations to methods or services. Upon invocation, a request is en-queued at the destination side and the caller can continue its execution. But a question remains: ``what if one wants to manipulate the result of an asynchronous invocation?'' First-class futures provide a transparent and easy-to-program answer: a future acts as the placeholder for the result of an asynchronous invocation and can be safely transmitted between processes while its result is not needed. Synchronization occurs automatically upon an access requiring the result. As references to futures disseminate, a strategy is necessary to propagate the result of each request to the processes that need it. This report studies the efficient transmission of results: it presents three main strategies in a semi-formal manner, and provides a cost analysis with some experiments to determine the efficiency of each strategy.

Abstract: Efficient modeling of delay conditions is a critical requirement of modern discrete-event simulation software. In this article four forms of delay are discussed: time-based, state-based, compound combinations of time-based and state-based, and user-managed. Most of the algorithms described are those used by the SLX simulation language. An informal survey of SLX users provides many examples of the demands placed on delay mechanisms and the resultant performance of the SLX models.

Abstract: In this paper the problem of dynamic manipulation of active objects by throwing is studied. Here active object means a multi-body object that can actively move its body parts. The prime reason for selecting this problem is existence of conceptual analogy between it and dynamic walking. The second reason is theoretical attraction in addition to its possible practical applications for manipulation of active objects in space or in micro scales. First the task is decomposed into three distinct phases and it is mathematically modeled. Main constraints such as requirement to hold dynamic grasp are also derived and mapped into the manipulator's configuration space. Then the task is formulated as an optimization problem and a proper cost function in the manipulator's configuration space is presented. Finally this optimization problem is solved for obtaining appropriate trajectories of manipulator's joints in addition to that of the active object. Simulation results in ADAMS verify the developed formulations.

Abstract: To support real-time properties, mobile real-time operating system (RTOS) platforms have added to their classical cyclic executive model more flexible concurrency paradigms based on threads and preemptive priority-based scheduling algorithms. However, in newer mobile RTOS, the concurrency model is also going back to prior cooperative multi-tasking models similar to cyclic executives (based on active objects). This paper presents the concurrency model of a very popular mobile RTOS platform, as Symbian, that contains both concurrency models. This OS has been chosen for its popularity in the market and due to the fact that it includes both concurrency models with real-time support. The traditional AOM (Active Object Model) paradigm is taken in the personal embedded device's community as a means to simplify the interface given to programmers; no usage of synchronization primitives is required. This paper discusses how a combined pattern would take advantage of both worlds: AOM and thread based execution models; it allows using AOM-based programming inside threads in real-time environments.

Abstract: This paper proposes a design of detection terminal that adopts the embedded operating system and the high performance processor for active object based on GPRS network. It transmits the captured image processed by detection algorithm to users’ mobile telephone by means of MMS, SMS or email. In this paper, the design of the terminal is discussed in detail including hardware design, software design and an object detection algorithm based on the judgment by zone statistic of DC coefficients. The outcome of experiment verifies the design’s reliability, stability and correctness.