MISRA-C is a writing specification for the C programming language defined by the Motor Industry Software Reliability Association (MISRA). It establishes a set of rules to enhance the development of software that is safe, reliable, and portable. MISRA-C is widely adopted by industries such as aerospace, defense and security, telecommunications, and medical device manufacturers. We developed a static detector of code's compliance with MISRA-C's single-translation-unit rules. The code checker is based on the GNU Compiler Collection (GCC). This paper describes the strategies underlying the detector's design and implementation. For the tested benchmarks, the proposed checker is demonstrated to correctly assess compliance with or violation of all single-translation-unit rules. It can also obtain more accurate and more complete results than Cppcheck, a popular open-source checker. The source code can be downloaded from https://github.com/CCU-HPCLAB/GCC-MISRAC-Checker.

This paper presents a low complexity 3D image depth map generation algorithm for embedded stereo applications. The proposed algorithm generates depth information based on a single view 2D image automatically. Owing to different scene characteristics of image, we propose a mechanism to classify images to “Scenery”, “Normal” and “Close-up” types first and generate the associated depth map according to the proposed techniques. In addition, we propose a human detection method for strengthening the depth information in images with humans and post-processing for refining depth map. With good quality in the generated depth map, the proposed algorithm achieves about 93% in complexity reduction as compared to the traditional algorithm, which is suitable for realization in both the hardware and embedded systems for portable stereo applications.

SUMMARY XML is a markup language used to describe data or documents. The main goal of XML is to facilitate the sharing of data across diverse information systems, especially via the Internet. XML Stylesheet Transformations (XSLT) is a standard approach to describing how to transform an XML document into another data format. The ever‐increasing number of Web technologies being used in our everyday lives commonly employs XSLT to support data exchange among heterogeneous environments, and the associated increasing burdens on XSLT processors have increased the demand for high‐performance XSLT processors. In this paper, we present an XSLT compiler, named Zebu, which can transform an XSLT stylesheet into the corresponding C program. The compiled program can be used to transform documents without the processing of XSLT stylesheets. The results of experimental testing using standard benchmarks show that the proposed XSLT compiler performs well in processing XML transformations. Copyright © 2011 John Wiley & Sons, Ltd.

SUMMARY GCC (GNU Compiler Collection) is a popular compiler because it is open source, generates high‐quality code, and is portable. The emergence of various embedded systems has led to considerable interest in the portability of GCC. For GCC, a source programming language is parsed and internally transferred to the corresponding intermediate representation, RTL (Register Transfer Language). A machine description (MD)file, which describes the mapping relationships between RTL and the corresponding target assembly instructions, is provided at the stage of code generation. Therefore, GCC retargeting requires the construction of a target MD file. However, it is difficult for developers to understand and construct the MD because this requires considerable time spent studying the GCC intermediate representation and the strategy of code generation. In this paper, we propose a systematic methodology to help developers in retargeting GCC. The entire process is divided into seven levels according to the features of the supported source programming language. Based on this systematic methodology, a Web‐based assistance tool is also developed to guide developers through the retargeting. The assistance tool operates like a wizard to provide developers with the necessary procedures at each level and then generates the corresponding GCC files. Finally, we demonstrate the utility and practicality of the assistance tool based on the proposed methodology by applying it to the retargeting of GCC to a 32‐bit embedded processor—the helper function unit of the UniCore VisoMT processor, as developed by the System‐on‐Chips (SoC) Research Center of National Chung Cheng University, Taiwan. Copyright © 2011 John Wiley & Sons, Ltd.

Probabilistic pointer analysis (PPA) is a compile-time analysis method that estimates the probability that a points-to relationship will hold at a particular program point. The results are useful for optimizing and parallelizing compilers, which need to quantitatively assess the profitability of transformations when performing aggressive optimizations and parallelization. This paper presents a PPA technique using the static single assignment (SSA) form. When computing the probabilistic points-to relationships of a specific pointer, a pointer relation graph (PRG) is first built to represent all of the possible points-to relationships of the pointer. The PRG is transformed by a sequence of reduction operations into a compact graph, from which the probabilistic points-to relationships of the pointer can be determined. In addition, PPA is further extended to interprocedural cases by considering function related statements. We have implemented our proposed scheme including static and profiling versions in the Open64 compiler, and performed experiments to obtain the accuracy and scalability. The static version estimates branch probabilities by assuming that every conditional is equally likely to be true or false, and that every loop executes 10 times before terminating. The profiling version measures branch probabilities dynamically from past program executions using a default workload provided with the benchmark. The average errors for selected benchmarks were 3.80 percent in the profiling version and 9.13 percent in the static version. Finally, SPEC CPU2006 is used to evaluate the scalability, and the result indicates that our scheme is sufficiently efficient in practical use. The average analysis time was 35.59 seconds for an average of 98,696 lines of code.

Heart activities are governed by the sympathetic and parasympathetic nervous system. Changes in these neural signals influence the development of arrhythmias, including ventricular tachyarrhythmias that often progress to sudden cardiac death (SDC). A simultaneous study of the cardioneural signals with the electrical heart activity can elucidate the mechanism of abnormal heart activity. In this work, we identify the locations to detect cardioneural signals. We first perform a 108 channel measurement to explore the cardioneural signals. We then focus on selected locations for longer period measurement. We monitor the changes in the heart rate following each sympathetic or vagal nerve activity. The neural signals are extracted from ECG by applying independent component analysis. The work provides a promising approach for studying the association of cardioneural signals with electrical heart activity.

When performing aggressive optimizations and parallelization to exploit features of advanced architectures, optimizing and parallelizing compilers need to quantitatively assess the profitability of any transformations in order to achieve high performance. Useful optimizations and parallelization can be performed if it is known that certain points-to relationships would hold with high or low probabilities. For instance, if the probabilities are low, a compiler could transform programs to perform data speculation or partition iterations into threads in speculative multithreading, or it would avoid conducting code specialization. Consequently, it is essential for compilers to incorporate pointer analysis techniques that can estimate the possibility for every points-to relationship that it would hold during the execution. However, conventional pointer analysis techniques do not provide such quantitative descriptions and, thus, hinder compilers from more aggressive optimizations, such as thread partitioning in speculative multithreading, data speculations, code specialization, etc. We address this issue by proposing a probabilistic points-to analysis technique to compute the probability of every points-to relationship at each program point. A context-sensitive interprocedural algorithm has been implemented based on the iterative data flow analysis framework, and has been incorporated into SUIF and MachSUIF. Experimental results show this technique can estimate the probabilities of points-to relationships in benchmark programs with reasonable small errors, about 4.6 percent on average. Furthermore, the current implementation cannot disambiguate heap and array elements. The errors are further significantly reduced when the future implementation incorporates techniques to disambiguate heap and array elements.

Speculative multithreading (SpMT) architecture can exploit thread-level parallelism that cannot be identified statically. Speedup can be obtained by speculatively executing threads in parallel that are extracted from a sequential program. However, performance degradation might happen if the threads are highly dependent, since a recovery mechanism will be activated when a speculative thread executes incorrectly and such a recovery action usually incurs a very high penalty. Therefore, it is essential for SpMT to quantify the degree of dependences and to turn off speculation if the degree of dependences passes certain thresholds. This paper presents a technique that quantitatively computes dependences between loop iterations and such information can be used to determine if loop iterations can be executed in parallel by speculative threads. This technique can be broken into two steps. First probabilistic points-to analysis is performed to estimate the probabilities of points-to relationships in case there are pointer references in programs, and then the degree of dependences between loop iterations is computed quantitatively. Preliminary experimental results show compiler-directed thread-level speculation based on the information gathered by this technique can achieve significant performance improvement on SpMT.