General-purpose Operating System Research Articles

Integrated Scheduling for a Reliable Dual-OS Monitor

Virtualization solutions aimed at the consolidation of a real-time operating system (RTOS) and a general-purpose operating system (GPOS) onto the same platform are gaining momentum as high-end embedded systems increase their computation power. Among them, the most extended approach for scheduling both operating systems consists of executing the GPOS only when the RTOS becomes idle. Although this approach can guarantee the real-time performance of the RTOS tasks and interrupt handlers, the responsiveness of GPOS time-sensitive activities is negatively affected when the RTOS contains compute-bound activities executing with low priority. In this paper, we modify a reliable hardware-assisted dual-OS virtualization technique to implement an integrated scheduling architecture where the execution priority level of the GPOS and RTOS activities can be mixed with high granularity. The evaluation results show that the proposed approach is suitable for enhancing the responsiveness of the GPOS time-sensitive activities without compromising the reliability and real-time performance of the RTOS.

Methods of assessing the time efficiency in the virtual measurement systems

The paper presents the analysis of the time measurement methods in the virtual instrumentation. Problem of the software operations time efficiency assessment is presented. Different methods and functions of the time measurement in the integrated programming environments are discussed. Experiments using the exemplary virtual instrument are conducted to reveal the advantages and disadvantages of particular time measurement methods. Both general purpose and Real-Time operating systems are considered. Experiments cover personal computers, and specialized systems, such as CompactRIO. Conclusions include the analysis of the possible approaches to the time-efficient instrument design and future applications of the presented methods.

Gang scheduling istn't worth it ... yet

The hardware trend toward higher core counts will likely result in a dynamic, bursty and interactive mix of parallel applications in personal and server computing. We investigate whether gang scheduling can provide performance benefits for applications in this scenario. We present a systematic study of the conditions under which gang scheduling might be better than classical general-purpose OS scheduling, and derive a set of necessary conditions on the workload. We find that these conditions are rarely met today, except in a small subset of workloads, for which we give an example. However, we propose that this subset is potentially important in the future, if (for example) parallel algorithms become increasingly used for real-time computer-human interaction.

RTiK-Linux: 리눅스용 실시간 이식 커널의 설계

첨단 군사 체계를 위한 측정 장치의 필요성에 따라 낮은 지연을 추구하는 실시간 특성인 시간 결정성과 수행의 정확성은 매우 중요해 졌으며, 이러한 이유로 리눅스와 같은 범용 운영체제에 실시간 기능을 추가하는 시장 요구가 증대하게 되었다. 따라서 RTLinux와 RTAI가 리눅스기반의 이중 커널로 개발되었다. RT-Linux의 경우 경성 실시간성을 제공하지만 어셈블러를 사용해야함으로 개발자가 다루기 어려운 단점이 존재한다. 또한 RTAI의 경우 연성 실시간성만을 제공하는 단점이 있다. 이러한 단점을 해결하기 위해 RTiK-Linux를 개발하였다. 본 논문에서는 리눅스에 경성 실시간 특징을 가지며 새로운 이중 커널 구조인 실시간 이식 커널인 RTiK-Linux를 제안한다. 먼저 관련 연구에 대한 소개를 하고, 타이머 설정 값과 거의 일치하는 분해능을 보장하는 설계 방법론을 기술한다. 그리고 경험적 측정으로 얻어진 결과를 보이고, 제안하는 RTiK-Linux를 검증 및 평가하기 위하여 그 결과를 분석한다. According to the necessity of measuring equipments for advanced military systems, real-time characteristics such as time determinism and execution accuracy pursuing low-latencies have become very important. With this reason, the market demand for real-time features in the general purpose operating system such as Linux has been enlarging. To meet these requirements, RTLinux and RTAI has been developed as dual-kernels based on Linux. However, developers should use assembler languages to facilitate real-time in RT-Linux, it is very difficult to deal with it. RTAI has disadvantage that it only provides soft real-time. To solve these problems, RTiK-Linux was developed. In this paper, we propose a new dual-kernel with hard real-time capabilities in Linux, called RTiK-Linux(Real-Time implemented Kernel for Linux). We first introduce related researches and then describe the design methodologies to guarantee the resolution which almost accords with the timer settings. Finally, we present the results of experimental measurements and analyze them in order to validate and evaluate the proposed RTiK-Linux.

Hard-Soft Real-Time Performance Evaluation of Linux RTAI Based Embedded Systems

A system is considered to be a hard real-time if all the computations are not only correct but their response is provided each time before a fixed deadline. Missing a deadline for such a system can possibly produce severe material damage or human health injury, therefore adequate testing and analysis should be done. This paper evaluates the suitability of a general purpose operating system like Linux with a real time extension. As it can be seen further on, Linux has overall good raw performance that can make it usable for an embedded system with industrial usage. To show the characteristics under full load stress, we have done several test cases for different scenarios that will be presented next in the paper.

Virtualization on Multicore for Industrial Real-Time Operating Systems [From Mind to Market

While much of the attention regarding virtualization in the software community has been focused on server applications, embedded applications can also benefit from the latest advances in multicore processors and hardware support for virtualization. Multicore processors offer a unique means to combine new features with legacy code and to host multiple operating systems (OSs) on a single platform. For example, a highly integrated system can be constructed with a real-time OS (RTOS) and a general-purpose OS (GPOS) running on separate cores of a single processor.

Securing Android-Powered Mobile Devices Using SELinux

Google's Android framework incorporates an operating system and software stack for mobile devices. Using a general-purpose operating system such as Linux in mobile devices has advantages but also security risks. Security-Enhanced Linux (SELinux) can help reduce potential damage from a successful attack.

Composition Kernel: A Software Solution for Constructing a Multi-OS Embedded System

Modern high-end embedded systems require both predictable real-time scheduling and high-level abstraction interface to their OS kernels. Since these features are difficult to be balanced by a single OS, some methods that accommodate multiple different versions of OS kernels, typically real-time OS and general purpose OS, into a single device have been proposed. The hybrid kernel, one of those methods, executes a general purpose OS kernel as a task of real-time OS which can support those features with reasonable engineering effort. However when adapting the approach to various combinations of OS kernels, which is required in the real-world embedded system design, the engineering effort of modifying the kernel becomes not negligible. This article introduce a method called a composition kernel which uses a thin abstraction layer for accommodating kernels without making direct dependencies between them. The authors developed the abstraction layer on an SH-4A processor and executed kernels on top of it. The amount of modifications to the kernels was significantly smaller than that in related work, while introducing only negligible verhead to the performance of the kernels.

Verification-Purpose Operating System for Microprocessor System-Level Functions

Microprocessor system-level functions that provide hardware support for software are difficult to verify on FPGA prototypes. Traditional FPGA verification involves running a general-purpose operating system such as Linux. However, such a GPOS is difficult to control, and debug is inefficient. The verification-purpose operating system, on the other hand, simplifies debug and is easy to control. VPOS also significantly increases coverage over that of GPOS approaches.

Prediction-Based Micro-Scheduler: Toward Responsive Scheduling of General-Purpose Operating Systems

In this paper, we propose a novel scheduling technique to improve the responsiveness of a real-time process while maintaining relative execution rates of non-real-time processes, called the prediction-based micro-scheduler. It runs upon an existing macro-scheduler and it conditionally rearranges the scheduling pattern generated by the macro-scheduler based on urgent interval prediction and lock hold time prediction. The rearrangement occurs if one process seeks to enter a long nonpreemptible section and the operation is predicted to significantly disturb the future execution of a real-time process. We implemented the prototype on Linux 2.6.19. Experimental results show that the average OS latency of a real-time process is reduced up to 34 percent of the original one while still maintaining relative execution rates of non-real-time processes. Moreover, the performance degradation caused by the micro-scheduler does not exceed 5 percent.

Development of a laboratory model of SSSC using RTAI on Linux platform

This paper presents the implementation of Static Synchronous Series Compensator (SSSC) controller on Real Time Application Interface (RTAI) for Linux Operating System (OS). RTAI provides real-time capability to Linux General Purpose Operating System (GPOS) over and above the capabilities of non real-time Linux environment, e.g. access to TCP/IP, graphical display and windowing systems, file and database systems. Both Type II controllers, DC voltage and current scheduling controllers, are implemented in RTAI. To create a user friendly environment, Graphical User Interface (GUI) is developed in Linux OS in user space (non real-time) using a software available from Quasar Technologies (Qt). The controller is tested on a small scale laboratory model of a Voltage Source Converter (VSC) connected in series with a transmission line. The real time controller performs well in both inductive and capacitive regions.

Benchmarking the effects of operating system interference on extreme-scale parallel machines

We investigate operating system noise, which we identify as one of the main reasons for a lack of synchronicity in parallel applications. Using a microbenchmark, we measure the noise on several contemporary platforms and find that, even with a general-purpose operating system, noise can be limited if certain precautions are taken. We then inject artificially generated noise into a massively parallel system and measure its influence on the performance of collective operations. Our experiments indicate that on extreme-scale platforms, the performance is correlated with the largest interruption to the application, even if the probability of such an interruption on a single process is extremely small. We demonstrate that synchronizing the noise can significantly reduce its negative influence.

임베디드 리눅스 기반 산업용 무선 HMI 소프트웨어 모듈 설계 및 구현

Industrial HMI(Human Machine Interface) system is the main element among the factory automation processes and have been used to monitor and control operation and status of machine in factory with PLC. This HMI often brings heavy loads to the system development and difficult decreasing the system because it tends to use a specific system per each manufacturer. Therefore, in this thesis, we have developed an embedded linux-based embedded industrial HMI software modules which can be used for touch panel embedded system to solve these problem. In this module, we have used the Qt/Embedded software component because it can be used by all systems which support C++ compiler without modifying the existing codes. We can design more flexible system and network configuration because we have used the wireless communication module. In this thesis, we implement linux-based HMI software modules which are capable of wireless communication as well as bringing the mobility to the overall system and finally decreasing the system development loads by using the general purpose OS with competitive price.

HPC-Colony

Traditional full-featured operating systems are known to have properties that limit the scalability of distributed memory parallel programs, the most common programming paradigm utilized in high end computing. Furthermore, as processor counts increase with the most capable systems, the necessary activity to manage the system becomes more of a burden. To make a general purpose operating system scale to such levels, new technology is required for parallel resource management and global system management (including fault management). In this paper, we describe the shortcomings of full-featured operating systems and runtime systems and discuss an approach to scale such systems to one hundred thousand processors with both scalable parallel application performance and efficient system management.

Towards a framework for dedicated operating systems development in high-end computing systems

In the context of high-end computing systems, general-purpose operating systems impose overhead on the applications they support due to unneeded services. Although dedicated operating systems overcome this issue, they are difficult to develop or adapt. In this paper, we propose a framework, based on the component programming paradigm, which supports the development and adaptation of such operating systems. This framework makes possible the a la carte construction of operating systems which provide specific high-end computing system characteristics.

Virtual machines for enterprise desktop security

A virtual machine monitor (VMM) allows a single computer to run two or more operating systems at the same time. VMMs are relatively simple and are typically built to high assurance standards, which means that the quality of isolation provided by a virtual machine monitor is usually greater than that which can be achieved with a general-purpose operating system. This paper discusses how the flexibility afforded by multiple OS environments and the robust isolation provided by a virtual machine monitor can be used to improve client PC security. A prototype system is also described. This paper is neither a product announcement nor an official Microsoft position paper, but rather it is a discussion of interesting configuration options that can be constructed using existing Microsoft and third-party products: in this case two or more operating systems running in conjunction with a virtual machine monitor.

멀티미디어 태스크 지원을 위한 다단계 스케줄러

연성 실시간 특성을 가진 멀티미디어 응용 프로그램이 일정한 서비스 품질을 유지하고 수행되기 위해서는 커널 수준과 사용자 수준에서 실시간 처리를 요구한다. 본 연구에서는 널리 사용되는 범용 운영체제 환경에서 멀티미디어를 지원하는데 있어서 문제가 되는 부분을 살펴보고 이를 개선할 수 있는 다단계 스케줄러를 제안한다. 다단계 스케줄러는 사용자 피드백을 기반으로 스케줄링 정보를 생성하는 상위 스케줄러와 커널에 구현된 하위 스케줄러로 구성된다. 제안한 다단계 스케줄러를 리눅스에서 구현하고 성능 분석을 수행하였으며, 실험 결과, 제안한 방식이 시스템에 성능 저하를 발생시키지 않으면서 멀티미디어의 서비스 품질을 일정하게 보장하는 것을 확인하였다. General purpose operating systems are Increasingly being used for serving time-sensitive applications. These applications require soft real-time characteristics from the kernel and from other system-level services. In this paper, we explore various operating systems techniques needed to support time-sensitive applications and describe the design of MUSMA(Multi-level Scheduler for Multimedia Application). MUSMA is a framework that combination of user-level top scheduler and kernel-level bottom scheduler. We develope MUSMA in linux environment and it's performance is evaluated. Experiment result shows that it is possible to satisfy the constraints of multimedia in a general purpose operating system without significantly compromising the performance of non-realtime applications.

Packet Video Broadcasting with General-Purpose Operating Systems in an Ethernet

Video transmission with general-purpose PCs poses a number of requirements that radically differ from those of high-end dedicated video servers. We analyze the scenario of an Ethernet local area network in which a number of PCs are transmitting video streams, while other TCP/IP applications are also running concurrently. Our findings show that since the operating system clock resolution cannot cope with the transmission timing requirements the following holds: if the video transmission is performed with exact timing accuracy to maintain a constant rate then CPU load grows to 100%, thus blocking the PC for other user applicationss on the other hand, if transmission is performed in a bursty manner, i.e. with sleep system calls, then CPU load decreases dramatically but the increased burstiness of the video stream has a negative impact on network performance (for example, capture effect in the Ethernet). Furthermore, the impact of video transmission over the rest of TCP/IP applications running on the same network depends heavily on the packet size. We provide an integrated analysis of operating system and network parameters to achieve video broadcasting while preserving timing requirements and minimizing the impact on other applications.

Effects of clock resolution on the scheduling of interactive and soft real-time processes

It is commonly agreed that scheduling mechanisms in general purpose operating systems do not provide adequate support for modern interactive applications, notably multimedia applications. The common solution to this problem is to devise specialized scheduling mechanisms that take the specific needs of such applications into account. A much simpler alternative is to better tune existing systems. In particular, we show that conventional scheduling algorithms typically only have little and possibly misleading information regarding the CPU usage of processes, because increasing CPU rates have caused the common 100 Hz clock interrupt rate to be coarser than most application time quanta. We therefore conduct an experimental analysis of what happens if this rate is significantly increased. Results indicate that much higher clock interrupt rates are possible with acceptable overheads, and lead to much better information. In addition we show that increasing the clock rate can provide a measure of support for soft real time requirements, even when using a general-purpose operating system. For example, we achieve a sub-millisecond latency under heavily loaded conditions.

Combining Monitors for Runtime System Verification

Runtime verification permits checking system properties that cannot be fully verified off-line. This is particularly true when the system includes complex third-party components, such as general-purpose operating systems and software libraries, and when the properties of interest include security and performance. The challenge is to find reliable ways to monitor these properties in realistic systems. In particular, it is important to have assurance that violations will be reported when they actually occur. For instance, a monitor may not detect a security violation if the violation results from a series of system events that are not in its model.We describe how combining runtime monitors for diverse features such as memory management, security-related events, performance data, and higher-level temporal properties can result in more effective runtime verification. After discussing some basic notions for combining and relating monitors, we illustrate their application in an intrusion-tolerant Web server architecture under development at SRI.