Flowback analysis is a powerful technique for debugging programs. It allows the programmer to examine dynamic dependences in a program's execution history without having to re-execute the program. The goal is to present to the programmer a graphical view of the dynamic program dependences. We are building a system, called PPD, that performs flowback analysis while keeping the execution time overhead low. We also extend the semantics of flowback analysis to parallel programs. This paper describes details of the graphs and algorithms needed to implement efficient flowback analysis for parallel programs. Execution time overhead is kept low by recording only a small amount of trace during a program's execution. We use semantic analysis and a technique called incremental tracing to keep the time and space overhead low. As part of the semantic analysis, PPD uses a static program dependence graph structure that reduces the amount of work done at compile time and takes advantage of the dynamic...

The concept of static program slicing was first introduced by Weiser. Ottenstein et al. indicated that an intraprocedural slice can be found in linear time by traversing a suitable graph representation of the program referred to as the program dependence graph (PDG). Horwitz et al. introduced algorithms to construct interprocedural slices by extending the program dependence graph to a supergraph of the PDG referred to as the system dependence graph (SDG). This extension captures the calling context of procedures. In a previous paper, we demonstrated that a parse-tree-based SDG provides us with ‘‘smaller’ ’ and therefore more precise slices than a statement-based SDG. Furthermore, we described extensions to the SDG in order to handle particular constructs in a language that is a subset of ANSI C. In this paper, we will describe a new method for the calculation of transitive dependences and therefore build a SDG that does require neither the calculation of the GMOD and GREF sets nor the construction of a linkage grammar and the corresponding subordinate characteristic graphs of the linkage grammar’s nonterminals. Additionally, we illustrate the versatility of the SDG as an internal program representation by briefly presenting a tool that we have developed that permits slicing, dicing, and ripple analyzing in addition to other software engineering activities to be performed on programs written in a subset of ANSI C. This report is an extension of our previous report published in December 1991. 1.

In this paper we propose a program dependence model for concurrent logic programs. We present three types of primary program dependences named the sharing dependence, communication dependence, and unification dependence between arguments in a concurrent logic program. We formally define these primary program dependences based on mode information. We further present a dependence-based representation named the argument dependence net (ADN), which explicitly represents all primary program dependences between arguments in a concurrent logic program. We also discuss some applications of the ADN for developing software engineering tools of concurrent logic programs. Finally, we briefly introduce a program analysis system called CLPKIDS for concurrent logic programs, which is a prototype implementation of the techniques introduced in this paper.

Embedded systems require control of many concurrent real-time activities, leading to system designs which feature multiple hardware peripherals with each providing a specific, dedicated service. These peripherals increase system size, cost, weight, power and design time.Software thread integration (STI) provides low-cost thread concurrency on general-purpose processors by automatically interleaving multiple (potentially real-time) threads of control into one. This simplifies hardware to software migration (which eliminates dedicated hardware) and can help embedded system designers meet design constraints such as size, weight, power and cost. This paper introduces automated methods for planning and performing the code transformations

Component-based software development technique and its intensive use in the industry has led to the wide research in various aspects of component-based systems (CBSs). Dependency analysis is an useful technique that has many applications in software engineering activities including software understanding, testing, debugging, maintenance, and evolution. In this paper, we propose a matrix-based approach to analyzing dependencies in CBSs.

Data-parallel model is attractive in a point that data-parallelism is easily expressed in loops and the efficiency is likely to be the highest if processors perform computations on data elements stored in local memory. However, communication is necessary in many cases and single-threaded data-parallel programs have a limitation in efficient communication. In this paper, we introduce multithreading concept to overcome the limitation. We present a new representation, PCFG(Parallel Control Flow Graph) and show how to construct it. We also show multithreaded codes can be easily transformed from single-threaded data-parallel codes using PCFGs. Keywords: data-parallel, multithreading, control dependence, data dependence, parallel control flow graph. Technical area: Compilers and Languages. 1 Introduction Data-parallel loops, which have no-loop carried dependence, are the primary target of Fortran D[1] or HPF(High Performance Fortran)[2] compilers. Most of parallel loops are related to arr...

This paper presents two new graph-theoretical program representations which can be used to represent control flows and/or data flows in concurrent programs as well as sequential programs. The paper also shows some possible applications of the representations in software engineering. 1. INTRODUCTION