K. R. Jayaram

EventJava: An Extension of Java for Event Correlation

Event correlation has become the cornerstone of many reactive applications, particularly in distributed systems. However, support for programming with complex events is still rather specific and rudimentary. This paper presents EventJava, an extension of Java with generic support for event-based distributed programming. EventJava seamlessly integrates events with methods, and broadcasting with unicasting of events; it supports reactions to combinations of events, and predicates guarding those reactions. EventJava is implemented as a framework to allow for customization of event semantics, matching, and dispatching. We present its implementation, based on a compiler transforming specific primitives to Java, along with a reference implementation of the framework. We discuss ordering properties of EventJava through a formalization of its core as an extension of Featherweight Java. In a performance evaluation, we show that EventJava compares favorably to a highly tuned database-backed event correlation engine as well as to a comparably lightweight concurrency mechanism.

Parametric Content-Based Publish/Subscribe

Content-based publish/subscribe (CPS) is an appealing abstraction for building scalable distributed systems, e.g., message boards, intrusion detectors, or algorithmic stock trading platforms. Recently, CPS extensions have been proposed for location-based services like vehicular networks, mobile social networking, and so on. Although current CPS middleware systems are dynamic in the way they support the joining and leaving of publishers and subscribers, they fall short in supporting subscription adaptations. These are becoming increasingly important across many CPS applications. In algorithmic high frequency trading, for instance, stock price thresholds that are of interest to a trader change rapidly, and gains directly hinge on the reaction time to relevant fluctuations rather than fixed values. In location-aware applications, a subscription is a function of the subscriber location (e.g. GPS coordinates), which inherently changes during motion. The common solution for adapting a subscription consists of a resubscription, where a new subscription is issued and the superseded one canceled. This incurs substantial overhead in CPS middleware systems, and leads to missed or duplicated events during the transition. In this article, we explore the concept of parametric subscriptions for capturing subscription adaptations. We discuss desirable and feasible guarantees for corresponding support, and propose novel algorithms for updating routing mechanisms effectively and efficiently in classic decentralized CPS broker overlay networks. Compared to resubscriptions, our algorithms significantly improve the reaction time to subscription updates without hampering throughput or latency under high update rates. We also propose and evaluate approximation techniques to detect and mitigate pathological cases of high frequency subscription oscillations, which could significantly decrease the throughput of CPS systems thereby affecting other subscribers. We analyze the benefits of our support through implementations of our algorithms in two CPS systems, and by evaluating our algorithms on two different application scenarios.

Putting events in context: aspects for event-based distributed programming

Event-based programming is an appealing paradigm for developing pervasive systems since events enable the decoupling of interacting components. Unfortunately, many event-based languages and systems have hardwired notions of physical or logical time and space. This limits their adaptability and target deployment environments, as pervasive systems rely on inherent interaction and interchanging of different protocols and infrastructures. This paper introduces domain-specific aspects for capturing event context, generalizing beyond the classic time and space dimensions associated with events. Through examples, we demonstrate that our context aspects - conspects for short - modularize the design and implementation of event contexts, enabling code reuse, and making programs portable across infrastructures. We illustrate the benefits of conspects by using them to transparently switch protocols in two pervasive software suites implemented in EventJava: (1) a tornado monitoring system deployed on different architectures ranging from desktop x86 to embedded LEON3, and (2) a mobile social networking suite with protocols for different application scenarios.

Program analysis for event-based distributed systems

Designing distributed applications around the idiom of events has several benefits including extensibility and scalability. To improve conciseness, safety, and efficiency of corresponding programs, several authors have recently proposed programming languages or language extensions with support for event-based programming. The presence of a dedicated programming language and compilation process offers avenues for program analyses to further improve simplicity, safety, and expressiveness of distributed event-based software. This paper presents three program analyses specifically designed for event-based programs: immutability analysis avoids costly cloning of events in the presence of co-located handlers for same events; guard analysis allows for simple yet expressive subscriptions which can be further simplified and handled efficiently; causality analysis determines causal dependencies among events which are related, allowing unrelated events to be transferred independently for efficiency. We convey the benefits of our approach by empirically evaluating their performance benefits.

FAIDECS: fair decentralized event correlation

Many distributed applications rely on event correlation. Such applications, when not built as ad-hoc solutions, typically rely on centralized correlators or on broker overlay networks. Centralized correlators constitute performance bottlenecks and single points of failure; straightforwardly duplicating them can hamper performance and cause processes interested in the same correlations to reach different outcomes. The latter problem can manifest also if broker overlays provide redundant paths to tolerate broker failures as events do not necessarily reach all processes via the same path and thus in the same order. This paper describes FAIDECS, a generic middleware system for fair decentralized correlation of events multicast among processes: processes with identical interests reach identical outcomes, and subsumption relationships among subscriptions are considered for respectively delivered composite events. Based on a generic subset of FAIDECSs predicate language, we introduce properties for composite event deliveries in the presence of process failures and present novel decentralized algorithms implementing these properties. Our algorithms are compared under various workloads to solutions providing equivalent guarantees.

Parametric subscriptions for content-based publish/subscribe networks

Subscription adaptations are becoming increasingly important across many content-based publish/subscribe (CPS) applications. In algorithmic high frequency trading, for instance, stock price thresholds that are of interest to a trader change rapidly, and gains directly hinge on the reaction time to relevant fluctuations. The common solution to adapt a subscription consists of a re-subscription, where a new subscription is issued and the superseded one canceled. This is ineffective, leading to missed or duplicate events during the transition. In this paper, we introduce the concept of parametric subscriptions to support subscription adaptations. We propose novel algorithms for updating routing mechanisms effectively and efficiently in classic CPS broker overlay networks. Compared to re-subscriptions, our algorithms significantly improve the reaction time to subscription updates and can sustain higher throughput in the presence of high update rates. We convey our claims through implementations of our algorithms in two CPS systems, and by evaluating them on two different real-world applications.

Scalable efficient composite event detection

Composite event detection (CED) is the task of identifying combinations of events which are meaningful with respect to program-defined patterns. Recent research in event-based programming has focused on language design (in different paradigms), leading to a wealth of prototype programming models and languages. However, implementing CED in an efficient and scalable manner remains an under-addressed problem. In fact, the lack of scalable algorithms is the main roadblock to incorporating support for more expressive event patterns into prominent event-based programming languages. This lack of scalable algorithms is a particularly acute problem in event stream processing, where event patterns can additionally be specified over time windows. In this paper we describe GenTrie, a deterministic trie-based algorithm for CED. We describe how complex event patterns are split, how each sub-pattern maps to a node in the trie, and demonstrate through empirical evaluation that GenTrie has higher throughput than current implementations of related languages.

Context-oriented programming with EventJava

Recent research on Distributed Event-based Systems (DEBS) has focussed on event correlation, which is the task of processing events to identify meaningful patterns of events in the event cloud. In DEBS, software components communicate by generating, disseminating and receiving event notifications, which reify and describe the event. Several parts of an event notification are context-sensitive, depending on where the software component producing the event is deployed, the communication infrastructure available for event dissemination etc. Event contexts may be added during the production of an event (e.g. by the runtime system executing the component) or during dissemination (by a middleware) and play an integral part in event correlation. Examples of contextual information include physical time, logical time, geographical coordinates, information about the source of events, digital signatures, etc. EventJava [7], an extension of Java with advanced support for event correlation, explicitly integrates the notion of event context, thereby allowing a programmer to customize the way in which events are ordered, propagated and correlated with other events. In this paper, we explain why contexts are indispensable to DEBS, present an overview of EventJava and illustrate the use of contexts through programming examples.

Abstracting context in event-based software

With the recent immersion of advanced mobile devices in the daily lives of millions, pervasive computing is becoming a reality. Developing pervasive software systems is inherently difficult though it requires to deal with heterogeneous infrastructure besides peer-to-peer communication and device mobility. Thus, programming support for such applications must provide loose coupling between different participants, as well as loose coupling between applications and communication protocols. Event-based programming provides an appealing paradigm to decouple participants, however many event-based systems and languages have hardwired communication protocols, which limits their adaptability to heterogeneous deployment environments. In this paper we address this issue by abstracting the context in which events are created and handled, including protocols used to convey, compose, and consume these events. More precisely, we propose to extend an event-based programming model with context aspects --- conspects for short. We demonstrate the elegant usage of conspects through several examples based on their implementation in EventJava and illustrate how they allow to modularize event-based pervasive software. We also provide a thorough empirical investigation of the performance overheads and benefits of conspects, including the costs of weaving them dynamically. Through empirical evaluations, we assess the benefits of conspects for switching protocols without any changes to the base applications through three case studies with EventJava. The three studies are (1) a tornado monitoring system deployed on different architectures ranging from desktop x86 to embedded LEON3, (2) a mobile social networking suite with protocols for different scenarios, and (3) the introduction of a novel adaptive communication protocol in our mobile social network suite as well as in a novel robotic swarm application.