Today, data analysis drives the decision-making process in virtually every human activity. This demands for software platforms that offer simple programming abstractions to express data analysis tasks and that can execute them in an efficient and scalable way. State-of-the-art solutions range from low-level programming primitives, which give control to the developer about communication and resource usage, but require significant effort to develop and optimize new algorithms, to high-level platforms that hide most of the complexities of parallel and distributed processing, but often at the cost of reduced efficiency. To reconcile these requirements, we developed Renoir, a novel distributed data processing platform written in Rust. Renoir provides a high-level dataflow programming model as mainstream data processing systems. It supports static and streaming data, it enables data transformations, grouping, aggregation, iterative computations, and time-based analytics, and it provides all these features incurring in a low overhead. In this paper, we present the programming model and the implementation details of Renoir. We evaluate it under heterogeneous workloads. We compare it with state-of-the-art solutions for data analysis and high-performance computing, as well as alternative research products, which offer different programming abstractions and implementation strategies. Renoir programs are compact and easy to write: developers need not care about low-level concerns such as resource usage, data serialization, concurrency control, and communication. At the same time, Renoir consistently presents comparable or better performance than competing solutions, by a large margin in several scenarios. We conclude that Renoir offers a good tradeoff between simplicity and performance, allowing developers to easily express complex data analysis tasks and achieve high performance and scalability.

Microservices architectures conceive an application as a composition of loosely-coupled sub-systems that are developed, deployed, maintained, updated, and scaled independently. Compared to monoliths, microservices speed up evolution and increase flexibility. For these reasons they are becoming the reference architecture for many practitioners. A key challenge to embrace a microservices architecture is how to decompose an application into microservices: a choice that deeply affects all subsequent development phases in ways that are difficult to foresee and evaluate. Without any tool to support their reasoning, developers may erroneously evaluate the various alternatives, leading to inaccurate decomposition choices that would result in increased development, operations, and maintenance costs. This paper tackles the problem with Cromlech, a semi-automatic tool to decompose a software system into microservices. Cromlech (i) takes in input a high-level model of the system in terms of functionalities and data entities accessed by those functionalities, (ii) formulates decomposition as an optimization problem, and (iii) outputs a proposed placement of functionalities and data onto microservices, using a visual representation that helps reasoning on the resulting architecture. Cromlech evaluates design concerns, communication overheads, data management requirements, opportunities and costs of data replication. Our evaluation on a real-world industrial application shows that Cromlech consistently delivers more efficient solutions than simple heuristics and state-of-the-art approaches, and provides useful insights to developers.

Distributed data processing platforms aim to provide a balance between ease of use and performance. The question is: do they succeed? Systems like Apache Spark or Apache Flink offer a high-level programming model that results in simple and concise definition of the processing tasks, abstracting away most of the concerns associated to concurrency and distribution but at the cost of a large performance gap with custom programs that use low-level primitives to control distribution and resource usage. May we fill this gap? May alternative design choices yield better performance without sacrificing simplicity?This paper answers the above questions by introducing RStream, a novel data processing platform written in Rust. RStream provides a high-level programming model similar to that of mainstream data processing systems, which supports batch and stream processing, data transformations, grouping, aggregation, iterative computations, and time-based analytics, incurring in a much lower overhead, closer to that of custom, low-level code. In numerical terms, our evaluation shows that RStream programs present nearly identical complexity as similar programs written in Flink, delivering from 2× to 20× the throughput of Flink, rivaling custom MPI implementations.

Large-scale information processing often relies on subset matching for data classification and routing. Examples are publish/subscribe and stream processing systems, database systems, social media, and information-centric networking. For instance, an advanced Twitter-like messaging service where users might follow specific publishers as well as specific topics encoded as tag sets must join a stream of published messages with the users and their preferred tag sets so that the user tag set is a subset of the message tags.

Matching incoming event notifications against received subscriptions are a fundamental part of every publish-subscribe infrastructure. In the case of content-based systems this is a fairly complex and time consuming task, whose performance impacts that of the entire system. In the past, several algorithms have been proposed for efficient content-based event matching. While they differ in most aspects, they have in common the fact of being conceived to run on conventional, sequential hardware. On the other hand, parallel hardware is becoming available off-the-shelf: the number of cores inside CPUs is constantly increasing, and CUDA makes it possible to access the power of GPU hardware for general purpose computing. In this paper, we describe a new publish-subscribe content-based matching algorithm designed to run efficiently both on multicore CPUs and CUDA GPUs. A detailed comparison with two state-of-the-art sequential matching algorithms demonstrates how the use of parallel hardware can bring impressive speedups in content-based matching. At the same time, our analysis identifies the characteristic aspects of multicore and CUDA programming that mostly impact performance.

This paper describes a novel model for the service selection problem of workflow-based applications in the context of self-managing situated computing. In such systems, the execution environment includes different types of devices, from remote servers to personal notebooks, smartphones, and wireless sensors, which build an infrastructure that can dynamically change both its physical and logical architecture at runtime. We assume that workflows are defined abstractly; i.e., they invoke abstract services whose concrete counterparts can be selected dynamically. We also assume that concrete service implementations may possibly migrate on the nodes of the infrastructure. The selection problem we address is framed as an optimization problem of the quality of service (QoS), which evaluates at runtime the optimal binding to concrete services as well as the tradeoff between the remote execution of software fragments and their dynamic deployment on local nodes of the computational environment. The final deployment takes into account quality of service constraints, the capabilities of the physical devices involved, including their performance and energy consumption, and the characteristics of the networking links connecting them.

We present the workflow language DSOL, its runtime system and the tools available to support the development of dynamic service orchestrations. DSOL aims at supporting dynamic, self-managed service compositions that can adapt to changes occurring at runtime.

Service Oriented Computing enables distributed applications that orchestrate existing services exported by remote providers. This paradigm requires to explicitly handle possible changes that may affect the orchestration. They include changes that impact its functional behavior (e.g., services being retired by their providers), but also changes in the non-functional behavior of the orchestrated services (e.g., an increased execution time). In the past we developed DSOL: it combines a declarative language to model the orchestration with planning mechanisms to decide at run-time the best flow of actions. In this paper we extend DSOL to support QoS attributes and requirements. In particular, we combine the DSOL planning techniques with a linear optimizer to calculate the optimal plan w.r.t. the QoS requirements. Moreover, we leverage the DSOL ability to adapt the orchestration flow at run-time, to further optimize the QoS perceived by the end users depending on the actual situations encountered.

In this demo we present SelfMotion: a declarative language and a run-time system conceived to support the development of adaptive, mobile applications, built as compositions of ad-hoc components, existing services and third party applications. The advantages of the approach and the adaptive capabilities of SelfMotion are demonstrated in the demo by designing and executing a mobile application inspired by an existing, worldwide distributed, mobile application.

Remote Method Invocation (RMI) provides a powerful programming abstraction, well integrated with the object-oriented paradigm. Like conventional method calls, RMI interaction is point-to-point and uses an explicit address to determine the target of invocations. While natural and easy to use, these characteristics limit the applicability of RMI in large scale, dynamic scenarios. In this paper we present MultiCaR: a multicast extension to RMI, which provides a declarative addressing model that maximizes the decoupling among components, supporting a context-aware programming style that nicely fits dynamic scenarios. The set of guarantees provided by MultiCaR have been carefully defined to allow an efficient implementation of the model for large scale deployments. Finally, the MultiCaR prototype we developed exploits a content-based routing infrastructure to provide flexibility and scalability at the implementation level. We argue that these characteristics make MultiCaR a good candidate to develop large scale, object-oriented, dynamic applications, in the same way as content-based publish-subscribe has proved to support large scale, event-driven, dynamic applications.

In this poster, we focus on the cross-layer design of a low-power traffic aware MAC protocol and a content and context based routing protocol. We describe the cross-layering aspects of the MAC-Routing framework and present the performance results on real sensor node testbed.

Complex communication patterns often need to take into account the situation in which the information to be communicated is produced or consumed. Publish-subscribe, and particularly its content-based incarnation, is often used to convey this information by encoding the ldquocontextrdquo of the publisher into the published messages. In this paper we claim that this approach is limiting and inefficient and propose a context-aware publish-subscribe model of communication as a better alternative. We describe a protocol that implements such model in a distributed publish-subscribe middleware, and analyze how it performs w.r.t. traditional content-based routing.

Content-based routing (CBR) provides a powerful and flexible foundation for distributed applications. Its communication model, based on implicit addressing, fosters decoupling among the communicating components, therefore meeting the needs of many dynamic scenarios, including mobile ad hoc networks (MANETs). Unfortunately, the characteristics of the CBR model are only rarely met by available systems, which typically assume that application-level routers are organized in a tree-shaped network with a fixed topology. In this paper, we present COMAN, a protocol to organize the nodes of a MANET in a tree-shaped network able to 1) self- repair to tolerate the frequent topological reconfigurations typical of MANETs and 2) achieve this goal through repair strategies that minimize the changes that may impact the CBR layer exploiting the tree. COMAN is implemented and publicly available. Here, we report about its performance in simulated scenarios, as well as in real-world experiments. The results confirm that its characteristics enable reliable and efficient CBR on MANETs.

Distributed content-based publish-subscribe middleware is emerging as a promising answer to the demands of modern distributed computing. Nevertheless, currently available systems usually do not provide reliability guarantees. This hampers their use in dynamic and unreliable scenarios, notably including mobile ones. We evaluate the effectiveness of an approach based on epidemic algorithms. Three algorithms we originally proposed in [P. Costa et al., (2003)] are thoroughly compared and evaluated through simulation in challenging unreliable settings. The results show that our use of epidemic algorithms improves significantly event delivery, is scalable, and introduces only limited overhead.

Distributed content-based publish-subscribe middleware provides the decoupling, flexibility, expressiveness, and scalability required by highly dynamic distributed applications, e.g., mobile ones. Nevertheless, the available systems exploiting a distributed event dispatcher are unable to rearrange dynamically their behavior to adapt to changes in the topology of the dispatching infrastructure. In this work, we first define a strawman solution based on ideas proposed (but never precisely characterized) in existing work. We then analyze this solution and achieve a deeper understanding of how the event dispatching information is reconfigured. Based on this analysis, we modify the strawman approach to reduce its overhead. Simulations show that the reduction is significant (up to 50%), and yet the algorithm is resilient to concurrent reconfigurations.

The development of complex distributed systems demands the creation of suitable architectural styles (or paradigms) and related runtime infrastructures. An emerging style that is receiving increasing attention is based on the notion of event. In an event-based architecture, distributed software components interact by generating and consuming events. An event is the occurrence of some state change in a component of a software system, made visible to the external world. The occurrence of an event in a component is asynchronously notified to any other component that has declared some interest in it. This paradigm (usually called "publish/subscribe", from the names of the two basic operations that regulate the communication) holds the promise of supporting a flexible and effective interaction among highly reconfigurable, distributed software components. In the past two years, we have developed an object-oriented infrastructure called JEDI (Java event-based distributed infrastructure). JEDI supports the development and operation of event-based systems and has been used to implement a significant example of distributed system, namely, the OPSS workflow management system (WFMS). The paper illustrates the main features of JEDI and how we have used them to implement OPSS. Moreover, the paper provides an initial evaluation of our experiences in using the event-based architectural style and a classification of some of the event-based infrastructures presented in the literature.

The development of complex distributed systems demands for the creation of suitable architectural styles (or paradigms) and related run-time infrastructures. An emerging style that is receiving increasing attention is based on the notion of event. In an event-based architecture, distributed software components interact by generating and consuming events. The occurrence of an event in a component (called source) is asynchronously notified to any other component (called recipient) that has declared some interest in it. This paradigm holds the promise of supporting a flexible and effective interaction among highly reconfigurable distributed software components. We have developed an object-oriented infrastructure, called JEDI (Java Event-based Distributed Infrastructure), to support the development and operation of event-based systems. During the past year, JEDI has been used to implement a significant example of distributed system, namely, the OPSS workflow management system. The paper illustrates JEDI main features and how we have used it to implement the OPSS workflow management system. Moreover, it provides an initial evaluation of our experiences in using an event-based architectural style.

Process support systems (PSSs) support business organizations in modeling, improving and automating their business processes. Thanks to their ability in enacting process models, they can be used to guide people in performing their daily work and to automate the repetitive tasks that do not require human intervention. Given these potential benefits, it is surprising to observe that PSSs are not widely adopted. This is especially true in case of highly flexible and human-intensive processes, such as design processes in general and software processes in particular. This fact can be explained by observing that currently available PSSs do not fulfil some crucial needs of modern business organizations. One of their major drawbacks is that they do not offer adequate mechanisms to cope with unforeseen situations. They are good at supporting business processes if all proceeds as expected, but if an unexpected situation is met, which would require one to deviate from the process model, they often become more an obstacle than a help. This paper deals with the problem of managing unforeseen situations that require deviations from the process model during enactment in the context of the PROSYT (PROcess Support sYstem capable of Tolerating deviations) PSS. During process model enactment, PROSYT is capable of tolerating deviations from the process model by supporting users even when unexpected situations arise. Furthermore, it supports users in reconciling the process model with the process actually followed, if necessary.

Most modern business activities are carried out by a combination of computerized tools and human agents. Typical examples are engineering design activities, office procedures, and banking systems. All these human-centered systems are characterized by the interaction among people, and between people and computerized tools. This interaction defines a process, whose effectiveness is essential to ensure the quality of the delivered products and/or services. To support these systems, process-centered environments and workflow management systems have been recently developed. They can be collectively identified with the term process technology . This technology is based on the explicit definition of the process to be followed (the process model ). The model specifies the kind of support that has to be provided to human agents. An essential property that process technology mut exhibit is the ability of tolerating, controlling, and supporting deviations and inconsistencies of the real-world behaviors with respect to the proocess model. This is necessary to provide consistent and effective support to the human-centered system, still maintaining a high degree of flexibility and adaptability to the evolving needs, preferences, an expertise of the the human agents. This article presents a formal framework to characterize the interaction between a human-centered system and its automated support. It does not aim at introducing a new language or system to describe processes. Rather, it aims at identifying the basic properties and features that make it possible to formally define the concepts of inconsistency and deviation. This formal framework can then be used to compare existing solutions and guide future research work.

A fundamental problem in software processes is how the mintrinsic rigidity of a predejined (formal) model can be reconciled with the need for flexibility, change, and evolution.We therefore distinguish between software processes, as specified in a process description, and their actual performance by humans.Further, we claim that the two inevitably diverge, and thus it is necessary to provide means to reconcile them.We present a preliminary exploration into the problem.In particular, we illustrate how a temporal logic-based approach can be used to capture and tolerate some deviations from the process description during execution.We present a simple process language (LATIN), and its prototype environment (SENTINEL), in which these ideas are currently experimented.1