Search

Erasure coding is widely used in building reliable distributed object storage systems despite its high repair cost. Regenerating codes are a special class of erasure codes, which are proposed to minimize the amount of data needed for repair. In this paper, we assess how optimal repair can help to improve object storage systems, and we find that regenerating codes present unique challenges: regenerating codes repair at the granularity of chunks instead of bytes, and the choice of chunk size leads to the tension between streamed degraded read time and repair throughput. To address this dilemma, we propose Geometric Partitioning, which partitions each object into a series of chunks with their sizes in a geometric sequence to obtain the benefits of both large and small chunk sizes. Geometric Partitioning helps regenerating codes to achieve 1.85x recovery performance of RS code while keeping degraded read time low.

Most general-purpose distributed storage systems are not designed with near data processing (NDP) in mind. They do not respect semantic data boundaries when writing data, for example splitting a record across servers. This reduces NDP effectiveness by requiring data collation before computation. While semantic data awareness and NDP functions can be retroactively added to existing distributed storage, it is often complex and difficult to accomplish in practice. We propose sharing storage system layout information with data writers so they can adjust data layouts to prevent data alignment issues regardless of the underlying architectures. By doing so, we can simplify NDP implementation by reducing the need for data reassembly, and reduce the need for complex storage system or application extensions. We demonstrate a hinting mechanism on both HDFS with computational block storage and an erasure coded MinIO deployment, reducing data movement by up to 99% when querying CSV data with NDP co-located with the stored data. This was accomplished purely with client side data alignment, no modifications to the server side write paths, and no inter-node collation of data.

Due to the influence of the shooting angle of view and the flight height, the images taken by UAV often have complex backgrounds and contain a large number of small and unevenly distributed objects. In order to solve the problem that it is difficult to accurately locate and recognize small objects in UAV images under complex backgrounds, this paper proposes an multi-scale feature fusion algorithm D-A-FS SSD (Dilated-Attention-Feature Fusion SSD) based on the combination of dilated convolution and attention mechanism. In the process of feature extraction, the receptive field of the feature is expanded through the dilated convolution, which improves the network's feature expression of object distribution and scale difference information. And a attention network is used in our method to effectively suppresse the background information. In the multi-scale detection stage, our method fuses the low-level feature map responsible for detecting small objects with the high-level feature map which have much higher semantic information to improve the recognition accuracy of small objects. Experimental results show that our method effectively improves the accuracy of UAV image object detection.

This demo shows an implementation of distributed object storage over NDN. It demonstrates how to reliably store and distribute data generated from sensors that do not have storage capability or generate large amounts of data. Chipmunk is an NDN based object storage system that leverages metadata that has data names and data locations to enable object storage service in a distributed system.

Data replication is essential in scenarios like geo-distributed datacenters and edge computing. Yet, it poses a challenge for data consistency. Developers either adopt high consistency at the detriment of performance or they embrace low consistency and face a much higher programming complexity. We argue that language abstractions should support associating the level of consistency to data types. We present ConSysT, a programming language and middleware that provides abstractions to specify consistency types, enabling mixing different consistency levels in the same application. Such mechanism is fully integrated with object-oriented programming and type system guarantees that different levels can be mixed only in a correct way.

Knowing the locations of spatially distributed objects is important in many different scenarios (e.g., driving a car and being aware of other road users). In particular, it is critical for preventing accidents with objects that come too close (e.g., cyclists or pedestrians). In this paper, we explore how peripheral cues can shift a user's attention towards spatially distributed out-of-view objects. We identify a suitable technique for visualization of these out-of-view objects and explore different cue designs to advance this technique to shift the user's attention. In a controlled lab study, we investigate non-animated peripheral cues with audio stimuli and animated peripheral cues without audio stimuli. Further, we looked into how user's identify out-of-view objects. Our results show that shifting the user's attention only takes about 0.86 seconds on average when animated stimuli are used, while shifting the attention with non-animated stimuli takes an average of 1.10 seconds.

In this paper, we propose a Region of Interest(ROI) modulated H.264 video encoder system, based on a distributed object detector-tracker framework, for smart camera networks. Locations of objects of interest, as determined by detector-tracker are used to semantically partition each frame into regions assigned with multiple levels of importance. A distributed architecture is proposed to implement the object detector-tracker framework to mitigate the computational cost. Further, a rate control algorithm with modified Rate-Distortion(RD) cost is proposed to determine Quantization Parameter(QP) and skip decision of Macro Blocks based on their relative levels of importance. Our experiments show that, the proposed system achieves upto 3x reduction in bitrate without significant reduction in PSNR of ROI(head-shoulder region of pedestrians). We also demonstrate the trade-off between total computational cost and compression possible with the proposed distributed detector-tracker framework.

Caching is an important aspect of today's web enterprise systems, enhancing performance and reducing access frequency to the backend storage server. However, when implemented as an independent component, such as when using Memcached, access to the remote cache can lead to considerable overhead and delay. Instead, in this paper we propose a cooperative and integrated cache framework where each application server has its own local cache but can also access the caches of other servers. Our solution dynamically distributes objects across caches and requests across servers such that the load is equally distributed across servers and servers find the objects they need for request execution in their local cache most of the time. The challenge is to handle the complex workloads of current e-commerce sites where requests can access more than one object and change the object set they access over time, and different request types access overlapping sets of objects. As such, we look at a whole range of distribution mechanisms and analyze their behavior in detail. We evaluated the various alternatives using the YCSB and RUBiS benchmarks, showing that our approach is applicable in different dynamic workload scenarios and is able to autonomously capture workload changes and adapt instantly.

The goal of this tool demo paper is to demonstrate the features of Atomic RMI 2, a system and tool for distributed programming in Java, extending the popular Java RMI system with support for distributed transactions. A distributed transaction can contain arbitrary code, including any operations on remote objects that must be executed atomically, consistently, and in isolation with respect to any other concurrent transactions. The Atomic RMI 2 package is released with an open source license.

Distributed applications are traditionally developed using separate modules for each component in the distributed system, which can even be written in different programming languages. Those modules react on events such as user input, which are produced by other modules, and may in turn produce new events to be handled by different modules. Thus, most distributed applications are reactive in nature. Distributed event-based data flow makes it is hard to reason about the system and therefore makes the development of distributed systems challenging. In this paper, we present language abstractions for distributed reactive programming easing the development of such applications and supporting various distributed architectures.

The problem. We consider the problem of implementing a consistent replicated object in a partially synchronous message passing distributed system susceptible to process and communication failures. The object is a generic shared resource, such as a data structure, a file, or a lock. The processes implementing the replicated object access it by applying operations to it at unpredictable times and potentially concurrently.1 The object should be linearizable: it should behave as if each operation applied to it takes effect at a distinct instant in time during the interval between its invocation and its response.The main reason for replicating an object is fault tolerance; if a copy of the object becomes inaccessible, the object can still be accessed through the other copies. Another reason for replicating an object is performance; a process that requires the object can access its local copy. The benefit of accessing a local copy, however, must be weighed against the cost of keeping the copies consistent.

The infrastructure beneath a worldwide social network has to continually serve billions of variable-sized media objects such as photos, videos, and audio clips. These objects must be stored and served with low latency and high throughput by a system that is geo-distributed, highly scalable, and load-balanced. Existing file systems and object stores face several challenges when serving such large objects. We present Ambry, a production-quality system for storing large immutable data (called blobs). Ambry is designed in a decentralized way and leverages techniques such as logical blob grouping, asynchronous replication, rebalancing mechanisms, zero-cost failure detection, and OS caching. Ambry has been running in LinkedIn's production environment for the past 2 years, serving up to 10K requests per second across more than 400 million users. Our experimental evaluation reveals that Ambry offers high efficiency (utilizing up to 88% of the network bandwidth), low latency (less than 50 ms latency for a 1 MB object), and load balancing (improving imbalance of request rate among disks by 8x-10x).

Object versioning is the keystone for implementing eventual consistency in modern geo-distributed object storage systems such as Amazon S3. Despite this, the study of implementing object versioning has not been given a lot of attention in either academic or industrial communities. The selection of an implementation method is not considered as an important factor impacting the overall system performance under different workloads.In this paper, we present our study of two methods of implementing object versioning in geo-distributed object storage systems and on how these impact the performance of these systems under different workloads. We propose and analyze the advantages and disadvantages of (1) Write-Repair approach and (2) Read-Repair approach. From our experiments, we found that the choice of approach significantly impacts the performance of storage systems, which in turn impact the performance of applications built on top of these systems.

Transactional memory is an abstraction where concurrent memory accesses are grouped into atomic transactions, similar to database transactions. There are many advantages in using this model instead of conventional ones, such as ease of programming: programmers simply mark code where race conditions may occur and the transactional system takes care to ensure the correctness of the results. This model has proven to be promising for Symmetric Multi-Processing (SMP) machines, however few studies in this area are focused on distributed architectures. These architectures are extremely important nowadays, as they compose a large portion of high performance computing platforms, and because of the trend of more and more computing devices communicating with each other. The main objective of this paper is to propose a domain specific language embedded in Java, for implementing memory transactions that can involve local and distributed objects on a network. This goal was approached both in the language level, allowing the programmer to define composable transactional actions, and in transactional system level, supporting the implementation of the language's abstractions. To validate our model, preliminary measurements of a prototype implementation of the system described here are presented.

APGAS (Asynchronous Partitioned Global Address Space) is a model for concurrent and distributed programming, known primarily as the foundation of the X10 programming language. In this paper, we present an implementation of this model as an embedded domain-specific language for Scala. We illustrate common usage patterns and contrast with alternative approaches available to Scala programmers. In particular, using two distributed algorithms as examples, we illustrate how APGAS-style programs compare to idiomatic Akka implementations. We demonstrate the use of APGAS places and tasks, distributed termination, and distributed objects.

With the widespread use of shared-nothing clusters of servers, there has been a proliferation of distributed object stores that offer high availability, reliability and enhanced performance for MapReduce-style workloads. However, data-intensive scientific workflows and join-intensive queries cannot always be evaluated efficiently using MapReduce-style processing without extensive data migrations, which cause network congestion and reduced query throughput. In this paper, we study the problem of computing data placement strategies that minimize the data communication costs incurred by such workloads in a distributed setting.Our main contribution is a reduction of the data placement problem to the well-studied problem of Graph Partitioning, which is NP-Hard but for which efficient approximation algorithms exist. The novelty and significance of this result lie in representing the communication cost exactly and using standard graphs instead of hypergraphs, which were used in prior work on data placement that optimized for different objectives.We study several practical extensions of the problem: with load balancing, with replication, and with complex workflows consisting of multiple steps that may be computed on different servers. We provide integer linear programs (IPs) that may be used with any IP solver to find an optimal data placement. For the no-replication case, we use publicly available graph partitioning libraries (e.g., METIS) to efficiently compute nearly-optimal solutions. For the versions with replication, we introduce two heuristics that utilize the Graph Partitioning solution of the no-replication case. Using a workload based on TPC-DS, it may take an IP solver weeks to compute an optimal data placement, whereas our reduction produces nearly-optimal solutions in seconds.

Eventual consistency is a relaxed consistency model used in large-scale distributed systems that seek better availability when consistency can be delayed. CRDTs are distributed data types that make eventual consistency of a distributed object possible and non ad-hoc. Specifically, state-based CRDTs achieve this through shipping the entire replica state that is, eventually, merged to other replicas ensuring conver- gence. This imposes a large communication overhead when the replica size or the number of replicas gets larger. In this work, we introduce a decomposable version of state-based CRDTs, called Delta State-based CRDTs (δ-CRDT). A δ-CRDT is viewed as a join of multiple fine-grained CRDTs of the same type, called deltas (δ). The deltas are produced by applying δ-mutators, on a replica state, which are mod- ified versions of the original CRDT mutators. This makes it possible to ship small deltas (or batches) instead of ship- ping the entire state. The challenges are to make the join of deltas equivalent to the join of the entire object in clas- sical state-based CRDTs, and to find a way to derive the δ-mutators. We address this challenge in this work, and we explore the minimal requirements that a communication al- gorithm must offer according to the guarantees provided by the underlying messaging middleware., Project Norte-01-0124-FEDER-000058 is co-financed by the North Portugal Regional Operational Program (ON.2 - O Novo Norte), under the National Strategic Reference Framework (NSRF), through the European Regional Development Fund (ERDF). Funding from the European Union Seventh Framework Program (FP7/2007-2013) with grant agreement 609551, SyncFree project., info:eu-repo/semantics/publishedVersion

This paper proposes a new system for 3D object sharing with multiple clients using networks. Our system aims to support group communication across devices over the same 3D object and puts the annotations with augmented reality automatically. In order to keep putting the annotations during the interaction, we apply the vision-based 3D object tracking algorithm which estimates 3D position and pose of the object just by capturing the object with a single RGB camera. By employing the tracking algorithm robust to viewpoint changes and occlusion, we develop the 3D object sharing system with a desktop as a server and a laptop and a smart phone as clients. We conducted the experiments to show the tracking algorithm is tolerant of interaction and can be applied to various objects with texture.

Graphical User Interfaces (GUI) offers a very flexible interface but require the user's complete visual attention, whereby Tangible User Interfaces (TUI) can be operated with minimal visual attention. To prevent visual overload and provide a flexible yet intuitive user interface, Smarter Objects combines the best of both styles by using a GUI for understanding and programming and a TUI for day to day operation. Smarter Objects uses Augmented Reality technology to provide a flexible GUI for objects when that is needed.

This paper presents a test pattern for developing automated system tests for distributed applications. System tests are those intended to test the whole, completely integrated application. Developing such tests is hard because it demands the probing and analysis of data from distributed objects that sometimes present asynchronous operations. The Distributed Test Agents pattern is intended to guide the testers in the development of automated system tests for distributed applications. During the development of the tests, testers can abstract several details regarding the configuration of the distributed components and they can use and access these components in a simple and synchronous way.

Herlihy and Wing [11] established that the set of possible outcomes of a shared memory distributed algorithm remains unchanged when atomic objects are replaced by their linearizable implementations. Since then, linearizability has been the correctness condition of choice for distributed algorithm designers. In 2011, however, Golab, Higham and Woelfel [9] showed that, if an algorithm employs randomization, then the probability distribution over the set of possible outcomes can differ between the atomic and implemented versions. They also proved that a stronger condition, called strong linearizability, is necessary and sufficient to guarantee the same probability distributions for these two cases when the randomized algorithm is under the control of an adaptive adversary. Therefore, we are motivated to construct strongly linearizable implementations of common distributed objects whenever possible. In this paper we prove • for several objects including multi-writer registers, max-registers, snapshots, and counters there is no strongly linearizable, non-blocking implementation from multi-reader/single-writer atomic registers, even though each of these objects has a linearizable implementation meeting the stronger wait-free progress requirement. • There is a universal strongly linearizable obstruction-free implementation of any object from multi-reader/single-writer atomic registers. • There is a strongly linearizable wait-free implementation of bounded max-registers from multi-reader/multi-writer atomic registers.

X10 is a programming language that incorporates distributed processing functions. The execution model of X10 is called "APGAS", where each object belongs to a specific place (an abstraction of a shared-memory computer), but can be remotely referenced from other places using a mechanism named GlobalRef. This means that a remotely-referenced object must not be collected as garbage even if there is no local reference to it.There is an implementation of X10 named "Managed X10", which uses multiple Java virtual machines (JVMs) to run an X10 application. In a Managed X10 environment, X10 objects are represented by Java objects, and unneeded objects are collected by the GC in the JVM. Each place is implemented as an individual JVM, so distributed processing is possible by using multiple JVMs on multiple computers. However, in the early implementation of Managed X10, objects that were ever remotely referenced through GlobalRef were registered in a management table and would never be collected. Therefore, if an application uses GlobalRefs periodically, its heap area is consumed by uncollectable objects and an OutOfMemoryError condition may eventually occur.To solve this problem, we developed a distributed GC for Managed X10. The core part of this GC is provided by an internal data structure called the "Globalized Object Tracker" (GOT), which is prepared for each remotely-referenced (globalized) object. GOT tracks the number of remote references to the object and handles the mapping between the object and its ID. When all remote references are removed, the distributed GC makes the object collectable by the local JVM GC.This paper first introduces the distributed execution model of X10 and the mechanism of GlobalRef, then explains how the distributed GC is implemented in Managed X10. The implementation does not modify the JVM, so it is highly portable. Through various evaluation experiments, we show that the remotely-referenced objects are correctly collected and there is almost no performance degradation in the proposed distributed GC.

This paper introduces a "k-bounded set object", namely a shared object with limited memory that allows processes to add and remove values as well as take a snapshot of its content. The interest of the k-bounded set lies in the fact that it can be used to program useful abstractions for dynamic distributed systems, such as an eventual participant detector.

ObjectTeams/Java realizes the Object Teams Model, a flexible and rigorous programming language model that combines aspect-oriented and collaboration-based concepts and integrates them with the object orientation model. OT/J establishes strong bonds through playedBy relationships between players and roles within a team (collaborations). OT/J has proved to be a strong programming model that allows adaptation of objects interacting within a collaboration in a single JVM. We believe that extending the OT model to distributed environments will allow the creation of a rigorous model for adapting distributed objects and developing adaptable distributed applications. This paper presents Distributed ObjectTeams/Java (DOT/J) as a distributed model that extends the OT model to distributed environments.

Most large-scale applications integrate remote services and/or transactional databases. Yet building software that efficiently invokes distributed service and accesses relational databases is still quite difficult. Existing approaches to these problems are based on the Remote Procedure Call (RPC) and Object-Relational Mapping (ORM). RPCs have been generalized to distributed object systems with remote proxies, a kind of remote object reference. ORM tools generally support a form of query sub-language for efficient object selection. The last 20 years have produced a long litany of technologies based on these concepts, including ODBC, CORBA, DCE, DCOM, RMI, DAO, OLEDB, SQLJ, JDBC, EJB, JDO, Hibernate, XML-RPC, Web Services and LINQ. Even with these technologies, complex design patterns for service facades and/or bulk data transfers must be followed to optimize communication between client and server or client and database, leading to programs that are difficult to modify and maintain. While significant progress has been made, there is no widely accepted solution or even agreement about what the solution should look like. In this talk I present a new unified approach to invocation of distributed services and data access. The solution involves a novel control flow construct that partitions a program block into remote and local computations, while efficiently managing the communication between them. The solution does not require proxies or an embedded query language. Although the result itself is elegant and useful, what is more significant is the realization that the original problems cannot be solved using existing programming language constructs and libraries. This work calls into question our assumption that general-purpose programming languages are truly general-purpose.

Session types allow communication protocols to be specified type-theoretically so that protocol implementations can be verified by static type-checking. We extend previous work on session types for distributed object-oriented languages in three ways. (1) We attach a session type to a class definition, to specify the possible sequences of method calls. (2) We allow a session type (protocol) implementation to be modularized , i.e. partitioned into separately-callable methods. (3) We treat session-typed communication channels as objects, integrating their session types with the session types of classes. The result is an elegant unification of communication channels and their session types, distributed object-oriented programming, and a form of typestates supporting non-uniform objects, i.e. objects that dynamically change the set of available methods. We define syntax, operational semantics, a sound type system, and a correct and complete type checking algorithm for a small distributed class-based object-oriented language. Static typing guarantees that both sequences of messages on channels, and sequences of method calls on objects, conform to type-theoretic specifications, thus ensuring type-safety. The language includes expected features of session types, such as delegation, and expected features of object-oriented programming, such as encapsulation of local state. We also describe a prototype implementation as an extension of Java.

This paper presents a novel object-oriented approach to modeling the semantics of distributed multi-party protocols such as leader election, distributed locks or reliable multicast, and a programming language that supports it. The approach extends our live distributed objects (LO) model with the new concept of a distributed flow (DF), a stream of events that flow concurrently at multiple locations. DFs correspond to local variables, private fields, and method parameters in Java-like languages; they're means by which one stores and communicates state. Protocol instances correspond to Java objects; they consume and output flows; their internal states are encapsulated as internal flows, and their internal logic is represented as operations on flows. Our language provides a new type of concern separation: the semantic structure of protocols is decoupled from implementation details such as construction and maintenance of overlays, trees, and other structures used for scalability. These can be generated by the compiler or at deployment time. This can be done differently in different parts of the network, to match the local environment.

Proxies are ubiquitous in distributed systems. They are mainly used to provide transparent access to server objects, and in some cases for additional functions such as caching, message routing, marshalling, and un-marshalling of data. In this paper, we discuss several software engineering problems associated with using proxies in a distributed system. We believe that proxies in distributed systems suffer from: 1) redundant code 2) multiple data translations that have to be written before data is marshalled for transfer over the wire, and 3) in the case when proxies are automatically generated, there is no universal or generic mapping (to date) from XML types to Object types and vice versa. We describe these problems using an example, and discuss the partial solutions provided by prior research. A better understanding of these problems may help show the way towards a future solution.

The key issue in distributed programming is partial failure: how to handle failures of part of the system. This unavoidable property causes uncertainty because we cannot know whether a remote object is ever going to reply to a message. It is also the reason why RMI/RPC is difficult to use. In this paper we describe the most convenient object-oriented mechanism we have found to develop peer-to-peer applications effectively, namely by using active objects that communicate via asynchronous message passing and fault streams for failure handling. We show that this works better than the usual approach of using RMI to communicate and distributed exceptions for failure handling. We define our peers as lightweight actors and we use them to build a highly dynamic peer-to-peer network that deals well with partial failure and non-transitive connectivity. We give many code examples to show the simplicity and naturalness of our approach.

The fundamental ideas of distributed objects have changed little in the last 20 years. Existing languages are retrofitted with transparent distribution mechanisms based on proxies. Experiments with mobile code demonstrate its power but have little impact on practice. The problems with transparency and mobile code have been well known since at least 1994. But in the absence of any fundamental new ideas, the same problematic approaches are used, for example in the design of Java RMI. In this essay we discuss a new programming construct called Remote Batch Invocation (RBI). A batch is a code block that combines remote and local execution over fine-grained object interfaces, but is executed by partitioning and remote evaluation. Remote Batch Invocation effectively addresses the shortcomings of transparent distribution with a controlled form of mobile code. Our experience leads us to believe that distribution cannot be implemented as a library, but requires specific language support. Viewing distribution as a language design problem represents a revolutionary step in the development of distributed objects.

Web services and platforms such as .NET make it easy to integrate interactive end-user applications with backend services. However, it remains hard to build collaborative applications in which information is shared within teams. We present a new drag-and-drop technology, in which standard office documents (spreadsheets, databases, etc.) are interconnected with eventdriven middleware ("live distributed objects"), to create distributed applications in which changes to underlying data propagate quickly to downstream applications. Information is replicated in a consistent manner, making it easy for team members to share updates and to coordinate their actions. In this demo, we present our middleware platform in office automation settings which is highly automated and highly configurable.

Web services and platforms such as .NET make it easy to integrate interactive end-user applications with backend services. However, it remains hard to build collaborative applications in which information is shared within teams. This paper introduces a new drag-and-drop technology, in which standard office documents (spreadsheets, databases, etc.) are interconnected with event-driven middleware ("live distributed objects"), to create distributed applications in which changes to underlying data propagate quickly to downstream applications. Information is replicated in a consistent manner, making it easy for team members to share updates and to coordinate their actions. We present our middleware platform, and show that it offers good performance and scalability, with small resource footprint. Moreover, because the approach is highly automated, and the underlying middleware is highly configurable, we're in a position to automatically address security and reliability needs that might otherwise be onerous. In addition to reviewing our existing system, we list open issues, which include integration with external data sources, and updating stored, but inactive objects.

Building large scale applications is nowadays a complex challenge. Such complexity is determined by several factors like distributed application development, deployment or management, to name a few. Adaptive middleware plays an important role in achieving such task, and abstracts developers from the underlying layer issues like persistence, fault tolerance, and load balancing, among others. Distributed Aspect Oriented Programming (AOP) is a promising paradigm that offers new ideas in the middleware arena. Several models like remote pointcut or component-aspects for designing wide-area distributed systems exist in such setting, but none of them completely fulfill the scalability requirement. In this paper we present a distributed aspect middleware for large-scale systems mainly offering three contributions. Firstly we introduce a complete aspect remoting service with one-to-one and one-to-many abstractions. Secondly, we outline the construction of a distributed aspect meta-model that provides a novel distributed meta-pointcut mechanism to intercept remote services. Finally, the distributed aspect composition model that allows connection mechanisms in design, activation, and runtime phases. The last part of the paper includes a proof-of-concept, consisting of an adaptive Distributed Hash Table (DHT), which is a clear example of how a wide variety of distributed aspects on large-scale scenarios can be implemented by using our model.

This paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact.

Distributed applications are difficult to write. Programmers need to adhere to specific distributed systems programming conventions and frameworks, which makes distributed systems development complex and error prone and ties the resultant application to the distributed system because the applications code is tangled with the crosscutting concern distribution.We introduce a simple high level domain specific aspect language we call a Distribution Definition Language (DDL), which describes the classes and methods of an existing application that are to be made remote, the distributed system to use to make them remote, and the recovery mechanism to use in the event of a remote error. The DDL is used by the RemoteJ compiler / generator to generate the distributed system specific code and apply it to components using bytecode manipulation techniques.We describe the language and its features and show that a distribution definition language can be used to significantly simplify distributed systems development and improve software reuse.

Replication is a well-known technique to enhance dependability and performance in distributed systems. A plethora of replication middleware for distributed object systems has been proposed in the past decade. However, replication in service-oriented systems is still in its infancy. In this paper, we analyze some of the proposed service replication middleware solutions and compare them on an architectural level with object replication middleware. In particular, we focus on replication middleware that allows for (but is not limited to) strict consistency of replicas since this is required by many real-life applications. We identify six major infrastructure components and present a generalized architecture for both distributed object and service-oriented replication middleware. The result of our comparison is unambiguous: Replication middleware for service-oriented systems and distributed object systems (such as FT-CORBA) share many commonalities and only subtle differences caused by the different granularity of the replicated entity, or different transaction models.

In a distributed system, it takes time for a software event to reach remote clients. In the same sense as used in physics, only when the event had reached the time horizon of a client, client becomes aware of it. Using this metaphor , we have developed a simple yet powerful model for software components to get back in sync after interruptions. The ideas described in this paper have been implemented on En Route Automation Modernization (ERAM) program, a Federal Aviation Administration (FAA) effort aimed at replacing the aging en route assets and planting a seed for the many future enhancements that the projected increase in air traffic requires. In many ways, this paper is a compendium to another paper at this same conference titled Publisher Framework (PFW), because it is within the auspices of PFW that these ideas have been implemented.

Most communication subsystems support modular and reconfigurable communication protocols based on the Lego block model. In this model, complex protocols are built as collections of simpler protocols. However, protocol behavior is often expressed via informal descriptions and few work has been done to develop the underlying semantics that enables us to model and reason about protocol interactions. Without it, it is very difficult to identify critical properties that must be met for correct operation. In this paper we present a communication framework based on a semantic model of distributed object reflection and we illustrate how this model can be used to formalize and reason about interactions between communication protocols. We evaluate the overhead and feasibility of our approach by developing an abstract executable specification of the communication framework in Maude [3] and a Maude API to systematically translate Maude code into Java. This gives us two versions of our model to play with: an abstract one for analysis and a concrete one for real-world applications.

The recent deployment of large distributed computing systems such as content distribution networks and the Planet-Lab has made it possible for researchers and practitioners to experiment with real world, large scale distributed applications. However, running an application in such an environment is difficult, due to the scale and frequent node failures of such systems. Thus, an important tool is needed that helps application developers/deployers to manage their applications. Our goal in this work is to develop MON, an extremely lightweight and failure resilient system for managing distributed applications. MON allows users to execute instant management commands on the distributed computing nodes, such as query the current status of the application, or start/stop a process on the distributed nodes. The commands are propagated to all the nodes and executed on each node, and the results are aggregated and returned back. We believe the ability to execute such instant commands is especially useful for the initial deployment of a distributed application, or for the monitoring and diagnoistics of (unexpected) application failures.

This paper presents a CORBA-compliant middleware architecture that is more flexible and extensible compared to standard CORBA. The portable design of this architecture is easily integrated in any standard CORBA middleware; for this purpose, mainly the handling of object references (IORs) has to be changed. To encapsulate those changes, we introduce the concept of a generic reference manager with portable profile managers. Profile managers are pluggable and in extreme can be downloaded on demand. To illustrate the use of this approach, we present a profile manager implementation for fragmented objects and another one for bridging CORBA to the Jini world. The first profile manager supports truly distributed objects, which allow seamless integration of partitioning, scalability, fault tolerance, end-to-end quality of service, and many more implementation aspects into a distributed object without losing distribution and location transparency. The second profile manager illustrates how our architecture enables fully transparent access from CORBA applications to services on non-CORBA platforms.

DisASTer (Distributed Algorithms Simulation Terrain) is a platform for the implementation of distributed algorithms. It provides a Java class library that eases the programming of distributed algorithms in Java. Moreover, DisASTer constitutes an execution environment that enables the user to specify interactively a topology at runtime. It allows the user to control the execution of the algorithm (start, stop, suspend, resume, go back and forth). In addition, the execution of a distributed algorithm can be observed through some built-in visualization panels (topology view, sequence view, message queue view). DisASTer supports the implementation of further application-specific views.

This paper presents a system for visualizing mobile object frameworks. In such frameworks, the objects can migrate to remote hosts, along with their state and behavior, while the application is running. An innovative graph-based visualization is used to depict the physical and the logical connections in the distributed object network. Scalability is achieved by using a focus+context technique jointly with a user-steered clustering algorithm. In addition, an event synchronization model for mobile objects is presented. The system has been applied to visualizing several mobile object applications.

Although in recent years the concept of leasing has become more and more popular in the field of distributed object-oriented systems, it has not yet been incorporated in the current specification of the widespread CORBA standard.In this paper, we present an approach to the problem of realizing the leasing concept in a CORBA environment. We examine different leasing variants, such as exclusive or shared leasing, leasing with or without prolongation, etc., describe different ways to implement these variants in CORBA, e.g., based on a specialized object adapter, a runtime library or framework, or a CORBA service, and we discuss the advantages and disadvantages of each approach.Furthermore, we show how existing CORBAservices such as Naming, Trading, and Property Service can benefit from leasing facilities. Finally, we briefly present some architectural details of our own implementation of an exemplary CORBA Leasing Service.

Middleware technologies allow the development of distributed applications without explicit knowledge of the networking involved. However, in the face of changing network and CPU conditions across the distributed system, these applications often will need to adapt their behavior to maintain an acceptable quality of service (QoS), which implies a knowledge of these conditions. This adaptation is neither part of the application logic nor part of the distribution middleware, and so represents a separate concern which needs to be addressed.This paper describes an aspect-based approach to programming QoS adaptive applications that separates the QoS and adaptation concerns from the functional and distribution concerns. To simplify aspect development for these applications, our approach integrates a domain-specific adaptation specification with a novel aspect language which includes distribution and adaptation-specific join points in its join point model. We compare and contrast this with existing aspect-oriented language approaches and illustrate our approach with an example distributed system application.

We describe an object-oriented software integration framework, Roccom, abstracted from our five years of experience in developing a complex, integrated code for rocket simulation. Roccom provides a flexible mechanism for inter-module data exchange and function invocation in parallel multiphysics simulations. It is designed to minimize user effort and code changes for integration, facilitate interoperability between different programming languages (in particular, C++ and Fortran 90), and enable plug-and-play of different implementations of physics and computer science modules in an integrated system. Its unique abstraction of distributed objects allows cleaner inter-module interfaces and maximizes concurrency in development of different modules. Our framework also provides a set of reusable service utilities that allow rapid prototyping of various coupling algorithms without sacrificing performance.

Many-to-Many Invocation (M2MI) is a new paradigm for building collaborative systems that run in wireless proximal ad hoc networks M2MI provides an object oriented method call abstraction based on broadcasting. An M2MI invocation means "Every object out there that implements this interface, call this method." An M2MI-based application is built by defining one or more interfaces, creating objects that implement those interfaces in all the participating devices, and broadcasting method invocations to all the objects on all the devices.

As researchers share computational resources, such as objects in large distributed environments, it becomes difficult to achieve scalability of synchronization. Concurrency protocols currently lack scalability. Our protocol enhances middleware concurrency services to provide scalability of synchronization enabling resource sharing and computing with distributed objects in systems with a large number of nodes.

Object combining tries to put objects together that have roughly the same life times in order to reduce strain on the memory manager and to reduce the number of pointer indirections during a program's execution. Object combining works by appending the fields of one object to another, allowing allocation and freeing of multiple objects with a single heap (de)allocation. Unlike object inlining, which will only optimize objects where one has a (unique) pointer to another, our optimization also works if there is no such relation. Object inlining also directly replaces the pointer by the inlined object's fields. Object combining leaves the pointer in place to allow more combining. Elimination of the pointer accesses is implemented in a separate compiler optimization pass.Unlike previous object inlining systems, reference field overwrites are allowed and handled, resulting in much more aggressive optimization. Our object combining heuristics also allow unrelated objects to be combined, for example those allocated inside a loop; recursive data structures (linked lists, trees) can be allocated several at a time and objects that are always used together can be combined.The main focus of object combining in this paper is on reducing object (de)allocation overhead, by reducing both garbage collection work and the number of object allocations. Reduction of memory management overhead causes execution time to be reduced by up to 35%. Indirection removal further reduces execution time by up to 6%.

Remote Method Invocation is an adaptation of the remote procedure call paradigm for object-oriented environments. RMI allows clients to seamlessly invoke methods of objects within remote servers. Communication between the client and server is based upon an agreed protocol stack that defines connection management rules, message formats, and data encoding.There are numerous communication libraries for Java that enable remote method invocations over different wire protocols. Standard Java RMI is based on the Java Remote Method Protocol, JRMP. RMI-IIOP [6] is alternative implementation that enables connectivity with legacy CORBA systems. JAX-RPC [5] provides means to invoke methods via SOAP, making it possible to interact with Web Services. Also, many alternative RMI implementations have been developed in order to overcome standard Java RMI and JRMP performance issues [3, 1, 2]. The common drawback of these libraries is that they are designed to be used exclusively (e.g. they usually bind clients to a particular wire protocol via stubs generated at compile time) and they do not interoperate well.RMIX is a meta-RMI framework that, rather than itself providing communication capabilities, defines a common facade through which variety of wire protocols may be used in a uniform way. Concrete protocols are supported by independent, dynamically pluggable modules, i.e. protocol service providers. Such an approach permits removal of the dependence of distributed applications on particular communication protocols: at the server side, remote objects may be uniformly exported over various protocols; at the client side, the need for statically generated stub classes is eliminated.Some projected usage scenarios of RMIX include: (1) loosely coupled distributed systems with peer-to-peer protocol negotiation (dynamic discovery is especially beneficial in this case as it makes it possible to add or upgrade protocol providers at run-time); (2) applications that are multi-protocol by nature (e.g. distributed scientific applications that communicate using an efficient native protocol but offer SOAP endpoints for monitoring and control purposes); (3) standard Java RMI applications ported to RMIX in order to eliminate the burden associated with generation and distribution of stub classes.Currently, RMIX offers two concrete protocol providers: RMIX-JRMPX, a lightweight layer over standard Java RMI, and RMIX-XSOAP, based on XSOAP [4] and using SOAP 1.1 as its wire protocol.In addition to multiple protocol support, RMIX offer other enhancements such as customizable remote object endpoints, and asynchronous invocation mode. More information about RMIX can be found at http://www.mathcs.emory.edu/rmix/.