Shuichi Oikawa

Portable RK: a portable resource kernel for guaranteed and enforced timing behavior

Portable RK is a portable implementation of a resource kernel, a resource-centric approach to build a real-time kernel that provides explicit timely, guaranteed, and enforced access by applications to system resources. Portable RK is designed to work with widely available operating systems with minimal changes. This facilitates experimentation in familiar software environments and helps the faster deployment of research results. Execution in resource kernels is directly based on OS-enforced resource reservation. As a result, an application can request the reservation of a certain amount of a resource, and the kernel can guarantee that the requested amount is available to that application in timely fashion. We describe the design and implementation of Portable RK called Linux/RK that resides within the Linux kernel. The evaluation results show that Portable RK in the form of Linux/RK gives direct control over timely resource utilization by applications and that its overhead costs are small enough to be negligible.

User-level real-time threads

Continuous-media applications require more efficient and flexible support from real-time threads than traditional real-time systems. It includes functionalities such as the dynamic management of thread attributes and the support of multiple thread models. We describe the design and implementation of user-level real-time threads on the RT-Mach micro kernel. Since they are implemented at user-level, both of the fast management of thread attributes and the support of multiple thread models are possible.<<ETX>>

Accounting system: a fine-grained CPU resource protection mechanism for embedded system

In ubiquitous computing environments, our daily lives will be made convenient by embedded intelligent devices. Those devices, such as car navigation systems, personal digital assistances, and cellular phones, provide various kinds of the complex services. Those devices are networked with each other and provide complicated services, through the Internet. While they provide useful services, there is an increasing possibility of security attacks, which include the unexpected execution of unsecure codes. Current information appliances have not yet fully embodied a resource protection mechanism that prevents misbehaved applications from consuming the whole CPU capacity of system resources. In this paper, we propose accounting system, and describe its design and implementation. The system is a resource monitoring and restriction system that has the purpose of improving the systems reliability and security. We developed the system on Linux. Our system is a very generic to offer various services, such as security improvement, overload control, and class-based accounting, that require CPU resource control

Integrating memory management with a file system on a non-volatile main memory system

Non-volatile (NV) memory technologies have been advanced significantly in recent years. As its performance, including faster access speed, larger capacity, and cheaper costs, improves, it has stimulated the active researches on its use for main memory or storage devices. These researches were, however, conducted independently. The fact that NV memory can be used for both main memory and storage devices means that their management can be integrated. Their integration based on NV memory enables the improvement of system performance because the size of main memory is increased and page swapping needs to be invoked much less frequently. This paper proposes a method of such integration along with its implementation for the Linux kernel. To the best of our knowledge, we are among the first to design and implement the integration. The evaluation results performed by executing Linux on a system emulator show the feasibility and efficiency of the proposed integration method.

Hybrid OpenCL: Connecting Different OpenCL Implementations over Network

We are developing Hybrid OpenCL, which enables the connection between different OpenCL implementations over the network. Hybrid OpenCL consists of two elements, a runtime system that provides the abstraction of different OpenCL implementations and a bridge program that connects multiple OpenCL runtime systems over the network. Hybrid OpenCL enables the construction of the scalable OpenCL environments. It enables applications written in OpenCL to be easily ported to high performance cluster computers; thus, Hybrid OpenCL can provide more various parallel computing platforms and the progress of utility value of OpenCL applications. This paper describes the implementation of Hybrid OpenCL and its results from experimentation. The experimental results show that the overhead introduced by Hybrid OpenCL is minimum and can be amortized by actual data processing time.

Task Grain Scheduling for Hypervisor-Based Embedded System

The emergence of functional embedded systems such as cell-phones and digital appliances brought up a new issue, building a system supporting both real-time and rich services. One of the solutions is leveraging a hypervisor to integrate an RTOS and a commodity OS into a single device. However, this approach induces the limitation of application deployment; all the high priority tasks should reside in the RTOS. In this paper, we propose a task grain scheduling for a real-time hypervisor, which enables a flexible application deployment between an RTOS and a commodity OS. We constructed a prototype system with an existing hypervisor, an RTOS, and a commodity OS. We measured some basic overheads, and fixed some tasks which were missing their deadlines using the task grain scheduling to meet their deadlines. The overheads were small and the task grain scheduling achieved a flexible real-time scheduling for the hypervisor based system.

Efficient timing management for user-level real-time threads

Timing management for user-level real-time threads can be done with appropriate support of the kernel. When a specified time comes, the kernel makes a virtual processor to upcall a user-level scheduler for its timing management. Then, the timing management can suffer from the overhead of a user-level scheduler. The paper presents an efficient timing management mechanism for user-level real-time threads. By sharing user-level timers through the shared kernel/user structure and keeping the appropriate hints for them, redundant processing of them and events can be eliminated. The results of the performance evaluations show that the upcall performance of our user-level real-time threads is comparable to and more stable than that of kernel-provided real-time threads.

Mesovirtualization: lightweight virtualization technique for embedded systems

These days, embedded and ubiquitous devices are becoming feature rich, and multiprocessor architectures for those devices are on the horizon. In order to utilize the resources of multiprocessor systems efficiently and securely, virtual machine monitors (VMMs) have been common among servers and desktop systems. The same can be applied if the cost of virtualization becomes much less expensive. In this paper, we introduce mesovirtualization, a new lightweight virtualization technique. Mesovirtualization makes VMMs smaller and requires only a few modifications for the guest operating system (OS) source code. We designed and implemented a VMM named Gandalf according to mesovirtualization. Our experimental results show that Linux on Gandalf performs better than Xen-Linux. Therefore, mesovirtualization makes virtualization environments suitable for embedded and ubiquitous devices.

Resource kernels: a resource-centric approach to real-time and multimedia systems

We consider the problem of OS resource management for real- time and multimedia systems where multiple activities with different timing constraints must be scheduled concurrently. Time on a particular resource is shared among its users and must be globally managed in real-time and multimedia systems. A resource kernel is meant for use in such systems and is defined to be one which provides timely, guaranteed and protected access to system resources. The resource kernel allows applications to specify only their resource demands leaving the kernel to satisfy those demands using hidden resource management schemes. This separation of resource specification from resource management allows OS-subsystem- specific customization by extending, optimizing or even replacing resource management schemes. As a result, this resource-centric approach can be implemented with any of several different resource management schemes. We identify the specific goals of a resource kernel: applications must be able to explicitly state their timeliness requirements; the kernel must enforce maximum resource usage by applications; the kernel must support high utilization of system resources; and an application must be able to access different system resources simultaneously. Since the same application consumes a different amount of time on different platforms, the resource kernel must allow such resource consumption times to be portable across platforms, and to be automatically calibrated. Our resource management scheme is based on resource reservation and satisfies these goals. The scheme is not only simple but captures a wide range of solutions developed by the real-time systems community over several years. One potentially serious problem that any resource management scheme must address is that of allowing access to multiple resources simultaneously and in timely fashion, a problem which is known to be NP-complete. We show that this problem of simultaneous access to multiple resources can be practically addressed by resource decoupling and resolving critical resource dependencies immediately. Finally, we demonstrate our resource kernels functionality and flexibility in the context of multimedia applications which need processor cycles and/or disk bandwidth.

Adaptive object management for a reconfigurable microkernel

Generic mechanisms and policies provided by the existing operating system kernels cannot satisfy requirements of the current and future applications especially in mobile system environments. An operating system kernel needs to be adaptable, customizable, and extensible to cope with the changes of a computation environment and requirements from applications. This paper introduces a DKM (Dynamic Kernel Module) as a mechanism and the DKM server as a service to reconfigure RT-Mach. A DKM is an extension of a LKM (Loadable Kernel Module), which is provided by UNIX kernels to extend their functionality dynamically. The DKM server manages their load and detachment. It must be programmable not to lose the flexibility of their management but to be reconfigurable to cope with a variety of applications and systems.