International audience

In this paper we discuss how we architected and developed a parallel data loader for LeanXcale database. The loader is characterized for its efficiency and parallelism. LeanXcale can scale up and scale out to very large numbers and loading data in the traditional way it is not exploiting its full potential in terms of the loading rate it can reach. For this reason, we have created a parallel loader that can reach the maximum insertion rate LeanXcale can handle. LeanXcale also exhibits a dual interface, key-value and SQL, that has been exploited by the parallel loader. Basically, the loading leverages the key-value API and results in a highly efficient process that avoids the overhead of SQL processing. Finally, in order to guarantee the parallelism we have developed a data sampler that samples data to generate a histogram of data distribution and use it to pre-split the regions across LeanXcale instances to guarantee that all instances get an even amount of data during loading, thus g uaranteeing the peak processing loading capability of the deployment.

Emerging cloud applications like machine learning, AI and big data analytics require high performance computing systems that can sustain the increased amount of data processing without consuming excessive power. Towards this end, many cloud operators have started deploying hardware accelerators, like FPGAs, to increase the performance of computationally intensive tasks but increasing the programming complexity to utilize these accelerators. VINEYARD has developed an efficient framework that allows the seamless deployment and utilization of hardware accelerators in the cloud without increasing the programming complexity and offering the flexibility of software packages. This paper presents a modular approach for the acceleration of data analytics using FPGAs. The modular approach allows the automatic development of integrated hardware designs for the acceleration of data analytics. The proposed framework shows the data analytics modules can be used to achieve up to 3.5x speedup compared to high performance general-purpose processors.

Summary Using a central file server is good for interactive access to files, because of the coherency implied by a centralized design. In fact, within local area networks, this is a common case. However, distributed environments in use today may exhibit round‐trip times on the order of 50 or 100 ms. This is a problem for interactive file access to a central file server because of the resulting access times. Although aggressive caching and loosely synchronized replicas may be used for distributed file access, there are cases where the better coherency provided by a central server is still desirable. In this paper, we present ZX, a distributed file system and protocol designed with latency in mind. It can use caching, but it does not require caching or batching to address latency issues. ZX relies on a novel channel‐based file system interface. It includes find requests and leverages streaming requests to work well under high‐latency conditions. Unlike other protocols designed for distributed access to a central server, ZX tolerates round‐trip times on the order of 50 or 100 ms to access a central file server for interactive usage such as compiling shared sources, running binaries, editing documents, and other similar workloads. It can be used on UNIX using a FUSE adaptor while permitting native ZX speakers to run faster.

Summary The Nix operating system permits different roles to be assigned to the cores. One of the roles is to be able to run user‐space code with no interrupts from the operating system, which is particularly useful for high‐performance computing. System calls are especially expensive to a core playing this role. This paper presents a new implementation of optimistic semaphores that avoid performing expensive system calls in an uncontended scenario. The implementation is straightforward and somewhat unorthodox: a semaphore is based on a data structure and a lock that are shared between user space and kernel space. This study aims at evaluating if such an approach is viable. In addition, the implementation includes a non‐deterministic choice operation over a collection of semaphores, altsems. This novel operation facilitates the creation of higher‐level communication mechanisms, such as sockets and channels. To support this claim, we implemented a new kind of buffered communication channels named tubes, tailored for communicating processes running on different (heterogeneous) cores. The paper describes the implementation of the semaphores and the tubes, a comparative analysis of optimistic and non‐optimistic semaphores on Nix, and a comparative analysis of tubes and other kinds of communication channels that are available on the Nix operating system. Copyright © 2014 John Wiley & Sons, Ltd.

This article is focused on the system side of the multidisciplinary problem of building User Interface Management Systems (UIMS) for distributed and heterogeneous I/O devices. It presents a new architecture that decouples applications from their interfaces by using distributed synthetic file system interfaces (similar to /proc on UNIX) to export user interface elements and a new UIMS, O/live, following this approach. The UIMS has been in use for several years on a daily basis, in our laboratory and personal computers. It supports transparent distribution, replication, and migration of user interface elements among highly heterogeneous devices. Moreover, it is highly programmable without the need for special tools, which (a) facilitates experimentation and iteration for new human–computer interaction techniques and (b) enables the creation of orthogonal services to manipulate programmatically and independently the elements of the distributed UI. This article describes both the approach and the O/live UIMS and window system.

This paper describes SHAD, a novel architecture for security in pervasive computing environments, and a prototype implementation. SHAD is a peer-to-peer and human-centered security architecture. It is based in a general purpose personal device that manages the user's security: the UbiTerm. There are several other systems that, at first sight, seem to provide single sign-on in ubiquitous environments. We argue that they fail to do so in practice, and that SHAD offers for the first time a real SSO that works well in ubiquitous environments that require using multiple machines and services simultaneously. SHAD permits users to share their resources in an easy, natural, and intuitive way, even while being disconnected from the rest of the world. The architecture we propose is able to exploit context information, when it is available. It does not require hard administration tasks, and permits users to manage their own resources. We have been using SHAD for one year. This paper describes our prototype implementation, the experience using it, and some measures that confirm that our approach is reasonable in practice

It is difficult to build user interfaces that must be distributed over a set of dynamic and heterogeneous I/O devices. This difficulty increases when we want to split, merge, replicate, and relocate the UI across a set of heterogeneous devices, without the application intervention. Furthermore, using generic tools, e.g. to search for UI components or to save/restore them, is usually not feasible. We follow a novel approach for building UIs that overcomes these problems: using distributed file systems that export widgets to applications. In this paper we describe Omero, a UI server built along this line for the plan B operating system

The conventional approach for building pervasive environments relies on middleware to integrate different systems. Instead, we have built a system that can deal with these environments by exporting system resources through distributed virtual file systems. This requires no middleware, simplifies interoperation, and permits applying general purpose tools to any system resource. A constraint-based file system import mechanism allows the system to adapt to changes in the environment and permits users to customize the environment and tailor adaptation according to their needs. The system has been in use for over a year to carry out our daily work and is underlying the smart space that we built for our department

There is a huge effort in ongoing research on new middleware platforms and new distributed services to support ubiquitous environments and pervasive applications. Prototypes for smart spaces are sometimes used to demonstrate the need for a new particular service, piece of software, or middleware layer. However, we have found that we could easily build a smart space and some applications for it by relying on services already provided by the system we use daily, Plan 9 from Bell Labs. This paper explores how far can we go with a traditional system to support a ubiquitous environment, without using any middleware. We describe how to build a pervasive computing platform using Plan 9, and how we built a smart space to demonstrate this

The first decades of the new millennium will witness an explosive growth in the number and diversity of networked devices and portals. We foresee high degrees of mobility, heterogeneity, and interactions among computing devices connected to global networks. While previous research in distributed operating systems solved many problems related to resource management, they seldom addressed the problems of heterogeneity and dynamic adaptability. On the other hand, middleware solutions, like CORBA and Java/Jini, solve part of the heterogeneity problem by permitting seamless communication among different platforms. But, they do not address dynamic resource management and adaptability for applications requiring high-performance distributed computing. This paper presents 2K, an integrated operating system architecture that addresses the problems of resource management in heterogeneous networks, dynamic adaptability and configuration of component-based distributed applications.

Computer users are increasingly multi-device equipped and no longer sedentary. It is desirable that the execution environment in any of these devices be customized to the user preferences and to the device characteristics. This paper describes a framework for managing execution environments in 2K, an adaptable, distributed, network-centric, user- and application-oriented operating system aimed at accommodating change. A 2K environment is a container of components, devices and configuration parameters and provides an execution context for the user within the 2K distributed system. A user has a distributed execution environment that consists of several subenvironments running on different platforms or temporarily suspended to be resumed later. The management of the execution environments is designed to provide a user-centric view of the system; it facilitates user mobility, by liberating users from the restriction of being explicitly attached to specific platforms, and by seamlessly recruiting resources where they are available.

A large number of protection domain crossings and context switches is often the cause of bad performance in complex object-oriented systems. We have identified the CompositeCall pattern which has been used to address this problem for decades. The pattern modifies the traditional client/server interaction model so that clients are able to build compound requests that are evaluated in the server domain. We implemented CompositeCalls for both a traditional OS, Linux, and an experimental object-oriented μkernel, Off++. In the first case, we learned about implications of applying CompositeCall to a non-object-oriented ‘legacy’ system. In both experiments, we learned when CompositeCalls help improving system performance and when they do not help. In addition, our experiments gave us important insights about some pernicious design traditions extensively used in OS construction. Copyright © 2000 John Wiley & Sons, Ltd.