Noritoshi Atsumi

An XML C Source Code Interchange Format for CASE Tools

We propose an XML C source code representation to support developing CASE tools. Since source code is a main artifact of software development, most CASE tools have some features related to source code editor, static analyzer, profiler, etc. To develop such tools, detailed information related to source code is needed. However, it is quite difficult to reuse program analysis features because they do not have common interfaces even for parsing and data/control-flow analysis that are most common features for such CASE tools. To address this issue, we focus on XML as an intermediate representation for source code information. Existing XML representations only represent structure of syntax trees and lack some important information required for CASE tools. We propose two models for representing source code, one is for intra-file information, which consists of syntax structure, flow, and type information, the other is for inter-file relation, which is cross-reference information. We also introduce CASE tools with our representation and demonstrate the efficacy in CASE tool development. To evaluate the efficacy, we show that a coding rule checker and a cross-referencer can be easily implemented using common XML processing libraries such as XSLT and XPath.

An integrated optimization framework for reducing the energy consumption of embedded real-time applications

This paper presents a framework for the purpose of energy optimization of embedded real-time systems. We implemented the presented framework as an optimization toolchain and an energy-aware real-time operating system. Our framework is synthetic, that is, multiple techniques optimize the target application together. The main idea of our approach is to utilize a trade-off between energy and performance of the processor configuration. The optimal processor configuration is selected at each appropriate point in the task. Additionally, an optimization technique about the memory allocation is employed in our framework. Our framework is also gradual, that is, the target application is optimized in a step-by-step manner. The characteristic and the behavior of target applications are analyzed and optimized for both intra-task and inter-task levels by our toolchain at the static time. Based on the results of static time optimization, the runtime energy optimization is performed by a real-time operating system according to the behavior of the application. A case study shows that energy minimization is achieved on average while keeping the real-time performance.

Grouping Objects for Execution Trace Analysis Based on Design Patterns

To comprehend an object-oriented software, visualizing object interactions performed as a UML sequence diagram is a promising technique for helping developers. However such UML sequence diagrams are typically too huge to comprehend behavior. In this paper, we propose a novel technique to generate abstracted sequence diagrams based on the information of applied GoF design patterns in a source code. We discuss effectiveness of our approach through a case study applying our implemented tool to an open source software.

Identifying Core Objects for Trace Summarization Using Reference Relations and Access Analysis

Behaviors of an object-oriented system can be visualized as reverse-engineered sequence diagrams from execution traces. This approach is a valuable tool for program comprehension tasks. However, owing to the massiveness of information contained in an execution trace, a reverse-engineered sequence diagram is often afflicted by a scalability issue. To address this issue, we present in this paper a method for identifying core objects for trace summarization by reference relations and access analysis. We detect and eliminate temporary objects that are trivial for a system, and then estimate the importance of non-trivial objects. By grouping objects with a focus on highly important ones (i.e., core objects), we visualize the systems behavior in terms of intergroup interactions. Consequently, we obtain a readable size of a reverse-engineered sequence diagram containing the systems key behavior. We implemented our technique in our tool and evaluated it by using traces from open-source software systems. The results showed that our reverse-engineered sequence diagrams contained only less than 30 lifelines, whereas the original diagrams (no abstraction methods were applied) contained approximately 1,000 to 3,000 lifelines. Our proposed method achieved significant reduction of the horizontal size of the diagram and is expected to be a valuable tool for program comprehension.

An Empirical Evaluation of Detecting Omissions by Comparing Words between Requirement and Architectural Documents

This paper presents the result of the empirical evaluation of detection of omitted requirements that are not described by using words appearance and words senses appearance. The evaluation investigated whether omitted requirements can be detected by difference between a set of words in software requirement document and a set of words in software architectural design document. The evaluation also investigated whether omitted requirements can be detected by difference between a set of words senses. First, the evaluation extracted a set of words that appear in a software requirement document and do not appear in the corresponding software architectural design document. The evaluation extracted a set of words senses that appear in a requirement document and do not appear in software architectural design document. Then, an analyst checked whether corresponding design description with each requirement sentence that contains each word and word sense of the sets exist or not. The result of the word appearance evaluation with 5 pairs of software requirement document and architectural design document shows that 82 requirement sentences were not described in the corresponding architectural design document. The result of the word sense appearance evaluation with 2 pairs of documents shows that 31 requirement sentences were not described in the corresponding architectural design document in addition to the word appearance evaluation.