Luis Garcés-Erice

Building an Enterprise Service Bus for Real-Time SOA: A Messaging Middleware Stack

Service-Oriented Architecture (SOA) has become the preferred methodology to build complex enterprise applications. Inside an enterprise, an Enterprise Service Bus (ESB) has emerged as a powerful and flexible solution to have services and applications interact with each other, independently of their location and connectivity requirements. ESBs are implemented with some form of middleware, and messaging middleware has been playing a major role in integrating applications and services in the J2EE space thanks to standards such as the Java Messaging Service (JMS). We observe that in an enterprise the need to use real-world current information and the shift of complexity toward higher layers of the SOA-based applications (e.g., the business process layer) favor the introduction of lightweight messaging middleware, benefiting real-time applications. This paper describes an architecture for a messaging middleware that aims at fulfilling the requirements of a real-time ESB, while maintaining compatibility with the applications already deployed.We present performance results of a first prototype that show low, regular latency and high throughput. We contend that this middleware is an essential building block for real-time SOA in the enterprise.

OS streaming deployment

A network deployment of generally available operating systems (OS) usually takes in the order of tens of minutes. This is prohibitive in an environment in which OSs must be dynamically and frequently provisioned in response to external requests. By exploiting the fact that in general only a small part of an OS image is actually required to be present to perform useful tasks, we demonstrate how an OS can perform work shortly after a deployment has begun. This requires the insertion of a streaming device between the operating system and the disk. We have implemented such a device for Windows∗ and Linux∗. We show that such an OS streaming deployment reduces significantly (i.e., to a few seconds) the time between the start of the deployment and the moment at which the OS is available. Furthermore, we demonstrate that the performance overhead of using the OS during streaming is negligible as the penalty introduced by the streaming device is minor and the I/O performance is completely dominated by the multiple caches between the application and the disk.

Messo & Preso Practical Sensor-Network Messaging Protocols

We present two protocols one of which supports the publication by sensors in a sensor-network of messages on a named topic, the other that allows sensors to subscribe to messages on a named topic. We separate the publish and subscribe functions into different protocols as it is not necessary for a given device to support both. The publication protocol is designed for management systems in which nodes take readings from a sensor and transmit them to monitoring applications while the subscription protocol is for actuating systems in which the state of certain nodes is changed by control applications. The protocols use cross-layer optimization techniques for reducing transmissions within the messaging layer of the sensor-network. We show that the path characteristics of such network are highly variable leading to frequent topology changes motivating our description of the protocols which can function even over fluctuating network topologies. Finally, we use simulation to compare the actuation protocol with an epidemic approach, showing that our protocol is more efficient when the topics that the nodes are interested in are non-uniform

Toward scalable real-time messaging

Conventional messaging technologies have been designed for large transactional systems, making the prediction and calibration of their delay impractical. In this paper, we present a minimal messaging system, implemented in Java™, that is designed to enable the analysis, modeling, and calibration of the expected performance of these technologies. We describe the algorithms and protocols that underlie this messaging system, show how an analysis can be performed, and give the actual measured performance figures. We show that the system achieves a throughput of more than 100,000 messages per second with less than 120-millisecond maximum latency, in the test environment. At 10,000 messages per second, a maximum latency of 5 milliseconds is measured. The algorithms make use of lock-free data structures, which allow the throughput to scale on multi-core systems.

Scaling OS Streaming through Minimizing Cache Redundancy

OS Streaming is a common data center technique for deploying an OS image quickly onto a physical or virtual machine in which the machine requests the individual blocks of the image from a server as it needs them. When streaming images the servers OS level block cache brings very little in terms of performance as the collection of images is usually too large to fit in memory. We investigate how to improve the scalability of streaming servers by ensuring that blocks {\it shared} among multiple streamed images are preferentially retained in a deduplicated cache. We outline the nature of our deduplicating block cache, describing how cacheable blocks are identified during an off line deduplication process and how an extended form of the Least Recently Used (LRU) block replacement algorithm can be used within the server cache.

Admission Control for Distributed Complex Responsive Systems

The software in modern systems has become too complex to make accurate predictions about their performance under different configurations. Real-time or even responsiveness requirements cannot be met because it is not possible to perform admission control for new or changing tasks if we cannot tell how their execution affects the other tasks already running. Previously, we proposed a resource-allocation middleware that manages the execution of tasks in a complex distributed system with real-time requirements. The middleware behavior can be modeled depending on the configuration of the tasks running, so that the performance of any given configuration can be calculated. This makes it possible to have admission control in such a system, but the model requires knowledge of run-time parameters. We propose the utilization of machine-learning algorithms to obtain the model parameters, and be able to predict the system performance under any configuration, so that we can provide a full admission control mechanism for complex software systems.

Predicting Performance on a Loosely Controlled Event System

We contend that event systems will become the kernel of distributed middleware for multicore systems due to their asynchronous nature. In a concurrent system, the fewer points of synchronization between independent activities, the better the achievable parallelization. As physical devices are integrated into distributed middleware the timeliness of the execution of functions becomes increasingly important. Precise guarantees require complete control of all the elements which influence the execution. However, the purpose of middleware is to abstract from the exact nature of the underlying platform. Here we outline an approach that allocates processor shares to event queues, thus controlling the rate of events handled at any given queue. We show how this in turn allows us to predict the likely throughput through a queue. This prediction is achieved through model fitting and calibration.

MULTI+: A robust and topology-aware peer-to-peer multicast service

TOPLUS is a lookup service for structured peer-to-peer networks that is based on the hierarchical grouping of peers according to network IP prefixes. In this paper, we present MULTI+, an application-level Multicast protocol for content distribution over a TOPLUS-based peer-to-peer (P2P) network. We use the characteristics of TOPLUS to design an overlay Multicast protocol that allows every peer to connect to an available peer that is close. MULTI+ trees also reduce the amount of redundant flows leaving and entering each network, making efficient usage of the bandwidth. We also study the resiliency of MULTI+ Multicast trees when massive failure or disconnection of peers occur. While the tree reconstruction introduces additional hops, the end-to-end latency increases very little. At the end we compare the trees constructed by MULTI+ with the trees constructed by Scribe, a well-known application-level Multicast system.

DISCE: A Declarative Inter-ESB Service-Connectivity Configuration Engine

The service-oriented architecture (SOA) has been successfully applied in enterprise environments. Due to decentralized set-ups, mergers and acquisitions and organizational boundaries, many enterprises today operate multiple, fragmented and heterogeneous service infrastructures that are administered by different organizational units. This fragmented infrastructure causes service duplication and unnecessary redundancy. This paper proposes an approach of cross-domain service integration through an automated federation of Enterprise Service Buses (ESBs). ESBs are the mediation centers within a service domain that enable service interaction across technological boundaries by using service proxies. We present DISCE, a configuration engine prototype that enables an operator to configure service connectivity in such an environment in a declarative form, by specifying simple rules. The engine produces a configuration consisting of a set of proxies interconnecting clients and services.

Dependable Actuation in Wireless Sensor Networks

Our protocol uses a publish/subscribe approach to perform reliable actuation on a sensor network with changing topology. Selective actuation on a group of devices can be performed by publishing a message on a topic, and having the group subscribe to that topic. The message contains the data needed to perform the actuation. Our design reduces costly transmissions and uses a soft-state approach to cope with frequent topology changes. Its features and robustness are compared with those of epidemic protocols by means of simulation. Our protocol exhibits more efficient behavior when the actuation targets a selected group of devices within the sensor network; efficiency is similar in other cases. Furthermore, we provide feedback to the external actuating application. The robustness of our proposal is close to that of an epidemic model for moderate bit error rates.