Program Paths Research Articles

Automated elicitation of functional dependencies from source codes of database transactions

Enforcement of data dependency is a major component in any database application. Functional dependency (FD) is an important data dependency. Due to the nature of software development and maintenance and the limitation of database management system (DBMS) in handling FD enforcement, many functional dependencies are enforced in the transactions that update the database, but not through DBMS. It is very difficult and time consuming to elicit functional dependencies from transactions manually for the reengineering, verification and maintenance of database applications. With the use of program analysis, this paper proposes a novel approach for the automated elicitation of functional dependencies from source codes of transactions that update the database. The approach is based on detecting program path patterns for enforcing FD.

Energy management for real-time embedded applications with compiler support

Reducing device energy has become one of the most important challenges to embedded systems designers. Processors with dynamic voltage scaling permit trading performance for reduced energy consumption as a program executes. In this paper, we first present a novel hybrid scheme that uses dynamic voltage scaling to adjust the performance of embedded applications to reduce energy consumption while also meeting time constraints. Our fine grained approach uses the compiler to insert power management hints in the application code. These hints convey path specific run-time information about the program's progress to power management points invoked by the operating system that adjust processor performance. Second we present an algorithm for inserting power management hints along different program paths. Finally, we experimentally evaluate our approach and show that signi cant energy reduction can be achieved. On two embedded applications, MPEG movie decoding and automatic target recognition, our scheme reduces energy by up to 79% over no power management and by up to over 50% static power management. We also experimentally demonstrate that our scheme achieves more energy savings compared to two purely compiler directed schemes.

Formal Semantics for Program Paths

This paper provides the syntax and semantics for a systematic approach to the problem of analysing control-flow paths in computer programs. We give an abstract syntax and a partial correctness semantics for program control-flow paths as a generic model for path analysis and constraint derivation. This approach is formally based on a predicate transformer semantics over a boolean-valued predicate space and an abstract command language. The notions of a command, dead commands, the entry and exit conditions of a command and the inverse of a command are formally defined and investigated on the base of the semantics. A notion of command refinement is introduced capturing the abstraction process in program development from specification to implementation with partial correctness. Furthermore, command-reduction theorems and characterisations for command refinement are derived using the underlying semantics. Finally we verify the equivalence of weakest liberal precondition and strongest postcondition semantics for program commands in terms of the ordering relation they define on the command language. The approach is generic in that it is applicable to any program language that can be supplied with a predicate transformer semantics.

AUTOMATIC TEST DATA GENERATION FOR PROGRAM PATHS USING GENETIC ALGORITHMS

A new technique and tool are presented for test data generation for path testing. They are based on the dynamic technique and on a Genetic Algorithm, which evolves a population of input data towards reaching and solving the predicates along the program paths. We improve the performance of test data generation by using past input data to compose the initial population for the search. An experiment was done to assess the performance of the techniques compared to that of random data generation.

Exploring into programs for the recovery of data dependencies designed

Data dependencies play an important role in the design of a database. Many legacy database applications have been developed on old generation database management systems and conventional file systems. As a result, most of the data dependencies in legacy databases are not enforced in the database management systems. As such, they are not explicitly defined in database schema and are enforced in the transactions, which update the databases. It is very difficult and time consuming to find out the designed data dependencies manually during the maintenance and reengineering of database applications. In software engineering, program analysis has long been developed and proven as a useful aid in many areas. With the use of program analysis, this paper proposes a novel approach for the recovery of common data dependencies, i.e., functional dependencies, key constraints, inclusion dependencies, referential constraints, and sum dependencies, designed in a database from the behavior of transactions, which update the database. The approach is based on detecting program path patterns for implementing most commonly used methods to enforce these data dependencies.

은행 정보시스템 감사에 관한 사례 연구

은행업에 있어서 정보시스템의 중요성은 다른 산업에 비해서 매우 높다. 본 논문에서는 한 은행의 사례를 토대로 은행에서 실시하고 있는 정보시스템 감사 제도의 전반적인 현황을 분석하여 문제점 및 발전 방향을 제시한다. 주요한 문제점은 다음과 같다. 전반적으로 정보시스템 프로세스의 수행 정도가 미흡하고, 감사 실시 정도는 전반적으로 중요한 프로세스에는 적절히 대응하고 있으나 금융 및 전산사고 예방에만 초점을 맞추어 전략적인 측면의 대응이 미흡한 것으로 나타났다. 또한 감사 활동이 프로세스 수행에 긍정적인 영향을 미치지 못하고 있어서 감사 사후 관리를 개선할 필요성이 제기되었다. 감사 인력/조직적인 측면에서는 인력의 충원이 필요하고, 전략 기획 분야와 연구·개발 활동이 미흡하고, 감사인의 적격성 및 독립성 분야에서 기준 대비 미흡한 면이 있는 것으로 분석되었다. 여기에 대한 발전 방향으로는 내부 감사 부서들간의 적절한 감사 분담, 외부 감사의 활용, 감사 자동화 도구 도입, 자가통제평가 제도 도입, 감사인력에 대한 경력개발 제도 실시, 위험 기반 감사 제도 도입 등이 있다. 본 연구의 결과는 은행업, 더 나아가서 다른 산업의 기업들이 참고할 수 있는 사시점을 제공하고, 본 연구에서 활용한 분석 프레임워크는 향후 정보시스템 감사 분야의 학술적인 연구에서 활용될 수 있을 것이다. Importance of Information Systems in banking industry is higher than that of other industries. This study, based on a case study of a bank, analyzes the current status of information systems (IS) audit and proposes future directions in the area of IS control and audit. Major problems identified in the study include deficiency of IS and audit process, and inability of audit function to improve IS process. In addition, deficiency of staffing level and investment in R&D, and lack of competency and independence of audit staff are identified. In order to solve the problems, the following directions were proposed proper division of functions among audit related departments, utilization of outside audit function, and adoption of CSA, CAAT, career path program, risk-based audit approach. The results of the studs will provide valuable implications to banks and companies in other industries. Also the research framework employed in the study can be utilized in the future research in IS control and audit.

Soft Constraint Logic Programming and Generalized Shortest Path Problems

In this paper we study the relationship between Constraint Programming (CP) and Shortest Path (SP) problems. In particular, we show that classical, multicriteria, partially ordered, and modality-based SP problems can be naturally modeled and solved within the Soft Constraint Logic Programming (SCLP) framework, where logic programming is coupled with soft constraints. In this way we provide this large class of SP problems with a high-level and declarative linguistic support whose semantics takes care of both finding the cost of the shortest path(s) and also of actually finding the path(s). On the other hand, some efficient algorithms for certain classes of SP problems can be exploited to provide some classes of SCLP programs with an efficient way to compute their semantics.

Hybrid Cache Analysis in Running Time Verification of Embedded Software

Verification of software running time is essential in embedded systemdesign with real-time constraints. Simulation with incomplete test patternsis unsafe for complex architectures when software running times are inputdata dependent. Formal analysis of such dependencies leads to software runningtime intervals rather than single values. These intervals depend on programproperties, execution paths and states of processes, as well as on the targetarchitecture. In the target architecture, caches have a major influence onsoftware running time. Current cache analysis techniques as a part of runningtime analysis approaches combine basic block level cache modeling with explicitor implicit program path analysis. We present an approach that extends instructionand data cache modeling from basic blocks to program segments thereby increasingthe overall running time analysis precision. We combine it with data flowanalysis based prediction of cache line contents. This novel cache analysisapproach shows high precision in the presented experiments.

Positive Action in Minority Ethnic Employment: The Role of Scottish Housing Organizations

This paper focuses on Scottish housing organizations, where the relative absence of black and minority ethnic employees is beginning to be addressed by programmes of positive action. The paper defines positive action, discusses experiences elsewhere in Europe and the USA, and identifies issues that have arisen from such programmes. Schemes targeted at the housing profession, such as PATH in both England and Scotland, are described in some detail. The attitudes and experiences of Scottish housing organizations were examined as part of an evaluation of the Scottish PATH programme carried out in 1998, and these are discussed. The paper concludes that a reservoir of goodwill exists towards positive action programmes and that there is a need for such programmes to be extended, possibly with the support of the Scottish Parliament.

A prediction system for evolutionary testability applied to dynamic execution time analysis

Evolutionary testing (ET) is a test case generation technique based on the application of an evolutionary algorithm. It can be applied to timing analysis of real-time systems. In this instance, timing analysis is equivalent to testing. The test objective is to uncover temporal errors. This corresponds to the violation of the system's timing specification. Testability is the ability of the test technique to uncover faults. Evolutionary testability is the ability of an evolutionary algorithm to successfully generate test cases with the goal to uncover faults, in this instance violation of the timing specification. This process attempts to find the best- and worst-case execution time of a real-time system. Some attributes of real-time systems were found to greatly inhibit the successful generation of the best- and worst-case execution times through ET. These are small path domains, high data dependence, large input vectors and nesting. This paper defines software metrics, which aim to express the effects of these attributes on ET. ET is applied to generate the best- and worst-case execution paths of test programs. Their extreme timing paths are determined analytically and the average success of ET to cover these paths is assessed. This empirical data is mapped against the software metrics to derive a prediction system for evolutionary testability. The measurement and prediction system developed from the experiments is able to forecast evolutionary testability with almost 90% accuracy. The prediction system will be used to assess whether the application of ET to a real-time system will be sufficient to successful dynamic timing analysis, or whether additional testing strategies are needed.

Continuous program optimization: Design and evaluation

This paper presents a system in which the already executing user code is continually and automatically reoptimized in the background, using dynamically collected execution profiles as a guide. Whenever a new code image has been constructed in the background in this manner, it is hot-swapped in place of the previously executing one. Control is then transferred to the new code and construction of yet another code image is initiated in the background. Two new runtime optimization techniques have been implemented in the context of this system: object layout adaptation and dynamic trace scheduling. The former technique constantly improves the storage layout of dynamically allocated data structures to improve data cache locality. The latter increases the instruction-level parallelism by continually adapting the instruction schedule to predominantly executed program paths. The empirical results presented in this paper make a case in favor of continuous optimization, but also indicate some of the pitfalls and current shortcomings of continuous optimization. If not applied judiciously, the costs of dynamic optimizations outweigh their benefit in many situations so that no break-even point is ever reached. In favorable circumstances, however, speed-ups of over 96 percent have been observed. It appears as if the main beneficiaries of continuous optimization are shared libraries in specific application domains which, at different times, can be optimized in the context of the currently dominant client application.

Timestamped whole program path representation and its applications

A whole program path (WPP) is a complete control flow trace of a program's execution. Recently Larus [18] showed that although WPP is expected to be very large (100's of MBytes), it can be greatly compressed (to 10's of MBytes) and therefore saved for future analysis. While the compression algorithm proposed by Larus is highly effective, the compression is accompanied with a loss in the ease with which subsets of information can be accessed. In particular, path traces pertaining to a particular function cannot generally be obtained without examining the entire compressed WPP representation. To solve this problem we advocate the application of compaction techniques aimed at providing easy access to path traces on a per function basis. We present a WPP compaction algorithm in which the WPP is broken in to path traces corresponding to individual function calls. All of the path traces for a given function are stored together as a block. Ability to construct the complete WPP from individual path traces is preserved by maintaining a dynamic call graph . The compaction is achieved by eliminating redundant path traces that result from different calls to a function and by replacing a sequence of static basic block ids that correspond to a dynamic basic block by a single id. We transform a compacted WPP representation into a timestamped WPP (TWPP) representation in which the path traces are organized from the perspective of dynamic basic blocks. TWPP representation also offers additional opportunities for compaction. Experiments show that our algorithm compacts the WPPs by factors ranging from 7 to 64. At the same time information is organized in a highly accessible form which speeds up the responses to queries requesting the path traces of a given function by over 3 orders of magnitude.

A CONSTRAINT SOLVER AND ITS APPLICATION TO PATH FEASIBILITY ANALYSIS

Many testing methods are based on program paths. A well-known problem with them is that some paths are infeasible. To decide the feasibility of paths, we may solve a set of constraints. In this paper, we describe constraint-based tools that can be used for this purpose. They accept constraints expressed in a natural form, which may involve variables of different types such as integers, Booleans, reals and fixed-size arrays. The constraint solver is an extension of a Boolean satisfiability checker and it makes use of a linear programming package. The solving algorithm is described, and examples are given to illustrate the use of the tools. For many paths in the testing literature, their feasibility can be decided in a reasonable amount of time.

“Returning the Dues”

This study uses interviews to explore students’ perspectives of a university path program, one initiative of a university-school partnership. Responses show that the abstraction of the program lives in concrete and personal dimensions for students as they move from high school to university in the same neighborhood. Advanced placement work at the university and the secondment of faculty from the school board blur distinctions between school and university. Most striking is the students’ desire to contribute to the community that has supported them and is most closely associated with their families, the school, and the university that lies, at least geographically, within community bounds.

Performance Optimization Using Extended Critical Path Analysis in Multithreaded Programs on Multiprocessors

Efficient performance tuning of parallel programs is often hard. Optimization is often done when the program is written as a last effort to increase the performance. With sequential programs each (executed) code segment will affect the completion time. In the case of a parallel program executed on a multiprocessor this is not always true, due to dependencies between the different threads. Thus, certain code segments of the execution may not affect the completion time of the program. Optimization of such code segments will not increase the performance. In this paper we present an approach to optimize performance by finding the extended critical path of the multithreaded program. The extended critical path analysis is a generalization of the critical path analysis in the sense that it also deals with more threads than processors. We have implemented the extended critical path analysis in a performance optimization tool. The tool allows the user to determine the extended critical path of a multithreaded application written for the Solaris operating system for any number of processors based on execution on a single processor workstation.

けん板断裂手術へのクリティカルパスの活用

We applied critical path to rotator cuff tears. At the introduction of the path, we decided the criteria for discharge. The criteria were the removal of shoulder abduction brace and the activity level of patients for face-washing and eating. At the programming of the critical path, we improved the process in our hospital. After anesthesia, patients remained asleep for 6 hours, and antibiotics administration stopped 2 days after surgery. The surgical wounds were fixed with tape so that the thread did not need to be removed.We examined the patients who were 8 before and 9 after introduction of critical path. We examined the duration of brace use, average number of days of hospital stay, and JOA score.After the introduction of the critical path, the duration of wearing brace use and average number of days in the hospital became shorter. Doctors, nurses, and patients were all satisfied with the critical path.

On the producibility of composite position tolerance specifications for patterns of holes

A composite position tolerance verification algorithm is embedded in a simulation program to explore the producibility of three composite position tolerance variants for patterns of holes. The influence of some selective design and manufacturing variables on producibility is simulated and evaluated. It is shown that design variables such as specification variant, material condition modifier and number of holes in the pattern have a significant influence on producibility. The influence of manufacturing variables such as orientation error and numerical control path programming in the presence of axis reversal error are also simulated and discussed. Detailed graphs of these effects are presented and discussed.

Using paths to measure, explain, and enhance program behavior

What happens when a computer program runs? The answer can be frustratingly elusive, as anyone who has debugged or tuned a program knows. As it runs, a program overwrites its previous state, which might have provided a clue as to how the program got to the point at which it computed the wrong answer or otherwise failed. This all-too-common experience is symptomatic of a more general problem: the difficulty of accurately and efficiently capturing and analyzing the sequence of events that occur when a program executes. Program paths offer an insight into a program's dynamic behavior that is difficult to achieve any other way. Unlike simpler measures such as program profiles, which aggregate information to reduce the cost of collecting or storing data, paths capture some of the usually invisible dynamic sequencing of statements. The article exploits the insight that program statements do not execute in isolation, but are typically correlated with the behavior of previously executed code.

Control design of an automated highway system

Describes the design of an automated highway system (AHS) developed over the past ten years in the California PATH program. The AHS is a large, complex system, in which vehicles are automatically controlled. The design and implementation of the AHS required advances in actuator and sensor technologies, as well as the design, analysis, simulation, and testing of large-scale, hierarchical hybrid control systems. The paper focuses on the multilayer AHS control architecture and some questions of implementation. It discusses in detail the design and safety verification of the on-board vehicle control system and the design of the link-layer traffic-flow controller.

Fast and Precise WCET Prediction by Separated Cache andPath Analyses

Precise run-time prediction suffers from a complexity problem when doing an integrated analysis. This problem is characterised by the conflict between an optimal solution and the complexity of the computation of the solution. The analysis of modern hardware consists of two parts: a) the analysis of the microarchitecture‘s behaviour (caches, pipelines) and b) the search for the longest program path. Because an integrated analysis has a significant computational complexity, we chose to separate these two steps. By this, an ordering problem arises, because the steps depend on each other. In this paper we show how the microarchitecture analysis can be separated from the path analysis in order to make the overall analysis fast. Practical experiments will show that this separation, however, does not make the analysis more pessimistic than existing approaches. Furthermore, we show that the approach can be used to analyse executables created by a standard optimising compiler.