Showing papers on "Distributed object published in 2009"

Embedding standard distributed object-oriented middlewares in wireless sensor networks

Abstract: This paper provides an analysis of the design space available to middleware developers in the context of wireless sensor networks (WSN). We identify the weaknesses of current communication abstraction layers and propose alternative implementation techniques that preserve most of the useful features but minimize the implementation cost in resource constrained wireless sensor nodes. Our proposal includes a whole WSN development framework based on standard distributed objects and a set of specific services designed to support highly dynamic and scalable WSN applications. Copyright © 2007 John Wiley & Sons, Ltd.

QuO's runtime support for quality of service in distributed objects

Abstract: Most distributed applications are brittle; they work in a limited environment and cannot adapt to changes in this environment. Making these applications less brittle is a complex engineering task that is hard for specific application areas and even harder to generalize. The Quality Objects (QuO) project offers a framework for creating applications that adapt to different Quality of Services (QoS) offered by the underlying resources. QuO offers several layers of tools for creating adaptive distributed applications using the familiar CORBA development process of code generators and runtime support libraries. In this paper we describe the QuO Runtime and the components it uses to maintain and adapt to QoS. The QuO Runtime is the base functionality on which QuO code generators specialize for a specific adaptive application. The QuO Runtime handles much of the complexity of collecting, organizing, and acting on changing QoS, thus reducing the burden for application developers.

Utilizing object-object and object-scene context when planning to find things

Abstract: In this paper, our goal is to search for a novel object, where we have a prior map of the environment and knowledge of some of the objects in it, but no information about the location of the specific novel object. We develop a probabilistic model over possible object locations that utilizes object-object and object-scene context. This model can be queried for any of over 25,000 naturally occurring objects in the world and is trained from labeled data acquired from the captions of photos on the Flickr website. We show that these simple models based on object co-occurrences perform surprisingly well at localizing arbitrary objects in an office setting. In addition, we show how to compute paths that minimize the expected distance to the query object and show that this approach performs better than a greedy approach. Finally, we give preliminary results for grounding our approach in object classifiers.

Behavioural Models for Distributed Fractal Components

Abstract: This paper presents a formal behavioural specification framework for specifying and verifying the correct behaviour of distributed Fractal components. The first contribution is a parameterised and hierarchical behavioural model called pNets that serves as a low-level semantic framework for expressing the behaviour of various classes of distributed languages and as a common internal format for our tools. Then, we use this model to define the generation of behavioural models for applications ranging from sequential Fractal components, to distributed objects, and finally to distributed components. Our models are able to characterise both functional and non-functional behaviours and the interaction between the two concerns. Finally, this work has resulted in the development of tools allowing the non-expert programmer to specify the behaviour of his components and (semi)automatically verify properties of his application.

Dynamic demand calculation using captured data of real life objects

Abstract: Methods and system for managing demand for an object includes capturing information about the object through a mobile device associated with a user. The mobile device is configured to capture information about the object that include one or more of a spatial, temporal, topical and social attributes of the object. The identity of the object is verified and validated using this metadata captured by the user through the device from the real world object or its proxy. Upon successful verification and validation, the object and its metadata are automatically added to a wish list of the user. An aggregate list is generated using the attributes and metadata of the object from a plurality of users. The aggregate list defines a source of demand for the object. The object is tracked as it progresses through various phases of ownership cycle using dynamic demand calculations based on the information associated with the objects, the users and the aggregate lists.

Asynchronous distributed garbage collection for replicated storage clusters

Abstract: A method may be performed by a device of a group of devices in a distributed data replication system. The method may include storing objects in a data store, at least one or more of the objects being replicated with the distributed data replication system, and conducting a scan of the objects in the data store. The method may further include identifying one of the objects as not having a reference pointing to the object, storing a delete negotiation message as metadata associated with the one of the objects, and replicating the metadata with the delete negotiation message to one or more other devices of the group of devices.

Chemical Programming of Future Service-oriented Architectures

Abstract: Service-based infrastructures are shaping tomorrow’s distributed computing systems by allowing the design of loosely-coupled distributed applications based on the composition of services spread over a set of resources available on the Internet. Compared to previous approaches such as remote procedure call, distributed objects or components, this new paradigm makes feasible the loose coupling of software modules, encapsulated into services, by allowing a late binding to them at runtime. In this context, an important issue is how to express the composition of services while keeping this loosely-coupled property. Different approaches have been proposed to express services composition, mostly using specialized languages. This article presents and explore an unconventional new approach for service composition based on a programming language, inspired by a chemical metaphor, called the High-Order Chemical Language (HOCL). The proposed approach provides a very abstract and generic way of programming service composition thanks to the high-order property of HOCL. We illustrated this approach by applying it to a simple example that aims at providing a travel organizer service based on the composition of several basic and smaller services.

System, method, and computer program for determining whether object is genuine or fake in metaverse

Abstract: A server computer connected to a plurality of client computers through a network and controls objects in a Metaverse accessed by the client computers. The server computer includes: a storage unit for storing, as object information for a certain object, an object ID specifying the object and, associated with the object ID, authenticity information indicating that the object is; a communication unit for communicating with each of the client computers; and an enquiry unit for, upon receipt of an enquiry request including an object ID to enquire about the object of the object ID from a certain client computer, causing the communication unit to transmit authenticity information of the object ID to the communication unit, when the authenticity information of the object ID is stored in the storage unit.

Multiple-view object recognition in band-limited distributed camera networks

Abstract: In this paper, we study the classical problem of object recognition in low-power, low-bandwidth distributed camera networks. The ability to perform robust object recognition is crucial for applications such as visual surveillance to track and identify objects of interest, and compensate visual nuisances such as occlusion and pose variation between multiple camera views. We propose an effective framework to perform distributed object recognition using a network of smart cameras and a computer as the base station. Due to the limited bandwidth between the cameras and the computer, the method utilizes the available computational power on the smart sensors to locally extract and compress SIFT-type image features to represent individual camera views. In particular, we show that between a network of cameras, high-dimensional SIFT histograms share a joint sparse pattern corresponding to a set of common features in 3-D. Such joint sparse patterns can be explicitly exploited to accurately encode the distributed signal via random projection, which is unsupervised and independent to the sensor modality. On the base station, we study multiple decoding schemes to simultaneously recover the multiple-view object features based on the distributed compressive sensing theory. The system has been implemented on the Berkeley CITRIC smart camera platform. The efficacy of the algorithm is validated through extensive simulation and experiments.

Asynchronous sequential processes

Abstract: Deterministic behavior for parallel and distributed computation is rather difficult to ensure. To reach that goal, many formal calculi, languages, and techniques with well-defined semantics have been proposed in the past. But none of them focused on an imperative object calculus with asynchronous communications and futures. In this article, an object calculus, Asynchronous Sequential Processes (ASP), is defined, with its semantics. We prove also confluence properties for the ASP calculus. ASPs main characteristics are asynchronous communications with futures, and sequential execution within each process. This paper provides a very general and dynamic property ensuring confluence. Further, more specific and static properties are derived. Additionally, we present a formalization of distributed components based on ASP, and show how such components are used to statically ensure determinacy. This paper can also be seen as a formalization of the concept of futures in a distributed object setting.

Research on Distributed Architecture Based on SOA

Abstract: In essence, Service Oriented Architecture (SOA) is distributed and shall not have any centralized control point. Any application can access an SOA network for interaction as long as it complies with the corresponding standards. A centralized SOA architecture can also be regarded as a part of SOA. This paper gives a general overview of the fundamental principles, features, and core technologies of distributed SOA, analyzes the integration of distributed object technologies and Web technology, and describes the difference between distributed SOA and centralized SOA. With the previous as a basis, this paper discusses the function and implementation of SOA in the distributed architecture, proposes an SOA-based distributed multi-layer architecture and an application integration frame realized via J2EE. This application integration frame can connect any distributed application without restriction and support data and function sharing among applications,thus simplifying the implementation of the functions at various layers and providing better maintainability and scalability.

Remote Batch Invocation for Compositional Object Services

Abstract: Because Remote Procedure Calls do not compose efficiently, designers of distributed object systems use Data Transfer and Remote Facade patterns to create large-granularity interfaces, hard-coded for particular client use cases. As an alternative to RPC-based distributed objects, this paper presents Remote Batch Invocation (RBI), language support for explicit client-defined batches. A Remote Batch statement combines remote and local execution: all the remote code is executed in a single round-trip to the server, where all data sent to the server and results from the batch are communicated in bulk. RBI supports remote blocks, iteration and conditionals, and local handling of remote exceptions. RBI is efficient even for fine-grained interfaces, eliminating the need for hand-optimized server interfaces. We demonstrate RBI with an extension to Java, using RMI internally as the transport layer. RBI supports large-granularity, stateless server interactions, characteristic of service-oriented computing.

Virtual machine tool interface for tracking objects

Abstract: Disclosed is a method and computer program product to track allocation of a plurality of objects in a heap. A data processing system, during an object allocation, prevents an object from being moved to another place in memory or being deleted. The data processing system prevents such activity concurrently with garbage collection on a second object not currently being allocated. The data processing system notifies a profiler of object information based on the object allocation via a callback function, wherein object information is a one-to-one mapping of the object address. The data processing system revives garbage collector processing of the object.

Javanaise: distributed shared objects for internet cooperative applications

Abstract: We have implemented a service for the development of distributed cooperative applications on the Internet. This service provides the abstraction of a distributed shared object space. The objects managed by the applications are transparently shared between the client nodes, so that the application developer can program as in a centralized setting. It consists of a set of system classes and a proxy generator implemented in the Java environment. The service and the applications that use it are dynamically deployed to client nodes at run-time, thanks to Java mobile code. Our system support relies on object replication on the client nodes. Logically related objects are grouped in clusters, the cluster being the unit of sharing, replication and coherence. One of the main advantages of our proposal is that the object clustering policy is tightly coupled with the application code, thus ensuring locality, while keeping clustering transparent to the application programmer.

Delayed Instantiation Bulk Operations for Management of Distributed, Object-Based Storage Systems

Abstract: : The basic distributed, object-based storage system model lacks features for storage management. This work presents and analyzes a strategy for using existing facilities to implement atomic operations on sets of objects. These bulk operations form the basis for managing snapshots (read-only copies) and forks (read-write copies) of portions of the storage system. Specifically, we propose to leverage the access control capabilities, and annotations at the metadata server, to allow for selective clone and delete operations on sets of objects. In order to act upon a set of objects, a bulk operation follows these steps. First, the metadata server accepts the operation, contacts the storage nodes to revoke outstanding capabilities on the set of objects, and retains a record of the operation and the affected set of objects. At this point, clients can make no changes to existing objects since any capabilities they hold will be rejected by storage nodes. Second, when clients subsequently contact the metadata server to access affected objects (e.g., acquire fresh capabilities), any records of bulk operations are consulted. Finding that a client is accessing an affected object, the metadata server will take the necessary steps to enact the uninstantiated operation before responding to the client request. This eventual enforcement of operation semantics ensures compliance with the operation's intent but delays the corresponding work until the next client access. With appropriate background instantiation, the work of instantiating bulk operations can be hidden from clients.

Trail: A distance-sensitive sensor network service for distributed object tracking

Abstract: Distributed observation and control of mobile objects via static wireless sensors demands timely information in a distance-sensitive manner: Information about closer objects is required more often and more quickly than that of farther objects. In this article, we present a wireless sensor network protocol, Trail, that supports distance-sensitive tracking of mobile objects for in-network subscribers upon demand. Trail achieves a find time that is linear in the distance from a subscriber to an object, via a distributed data structure that is updated only locally when the object moves. Notably, Trail does not partition the network into a hierarchy of clusters and clusterheads, and as a result Trail has lower maintenance costs, is more locally fault tolerant, and it better utilizes the network in terms of load balancing and minimizing the size of the data structure needed for tracking. Moreover, Trail is reliable and energy efficient, despite the network dynamics that are typical of wireless sensor networks. Trail can be refined by tuning certain parameters, thereby yielding a family of protocols that are suited for different application settings such as rate of queries, rate of updates, and network size. We evaluate the performance of Trail by analysis, simulations in a 90 × 90 sensor network, and experiments on 105 Mica2 nodes in the context of a pursuer-evader control application.

Content repository implemented in a network storage server system

Abstract: A network storage server system includes a distributed object store, a presentation layer, a metadata subsystem, and a content management subsystem. The object store has no namespace and provides location-independent addressing of data objects. The presentation layer provides multiple interfaces for accessing data stored in the object store, including a NAS interface and a Web Service interface, and provides at least one namespace for accessing data via the NAS interface or the Web Service interface. The Web Service interface allows access to stored data via the namespace or without using the namespace (“raw object” access). The metadata subsystem stores user-specified and/or system-generated metadata relating to data objects and allows data objects to be identified and retrieved by searching on the metadata. The content management subsystem autonomously manages lifecycles of data objects according to user-specified policies, based on metadata associated with the data objects and tracked by the metadata subsystem.

A framework for advanced home service design and management

Abstract: In this paper a distributed object-oriented framework (DOBS, Distributed Object Based Services) for home service design is presented. This framework eases the development of advanced services able to run in a variety of devices ranging from tiny wireless sensors to powerful multimedia servers. Special emphasis will be made on DOBS main features, its core components, the offered common services and the toolchain that has been developed to allow users and manufacturers to easily build advanced DOBS compliant services.

Mobile unit communication via a network

Abstract: Integrated imaging and GPS network monitors remote object movement. Browser interface displays objects and detectors. Database stores object position movement. Cameras detect objects and generate image signal. Internet provides selectable connection between system controller and various cameras according to object positions.

Object identification system, wireless internet system having the same and method servicing a wireless communication based on an object using the same

Abstract: An objection identification system includes a virtual object database (DB) in which a plurality of virtual objects is stored and a target virtual object. The virtual objects includes an attribute data set including an attribute value of a real object and a service data set including a service data related to the real object. The target virtual object determining part receives a real object identification data of a target real object previewed by a terminal to compute an attribute value of the target real object, and determines a virtual object having an attribute value matched to an attribute value of the computed target real object of plural virtual objects stored in the virtual object DB as a target virtual object. In this case, a service data included in the service data set of the determined target virtual object by the target virtual object determining part is transmitted to the terminal. Thus, it may provide Internet type based on a real object over a conventional Internet concept handing a virtual object. In addition, easy and intuitive wireless Internet environment may be realized, and various Internet service and new higher value-added business may be created.

Run-time monitoring of distributed applications

Abstract: In this paper we present a method to perform run-time monitoring of distributed applications built on top of a distributed object oriented processing environment. For this, we instrument the code at the compilation time in order to send notifications to an Observer when relevant events occur in the system; the instrumentation is done in an automated manner, requiring a minimum of programmer interactions. One advantage of our run-time monitoring approach is that it does not hinder the development process already adopted. In our proposal, the choice of the information to select for observation is made simple by the definition of events which are generic and useful for all distributed applications; the user does not need to specify them. We apply our run-time monitoring method to a telecommunication service implemented on top of the distributed processing environment CORBA Orbix™ from IONA.

A Verification System for Distributed Objects with Asynchronous Method Calls

Abstract: We present a verification system for Creol, an object-oriented modeling language for concurrent distributed applications. The system is an instance of KeY, a framework for object-oriented software verification, which has so far been applied foremost to sequential Java. Building on KeY characteristic concepts, like dynamic logic, sequent calculus, explicit substitutions, and the taclet rule language, the system presented in this paper addresses functional correctness of Creol models featuring local cooperative thread parallelism and global communication via asynchronous method calls. The calculus heavily operates on communication histories which describe the interfaces of Creol units. Two example scenarios demonstrate the usage of the system.

Metacomputing with Federated Method Invocation

Abstract: Six generations of RPC systems can be distinguished including Federated Method Invocation (FMI) presented in this paper. Some of them—CORBA, Java RMI, and Web/Globus services—support distributed objects. However, creating object wrappers implementing remote interfaces doesn’t have a great deal to do with object-oriented distributed programming. Distributed objects developed that way are usually ill-structured with missing core objectoriented traits: encapsulation, instantiation, inheritance, and network-centric messaging by ignoring the real nature of networking. A distributed system is not just a collection of distributed objects—it’s the network of objects. In particular, the object wrapping approach does not help to cope with network-centric messaging, invocation latency, object discovery, dynamic object federation, fault detection, recovery, partial failure, etc. The JiniTM architecture does not hide the network; it allows the programmer to deal with the network reality: leases for network resources, distributed events, transactions, and discovery/join protocols to form federations. A service-oriented architecture presented in this paper implements FMI to support metaprogramming. The triple Command pattern implantation uses Jini service management and Rio dynamic provisioning for managing the network of FMI objects.

Introduction to Distributed Systems

Abstract: Computing has passed through many transformations since the birth of the first computing machines. Developments in technology have resulted in the availability of fast and inexpensive processors, and progresses in communication technology have resulted in the availability of lucrative and highly proficient computer networks. Among these, the centralized networks have one component that is shared by users all the time. All resources are accessible, but there is a single point of control as well as a single point of failure. The integration of computer and networking technologies gave birth to new paradigm of computing called distributed computing in the late 1970s. Distributed computing has changed the face of computing and offered quick and precise solutions for a variety of complex problems for different fields. Nowadays, we are fully engrossed by the information age, and expending more time communicating and gathering information through the Internet. The Internet keeps on progressing along more than a few magnitudes, abiding end systems increasingly to communicate in more and more different ways. Over the years, several methods have evolved to enable these developments, ranging from simplistic data sharing to advanced systems supporting a multitude of services. This article provides an overview of distributed computing systems. The definition, architecture, characteristics of distributed systems and the various distributed computing fallacies are discussed in the beginning. Finally, discusses client/server computing, World Wide Web and types of distributed systems.

Dynamic Symbolic Execution for Testing Distributed Objects

Abstract: This paper extends dynamic symbolic execution to distributed and concurrent systems. Dynamic symbolic execution can be used in software testing to systematically identify equivalence classes of input values and has been shown to scale well to large systems. Although mainly applied to sequential programs, this scalability makes it interesting to consider the technique in the distributed and concurrent setting as well. In order to extend the technique to concurrent systems, it is necessary to obtain sufficient control over the scheduling of concurrent activities to avoid race conditions. Creol, a modeling language for distributed concurrent objects, solves this problem by abstracting from a particular scheduling policy but explicitly defining scheduling points. This provides sufficient control to apply the technique of dynamic symbolic execution for model based testing of interleaved processes. The technique has been formalized in rewriting logic, executes in Maude, and applied to non-trivial examples, including an industrial case study.

Staying in bounds: Contextual constraints on object-file coherence.

Abstract: Coherent visual perception necessitates the ability to track distinct objects as the same entities over time and motion. Calculations of such object persistence appear to be fairly automatic and constrained by specific rules. We explore the nature of object persistence here within the object-file framework; object files are mid-level visual representations that track entities over time and motion as the same persisting objects and store and update information about the objects. We present three new findings. First, objects files are constrained by the principle of “boundedness”; persisting entities should maintain a single closed contour. Second, object files are constrained by the principle of “containment”; all the parts and properties of a persisting object should reside within, and be connected to, the object itself. Third, object files are sensitive to the context in which an object appears; the very same physical entity that can instantiate object-file formation in one experimental context cannot in another. This contextual influence demonstrates for the first time that object files are sensitive to more than just the physical properties contained within any given visual display.

Programming patterns for logtalk parametric objects

Abstract: This paper presents a survey of programming patterns for Logtalk parametric objects. A parametric object is an object whose identifier is a compound term containing logical variables. These variables play the role of object parameters. Object predicates can be coded to depend on the parameter values. Parametric objects are a common feature of some other object-oriented logic programming languages and Prolog object-oriented extensions. Logtalk extends the usefulness of parametric objects by introducing the concept of object proxies. An object proxy is a compound term that can be interpreted as a possible instantiation of the identifier of a parametric object. Object proxies, when represented as predicate facts, allow application memory footprint to be minimized while still taking full advantage of Logtalk object-oriented features for representing and reasoning with taxonomic knowledge.

dRuby and Rinda: implementation and application of distributed Ruby and its parallel coordination mechanism

Abstract: The object-oriented scripting language Ruby is admired by many programmers for being easy to write in, and for its flexible, dynamic nature. In the last few years, the Ruby on Rails web application framework, popular for its productivity benefits, has brought about a renewed attention to Ruby for enterprise use. As the focus of Ruby has broadened from small tools and scripts, to large applications, the demands on Ruby's distributed object environment have also increased, as has the need for information about its usage, performance and examples of common practices. dRuby and Rinda were developed by the author as the distributed object environment and shared tuplespace implementation for the Ruby language, and are included as part of Ruby's standard library, dRuby extends method calls across the network while retaining the benefits of Ruby. Rinda builds on dRuby to bring the functionality of Linda, the glue language for distributed co-ordination systems, to Ruby. This article discusses the design policy and implementation points of these two systems, and demonstrates their simplicity with sample code and examples of their usage in actual applications. In addition to dRuby and Rinda's appropriateness for prototyping distributed systems, this article will also demonstrate that dRuby and Rinda are building a reputation for being suitable infrastructure components for real-world applications.

Transparent IP Cores Integration Based on the Distributed Object Paradigm

Abstract: Heterogeneous system architectures are currently the main platform on which an ever increasing number of innovative applications (i.e. smart home or ambient intelligence applications) rely. When designing these complex systems, one of the most time-consuming tasks is the definition of the communication interfaces between the different components through a number of scattered heterogeneous processing nodes. That is not only a complex task, but also very specific for a particular implementation, which may limit the flexibility of the system, and makes the solutions difficult to reuse. In this chapter, we describe how to provide a unified abstraction for both hardware and software components that have to cooperate with each other, independently of their implementation and their location. Based on this abstraction, we define a low-overhead system-wide communication architecture that offers total communication transparency between any kind of components. Since the architecture is highly compatible with standard objectoriented distributed software systems, it also enables seamless interaction with any other kind of external network.