Sources of multidimensional data are becoming more prevalent, partly due to the rise of the Internet of Things (IoT), and so is the need to ingest and analyze data streams at rates higher than before. Some industrial IoT applications require ingesting millions of records per second, while processing queries on recently ingested and historical data. Unfortunately, existing database systems targeting multidimensional data exhibit low per-node ingestion performance, and even if they can scale horizontally in distributed settings, they require large number of nodes to meet such ingest demands. For this reason, in this paper we present a single-node datastore able to ingest multidimensional sensor data at very high rates. Its design centers around a two-level indexing structure, wherein the global index is an in-memory R*-tree and the local indices are serialized kd-trees. This study is confined to records with numerical indexing fields and range queries, and covers ingest throughput, query response time, and storage footprint. We show that the adopted design streamlines data ingestion and offers ingress rates two orders of magnitude higher than those of a selection of open-source database systems, namely Percona Server, SQLite, and Druid. Our prototype also reports query response times comparable to or better than those of Percona Server and Druid, and compares favorably in terms of storage footprint. We believe the experience reported here is valuable to researchers and practitioners interested in building database systems for high-velocity multidimensional sensor data.

Multi-tenant virtualized infrastructures allow cloud providers to minimize costs through workload consolidation. One of the largest costs is power consumption, which is challenging to understand in heterogeneous environments. We propose a power modeling methodology that tackles this complexity using a divide-and-conquer approach. Our results outperform previous research work, achieving a relative error of 2% on average and under 4% in almost all cases. Models are portable across similar architectures, enabling predictions of power consumption before migrating a tenant to a different hardware platform. Moreover, we show the models allow us to evaluate colocations of tenants to reduce overall consumption.

Adaptive Resource-Centric Computing (ARCC) enables a simultaneous mix of high-throughput parallel, real-time, and interactive applications through automatic discovery of the correct mix of resource assignments necessary to achieve application requirements. This approach, embodied in the Tessellation manycore operating system, distributes resources to QoS domains called cells. Tessellation separates global decisions about the allocation of resources to cells from application-specific scheduling of resources within cells. We examine the implementation of ARCC in the Tessellation OS, highlight Tessellation's ability to provide predictable performance, and investigate the performance of Tessellation services within cells.

We investigate proactive dynamic load balancing on multicore systems, in which threads are continually migrated to reduce the impact of processor/thread mismatches to enhance the flexibility of the SPMD-style programming model, and enable SPMD applications to run efficiently in multiprogrammed environments. We present Juggle, a practical decentralized, user-space implementation of a proactive load balancer that emphasizes portability and usability. Juggle shows performance improvements of up to 80% over static balancing for UPC, OpenMP, and pthreads benchmarks. We analyze the impact of Juggle on parallel applications and derive lower bounds and approximations for thread completion times. We show that results from Juggle closely match theoretical predictions across a variety of architectures, including NUMA and hyper-threaded systems. We also show that Juggle is effective in multiprogrammed environments with unpredictable interference from unrelated external applications.

In order to accommodate different requirements of reliable multicast applications, the real-time reliable multicasting support framework must possess generic yet rich features for detecting and reporting message losses with tight latency bounds. One highly promising concrete formulation of a multicast framework is the Real-time Multicast & Memory Replication Channel (RMMC) scheme. In this paper, we present the Delay-Bounded Reliable RMMC (DBR-RMMC) scheme, which extends the RMMC scheme in order to yield tight bounds on the latencies in detecting and reporting message losses over RMMCs and to enable application layer to initiate timely recovery actions. The DBR-RMMC scheme offers an API that allows application developers to freely explore the various design dimensions of reliable multicast applications while assuring timeliness. We also discuss a middleware subsystem devised to support DBRRMMC, followed by a summary of several analytical results on the bounds for latencies in reacting to the occurrence of a message loss. Experiments involving a real-time video streaming application have been conducted and encouraging results are presented.

Highly desirable types of networked multimedia applications should adapt to changes in the environmental conditions in which they operate, such as communication bandwidth, available memory, and battery lifetime, while providing the best possible quality of service (QoS). In this paper we present a software architecture that facilitates the development of adaptive networked multimedia applications which meet this requirement. The proposed software architecture is based on the Time-triggered Message-triggered Object (TMO) programming scheme and it is implemented as a thin layer on top of the TMO Support Middleware (TMOSM). The new layer, called the QoS Adaptation Support Layer (QASL), includes monitoring and runtime reconfiguration facilities that allow us to easily incorporate QoS-adaptation capabilities into TMO-based multimedia applications. In addition, we introduce a novel, practical approach for establishing the QoS configurations that guide the adaptive behavior of a networked multimedia application. A QoS configuration contains a set of parameters that specify the quality-related characteristics of the media streams which a receiver expects from a sender. We also present a strategy used in QASL for selecting, from a given set of QoS configurations, an optimal configuration by reflecting currently observed environmental conditions. Finally, the effectiveness of the QoS-adaptation mechanisms implemented in QASL is evaluated with the use of a heterogeneous network based multi-party videoconference application.

This paper discusses the benefits of exploiting 1) the principle of global-time-based coordination of distributed computing actions (TCoDA) and 2) a high-level component-/object-based programming approach in developing real-time embedded computing software. The benefits are discussed in the context of a concrete case study. A new major type of distributed multimedia processing applications, called Adaptive Distributed Sound Systems (ADSSs), is presented here to show the compelling nature of the TCoDA exploitation. High-quality ADSSs impose stringent real-time distributed computing requirements. They require a global-time base with precision better than 100 mus. For efficient implementation, the TMO programming scheme and associated tools are shown to be highly useful. In addition, a prototype TMO-based ADSS has been developed and its most important quality attributes have been empirically evaluated. The prototype ADSS has also turned out to be a cost-effective tool for assessing the quality of service of a TMO execution engine.

A hybrid approach to deriving tight execution-time bounds of program segments was proposed very recently. This approach symbiotically combines analytical and measurement-based methods to find a tight execution- time bound falling between the maximum measured execution time and an analytically derived loose bound. It also enables the estimation of the probability of the derived tight bound not being exceeded at run time. This paper provides a refined description of the hybrid approach and presents techniques for measuring the execution times of acyclic-path segments (APSs), which are possible execution sequences of instructions that contain no cycles and the basic units of analysis in the hybrid approach. In this paper, we also report the results of the hybrid approach in the derivation of tight execution-time bounds of three algorithms frequently used in the evaluation of WCET analysis techniques.

Enabling message communication among concurrent computing threads without relying on mutual exclusion (i.e., locking) is highly desirable in real-time computing systems. This paper presents a refined version of the Non-Blocking Buffer (NBB), which is a lock-free interaction mechanism that enables efficient event-message communication between a single producer thread and a single consumer thread. The NBB scheme presented here contains improvements over the previous version in two aspects. First, application designers now have the flexibility of choosing the consumer's retry strategy for the case when the buffer is empty but the producer is in the middle of inserting an item. Second, in the refined version the producer inserts pointers to data items into the buffer whereas the consumer obtains copies of the items. This design is consistent with the fact that shared heap management must be avoided to enable fully lock-free interaction between the producer and the consumer. This paper also discusses the approaches based on the NBB mechanism for supporting all conceivable producer-consumer scenarios.

Real-time CORBA is a middleware standard that has demonstrated successes in developing distributed, realtime, and embedded (DRE) systems. Customizing real-time CORBA for an application can considerably reduce the size of the middleware and improve its performance. However, customizing middleware is an error-prone task and requires deep knowledge of the CORBA standard as well as the middleware design. This paper presents ZEN-kit, a graphical tool for customizing RTZen (an RTSJ-based implementation of real-time CORBA). This customization is achieved through modularizing the middleware so that features may be inserted or removed based on the DRE application requirements. This paper presents three main contributions: 1) it describes how real-time CORBA features can be modularized and configured in RTZen using components and aspects, 2) it provides a configuration strategy to customize real-time middleware to achieve low-footprint ORBs, and 3) it presents ZEN-kit, a graphical tool for composing customized real-time middleware.

The real-time specification for Java (RTSJ) offers the predictable memory management needed for real-time applications, while maintaining Java 's advantages of portability and ease of use. RTSJ's scoped memory allows object lifetimes to be controlled in groups, rather than individually as in C++. While easier than individual object lifetime management, scoped memory adds programming complexity from strict rules governing memory access across scopes. Moreover, memory leaks can potentially create jitter and reduce performance. To manage the complexities of RTSJ's scoped memory, we developed patterns and tools for RTZen, a real-time CORBA Object Request Broker (ORB). We describe four new patterns that enable communication and coordination across scope boundaries, an otherwise difficult task in RTSJ. We then present IsoLeak, a runtime debugging tool that visualizes the scoped hierarchies of complex applications and locates memory leaks. Our empirical results show that RTZen is highly predictable and has acceptable performance. RTZen therefore demonstrates that the use of patterns and tools like IsoLeak can help applications meet the stringent QoS requirements of DRE applications, while supporting safer, easier, cheaper and faster development in real-time Java.