Erzhou Zhu

Performance Tuning Towards a KVM-based Embedded Real-Time Virtualization System

Virtualization is a fundamental component in cloud computing because it provides numerous guest VM transparent services, such as live migration, high availability, rapid checkpoint, etc. Utilizing virtualization technology to combine real-time operating system (RTOS) and off-the-shelf time-sharing general purpose operating system (GPOS) is attracting much more interest recently. Such combination has the potential to provide a large application base, and to guarantee timely deterministic response to real-time applications, yet there remain some issues, such as responsiveness of RTOS running on top of a virtual machine (VM), system performance and CPU resource utilization rate, etc. In this paper we propose an embedded real-time virtualization architecture based on Kernel- Based Virtual Machine (KVM), in which VxWorks and Linux are combined together. We then analyze and evaluate how KVM influences the interrupt-response times of VxWorks as a guest operating system. By applying several real-time performance tuning methods on the host Linux, we will show that sub-millisecond interrupt response latency can be achieved on the guest VxWorks. Furthermore, we also find out that prioritization tuning results in waste of CPU resources when RTOS is not executing real-time tasks, so we design a dynamic scheduling mechanism--co-scheduling to improve system performance. Experimental results with SPEC2000 and bonnie 1.4 load, show that this new architecture tuned by CPU shielding, prioritization and co-scheduling, can achieve better real-time responsiveness and system performance.

Constructing a Hybrid Taint Analysis Framework for Diagnosing Attacks on Binary Programs

For the purpose of discovering security flaws in software, many dynamic and static taint analyzing techniques have been proposed. By analyzing information flow at runtime, dynamic taint analysis can precisely find security flaws of software. However, on one hand, it suffers from substantial runtime overhead and is incapable of discovering the potential threats. On the other hand, static taint analysis analyzes program’s code without actually executing it which incurs no runtime overhead, and can cover all the code, but it is often not accurate enough. In addition, since the source code of most software is hard to acquire and intruders simply do not attach target program’s source code in practice, software flaw tracking becomes rather complicated. In order to cope with these issues, this paper proposes HYBit, a novel hybrid framework which integrates dynamic and static taint analysis to diagnose the flaws or vulnerabilities for binary programs. In the framework, the source binary is first analyzed by the dynamic taint analyzer. Then, with the runtime information provided by its dynamic counterpart, the static taint analyzer can process the unexecuted part of the target program easily. Furthermore, a taint behavior filtration mechanism is proposed to optimize the performance of the framework. We evaluate our framework from three perspectives: efficiency, coverage, and effectiveness. The results are encouraging.

Two-phase execution of binary applications on CPU/GPU machines

High computational power of GPUs (Graphics Processing Units) offers a promising accelerator for general-purpose computing. However, the need for dedicated programming environments has made the usage of GPUs rather complicated, and a GPU cannot directly execute binary code of a general-purpose application. This paper proposes a two-phase virtual execution environment (GXBIT) for automatically executing general-purpose binary applications on CPU/GPU architectures. GXBIT incorporates two execution phases. The first phase is responsible for extracting parallel hot spots from the sequential binary code. The second phase is responsible for generating the hybrid executable (both CPU and GPU instructions) for execution. This virtual execution environment works well for any applications that run repeatedly. The performance of generated CUDA (Compute Unified Device Architecture) code from GXBIT on a number of benchmarks is close to 63% of the hand-tuned GPU code. It also achieves much better overall performance than the native platforms.

HYBit: A Hybrid Taint Analyzing Framework for Binary Programs

For the purpose of discovering security flaws in software, many dynamic and static taint analyzing techniques have been proposed. The dynamic techniques can precisely find the security flaws of the software; but it suffers from substantial runtime overhead. On the other hand, the static techniques require no runtime overhead; but it is often not accurate enough. In this paper, we propose HYBit, a novel hybrid framework which integrates dynamic and static taint analysis to diagnose the security flaws for binary programs. In the framework, the source binary is first analyzed by the dynamic taint analyzer; then, with the runtime information provided by its dynamic counterpart, the static taint analyzer can process the unexecuted part of the target program easily. Furthermore, a taint behavior filtration mechanism is proposed to optimize the performance of the framework. We evaluate our framework from three perspectives: efficiency, coverage, and effectiveness, and the results are encouraging.

SINOF: A dynamic-static combined framework for dynamic binary translation

Dynamic binary translation (DBT) is an important technique in virtualization, and in migrating legacy binaries to platforms based on a new architecture. However, poor profile information limits the process of optimization at runtime, so the DBT system may suffer from substantial overhead. In this paper, we design and implement a static-integrated optimization framework (SINOF) to improve the runtime performance for DBT. Combining static and dynamic approaches can greatly reduce the overhead of optimizing, profiling and translating for any program that runs repeatedly. Under this framework, once the source image has been executed, the profile information and target code will be saved in a software cache, and will be available for future runs. In the static phase, the saved code is analyzed and optimized based on the information collected in the previous run. Especially, we reorganize the code layout of the software cache. Experimental results show that the proposed framework can reduce run time by more than 30% on average compared to the original versions of DBT that the framework is based on.

Study of an Improved Genetic Algorithm for Multiple Paths Automatic Software Test Case Generation

Automatic generation of test case is an important means to improve the efficiency of software testing. As the theoretical and experimental base of the existing heuristic search algorithm, genetic algorithm shows great superiority in test case generation. However, since most of the present fitness functions are designed by a single target path, the efficiency of the generating test case is relatively low. In order to cope with this problem, this paper proposes an efficiency genetic algorithm by using a novel fitness function. By generating multiple test cases to cover multiple target paths, this algorithm needs less iterations hence exhibits higher efficiency comparing to the existing algorithms. The simulation results have also shown that the proposed algorithm is high path coverage and high efficiency.

AFOA: An Adaptive Fruit Fly Optimization Algorithm with Global Optimizing Ability

With the development of intelligent computation technology, the intelligent evolution algorithms have been widely applied to solve optimization problem in the real world. As a novel evolution algorithm, fruit fly optimization algorithm (FOA) has the advantages of simple operation and high efficiency. However, FOA also has some disadvantages, such as trapping into local optimal solution easily, failing to traverse the problem domain and limiting the universality. In order to cope with the disadvantages of FOA while retain it merits, this paper proposes AFOA, an adaptive fruit fly optimization algorithm. AFOA adjusts the swarm range parameter V dynamically and adaptively according to the historical memory of each iteration of the swarm, and adopts the more accurate elitist strategy, which is therefore very effective in both accelerating the convergence of the swarm to the global optimal front and maintaining diversity of the solutions. The convergence of the algorithm is firstly analyzed theoretically, and then 14 benchmark functions with different characteristics are executed to compare the performance among AFOA, PSO, FOA, and LGMS-FOA. The experimental results have shown that, AFOA algorithm is a new algorithm with global optimizing capability and high universality.

Study of a Secret Information Transmission Scheme Based on Invisible ASCII Characters

This paper proposes a secret information transmission scheme for English texts by using the characteristics of invisible ASCII codes. The scheme incorporates two stages, the information hiding stage and the information extracting stage. The first stage takes the prepared carrier documents and the secret information need to be embedded as the input. Then, the information hiding procedure of the scheme will synthesize the carrier document and the secret information into a stego document. In the second stage, an extracting procedure will pick up the secret information when it receives the stego document that generated by the first stage. The scheme achieves hiding effects by processing the bland spaces in the English texts. The experimental results have shown that our information hiding scheme is feasible, reliable, safe and efficient.

Partitioning the Conventional DBT System for Multiprocessors

Noticeable performance improvement via ever-increasing transistors is gradually trapped into a predicament since software cannot logically and efficiently utilize hardware resource, such as multi-core resource. This is an inevitable problem in dynamic binary translation (DBT) system as well. Though special purpose hardware as aide tool, through some interfaces, provided by DBT enables the system to achieve higher performance, the limitation of it is significant, that is, it is impossible to be used widely by another one. To overcome this drawback, we focus on building compatible software architecture to acquire higher performance without platform dependence. In this paper, we propose a novel multithreaded architecture for DBT system through partitioning distinct function module, which is to adequately utilize multiprocessors resource. This new architecture devides couples the common DBT system (DBTs) working routine into dynamic translation, optimization, and translated code execution phases, and then ramifies them into different threads to enable them concurrently executed. In this new architecture, several efficient novel methods are presented to cope with intractable work that puzzles most researchers, such as communication mechanism, cache layout, and mutual exclusion between threads. Experimental results using SPECint 2000 indicate that this new architecture for DBT system can achieve higher performance — speed up the traditional DBT system by about average 10.75%, with better CPU utilization.

A Translation Framework for Virtual Execution Environment on CPU/GPU Architecture

GPUs are many-core processors with tremendous computational power. However, as automatic parallelization has not been realized yet, developing high-performance parallel code for GPUs is still very challenging. The paper presents a novel translation framework designed for virtual execution environment based on CPU/GPU architecture. It addresses two major challenges of taking advantage of general purpose computation on graphics processing units (GPGPU) to improve performance: no rewriting the existing source code and resolving binary compatibility issues between different GPUs. The translation framework uses semi-automatic parallelization technology to port existing code to explicitly parallel programming models. It not only offers a mapping strategy from X86 platform to CUDA programming model, but also synchronizes the execution between the CPU and the GPUs. The input to our translation framework is parallelizable part of the program within binary code. With an additional information related to the parallelizable part, the translation framework transforms the sequential code into PTX code and execute it on GPUs. Experimental results on several programs from CUDA SDK Code Samples and Parboil Benchmark Suite show that our translation framework could achieve very high performance, even up to several tens of times speedup over the X86 native version.