Yu-Ping Wang

A New Watermarking Method for 3D Models Based on Integral Invariants

In this paper, we propose a new semi-fragile watermarking algorithm for the authentication of 3D models based on integral invariants. A watermark image is embedded by modifying the integral invariants of some of the vertices. In order to modify the integral invariants, the positions of a vertex and its neighbors are shifted. To extract the watermark, all the vertices are tested for the embedded information, and this information is combined to recover the watermark image. The number of parts of the watermark image that can be recovered will determine the authentication decision. Experimental tests show that this method is robust against normal use modifications introduced by rigid transformations, format conversions, rounding errors, etc., and can be used to test for malicious attacks such as mesh editing and cropping. An additional contribution of this paper is a new algorithm for computing two kinds of integral invariants.

PF-Miner: A New Paired Functions Mining Method for Android Kernel in Error Paths

Drivers are significant components of the operating systems(OSs), and they run in kernel mode. Generally, drivers have many errors to handle, and the functions called in the normal execution paths and error handling paths are in pairs, which are named as paired functions. However, some developers do not handle the errors completely as they forget about or are unaware of releasing the acquired resources, thus memory leaks and other potential problems can be easily introduced. Therefore, it is highly valuable to automatically extract paired functions for these problems and detect violations for the programmers. This paper proposes an efficient tool named PF-Miner, which can automatically extract paired functions and detect violations between normal execution paths and error handling paths from the source code of C program with the data mining and statistical methods. We have evaluated PF-Miner on different versions of Android kernel 2.6.39 and 3.10.0, and 81 bugs reported by PF-Miner in 2.6.39 have been fixed before the latest version 3.10.0. PF-Miner only needs about 150 seconds to analyze the source code of 3.10.0, and 983 violations have been detected from 546 paired functions that have been extracted. We have reported the top 51 violations as potential bugs to the developers, and 15 bugs have been confirmed.

Optimization approach for 3D model watermarking by linear binary programming

Watermarking algorithms provide a way of hiding or embedding some bits of information in a watermark. In the case of watermarking a 3D model, many algorithms employ a so-called indexed localization scheme. In this paper, we propose an optimization framework with two new steps for such watermarking algorithms to improve their capacity and invisibility. The first step is to find an optimal layout of invariant units to improve capacity. The second step is to rearrange the correspondence between the watermark units and the invariant units to improve invisibility. Experimental tests show that by using this framework, the capacity and invisibility of watermarking algorithms can be greatly improved.

FDTL: a unified flash memory and hard disk translation layer

Flash memory and magnetic disks are two widely used forms of non-volatile storage in consumer electronics. Both forms of storage have their advantages and limitations. The present study describes the design and implementation of a unified flash memory and hard disk translation layer (FDTL) to improve the performance of hybrid storage containing flash memory and disk drives. In this scheme, randomly accessed and frequently read data are mapped into a flash device, whereas sequentially accessed, frequently written, and cold data are mapped into a disk drive. FDTL is a good fit for several kinds of consumer electronics that demand large capacity storage and require high throughput, low energy consumption, and low cost. A trace-driven simulation was implemented to evaluate FDTL. Experimental results show that the I/O performance of FDTL is superior to other storage schemes with similar capacity. FDTL increases the throughput by over 40% and saves energy by 28% compared with other storages schemes.

Optimizing random write performance of FAST FTL for NAND flash memory

The NAND flash memory has gained its popularity as a storage device for consumer electronics due to its higher performance and lower power consumption. In most of these devices, an FTL (Flash Translation Layer) is adopted to emulate a block device interface to support the conventional disk-based file systems that make the flash management much easier. Among various FTLs, the FAST (Fully-Associative Sector Translation) FTL has shown superior performance, becoming one of the state-of-the-art approaches. However, the FAST FTL performs poorly while dealing with a huge number of small-sized random writes brought by upper applications such as database transaction processing workloads. The two important reasons are the absence of efficient selection schemes for the reclaiming of random log blocks that leads to large overhead of full merges, and the sequential log block scheme which no longer applies to random writes due to the large costs of partial merges. To overcome the above two defects in the presence of random writes, two techniques have been proposed. The first technique reduced full merge costs by adopting a novel random log block selection algorithm, based on the block associativity and the relevant-valid-page-amount of random log blocks as the key block selection criterion. The second technique replaced the sequential log block with a random log block to eliminate the overhead of partial merges. Experimental results showed that our optimizations can outperform FAST FTL significantly in three aspects: erase counts, page migration amount, and response time. The maximum improvement level in these cases could reach up to 66.8%, 98.2%, and 51.0%, respectively.

Runtime Checking for Paired Functions in Device Drivers

Device drivers usually invoke functions to allocate resources for managing hardware devices and communicating with the kernel, and these resources should be released by functions when the work is finished. Thus allocating functions and releasing functions must be invoked in pairs. However, many developers ignore this vital rule, and some allocated resources are not released in time, which may cause resource related problems like deadlocks and memory leak. For improving the resource management of device drivers, we propose an approach named Pair Dyn to check these paired functions during runtime. When the driver runs, Pair Dyn records the runtime information of allocating functions such as key parameters and return value, and dynamically detects whether the relevant releasing functions are invoked to free allocated resources during runtime. Before the driver exits, Pair Dyn automatically attempts to invoke the related releasing functions which are lacked in runtime, in order to free the allocated resources of the operation system. We have implemented Pair Dyn with the LLVM compiler infrastructure, and make the evaluation with four real device drivers in Linux version 3.10.1. The experimental result shows that with the low extra overhead, Pair Dyn can provide effective runtime checking for allocate-release paired functions. Moreover, 9 potential bugs are found in the four drivers, which are all fixed automatically before exiting. Finally, no manual modification of the source code is needed with Pair Dyn.

PAB: Parallelism-Aware Buffer Management Scheme for Nand-Based SSDs

Recently, internal buffer module and multi-level parallel components have already become the standard elements of SSDs. The internal buffer module is always used as a write cache, reducing the erasures and thus improving overall performance. The multi-level parallelism is exploited to service requests in a concurrent or interleaving manner, which promotes the system throughput. These two aspects have been extensively discussed in the literature. However, current buffer algorithms cannot take full advantage of parallelism inside SSDs. In this paper, we propose a novel write buffer management scheme called Parallelism-Aware Buffer (PAB). In this scheme, the buffer is divided into two parts named as Work-Zone and Para-Zone respectively. Conventional buffer algorithms are employed in the Work-Zone, while the Para-Zone is responsible for reorganizing the requests evicted from Work-Zone according to the underlying parallelism. Simulation results show that with only a small size of Para-Zone, PAB can achieve 19.2% ~ 68.1% enhanced performance compared with LRU based on a page-mapping FTL, while this improvement scope becomes 5.6% ~ 35.6% compared with BPLRU based on the state-of-the-art block-mapping FTL known as FAST.

ISRA-Based Grouping: A Disk Reorganization Approach for Disk Energy Conservation and Disk Performance Enhancement

Reducing disk energy consumption and improving disk performance in high-performance computer systems are increasingly pressing issues for reasons of disk economy and efficiency. To achieve these goals, we define the concept of Immediate Successor Relationship Amount (ISRA) to represent the successor relationship of data blocks, and propose an ISRA-based grouping algorithm for disk reorganization, based on an undirected graph. We group data blocks that experience frequent successive accesses, then sort them using a merge-sort-like algorithm to determine the position of every group as well as the new position of every block within those groups. We evaluate our approach in terms of disk seek time and disk energy consumption, using Disksim and the log energy model. The results show clearly that both disk seek time and the energy needs can be reduced by about 50 percent.

Mining and checking paired functions in device drivers using characteristic fault injection

ContextDevice drivers often call specific kernel interface functions in pairs to allocate and release resources, and these functions can be called as paired functions. But due to poor documentation and carelessness, developers sometimes misuse paired functions in drivers, which causes resource-usage violations. ObjectiveMany dynamic approaches have been proposed to mine API rules and check resource usage for user-mode applications, but they are rarely applied to kernel-mode device drivers due to their designs. Meanwhile, most existing dynamic approaches lack systematic mechanisms to cover error handling code, which limits their availability and scalability. Our goal is to improve dynamic analysis to solve these problems. MethodIn this paper, we propose PairCheck, a novel approach for mining and checking paired functions in device drivers, using three techniques. Firstly, we design a characteristic fault injection framework to generate test cases, which simulates occasional errors and covers most error handling code with little effort. Secondly, complete runtime information is recorded through call interception during test-case execution. Thirdly, we mine and check paired functions based on collected runtime information, name patterns and statistical analysis. ResultTo validate the availability of PairCheck, we evaluate it on 11 Linux Ethernet card drivers. PairCheck mines 37 and 43 real paired functions in Linux 3.1.1 and 3.17.2, respectively. With these mined paired functions, it finds 10 violations in Linux 3.1.1 which have been fixed in 3.17.2, and 35 new violations in 3.17.2. The replies from developers indicate the false positive rate is low. Compared to normal execution, code coverage increases by 8.3% on average. ConclusionOur work shows that it is possible to precisely mine API rules of resource usage by using characteristic fault injection. The mined rules are useful for improving the reliability of device drivers.

Advanced graph model for tainted variable tracking

The reliability of hardware devices is of critical importance to the overall stability of operating systems. Drivers assume that hardware devices always work normally, but this assumption may cause drivers or systems to crash, since hardware device failures occur frequently. This can lead to incorrect values for drivers and cause them to malfunction. This paper proposes an advanced graph model for tainted variable tracking. The proposed approach can efficiently find variables, which are related to values read from hardware devices. It can also be used for variable assignment tracking, which is of great benefit in improving the reliability of hardware devices and drivers.