Dynamic program slicing

Recent work on adaptive functional programming (AFP) developed techniques for writing programs that can respond to modifications to their data by performing change propagation . To achieve this, executions of programs are represented with dynamic dependence graphs (DDGs) that record data dependences and control dependences in a way that a change-propagation algorithm can update the computation as if the program were from scratch, by re-executing only the parts of the computation affected by the changes. Since change-propagation only re-executes parts of the computation, it can respond to certain incremental modifications asymptotically faster than recomputing from scratch, potentially offering significant speedups. Such asymptotic speedups, however, are rare: for many computations and modifications, change propagation is no faster than recomputing from scratch. In this article, we realize a duality between dynamic dependence graphs and memoization, and combine them to give a change-propagation algorithm that can dramatically increase computation reuse. The key idea is to use DDGs to identify and re-execute the parts of the computation that are affected by modifications, while using memoization to identify the parts of the computation that remain unaffected by the changes. We refer to this approach as self-adjusting computation. Since DDGs are imperative, but (traditional) memoization requires purely functional computation, reusing computation correctly via memoization becomes a challenge. We overcome this challenge with a technique for remembering and reusing not just the results of function calls (as in conventional memoization), but their executions represented with DDGs. We show that the proposed approach is realistic by describing a library for self-adjusting computation, presenting efficient algorithms for realizing the library, and describing and evaluating an implementation. Our experimental evaluation with a variety of applications, ranging from simple list primitives to more sophisticated computational geometry algorithms, shows that the approach is effective in practice: compared to recomputing from-scratch; self-adjusting programs respond to small modifications to their data orders of magnitude faster.

Program slicing techniques are widely used in the field of program debugging and testing, It is divided into static slicing and dynamic slicing. Existing dynamic slicing methods are inadequate, To solve these problems, A new dynamic slicing algorithm is designed, This algorithm based on coverage testing, The core idea is to establish a dynamic dependence graph, And the construction of this dependence graph is based on the coverage testing. This algorithm not only uses the static information, but also uses the dynamic execution information, The advantage of this algorithm is that it does not recalculate when the standard of slice changes.

Using Dynamic Dependence Graphs is a well understood method for computing dynamic program slices. However, in its basic form, the DDG is inappropriate for practical implementation, so several alternative approaches have been proposed by researchers. In this paper, we elaborate different methods in which the execution trace is processed and, using local definition-use information, the dependence chains are followed on the fly to construct the slices without actually building any graphs. Naturally, various additional data structures still need to be maintained, but these vary the slicing scenario. Firstly, one may want to perform the slicing in a demand-driven fashion, or to compute many slices globally. Next, one may be interested either in backward or forward slices. And finally, the slices can be produced by traversing the trace either in a forward or in a backward direction. This totals eight possibilities, of which some give useful algorithms, while there are irrelevant combinations as well. In this work we investigate all of them, give the basic algorithms where appropriate and discuss implementation experiences and perspectives.

When software developers want to understand the reason for a program's behavior, they must translate their questions about the behavior into a series of questions about code, speculating about the causes in the process. The Whyline is a new kind of debugging tool that avoids such speculation by instead enabling developers to select a question about program output from a set of “why did and why didn't” questions extracted from the program's code and execution. The tool then finds one or more possible explanations for the output in question. These explanations are derived using a static and dynamic slicing, precise call graphs, reachability analyses, and new algorithms for determining potential sources of values. Evaluations of the tool on two debugging tasks showed that developers with the Whyline were three times more successful and twice as fast at debugging, compared to developers with traditional breakpoint debuggers. The tool has the potential to simplify debugging and program understanding in many software development contexts.

Aspect-oriented Programming (AOP) is a recent programming paradigm that focuses on modular implementations of various crosscutting concerns. The typical features of AOP such as join-point, advice, introduction, aspects etc. make it difficult for applying slicing. Program slicing is a method to extort statements that are relevant to a particular variable. Program slicing, as initially defined by Weiser is based on static dataflow examination on the flow graph of the program. Program slicing has been applied in parallel processing, program debugging, program integration,program understanding , software testing and maintenance etc.In this paper, we proposed a technique for dynamic slicing of aspectoriented software based on the UML 2.0 Communication diagram. Here, we can use slicing at the architectural level to find the slicing of communication diagram at an earlier stage of software development. To represent the various unique features of AOP in UML diagrams is very difficult and complex in nature. For this purpose, we first draw the communication diagram for aspect-oriented program considering the classes, pointcuts, advices and aspects. Next, we have generated an intermediate representation from the communication diagram. Then, we proposed an edge marking dynamic slicing algorithm that traverses the intermediate representation and finds the slices for the communication diagram of the given problem scenario. The novelty in our approach is that we present the communication diagram for the aspect-oriented software. Also, we proposed an algorithm to find the slice from it. The advantage of using communication diagram is that it mainly focuses on the interaction between the objects involved in the problem scenario.

We propose a dynamic program slicing technique for object-oriented programs. We introduce the notion of compact dynamic dependence graph (CDDG) which is used as the intermediate program representation. Our dynamic slicing algorithm is based on the CDDG. We show that our algorithm is more time and space efficient than the existing ones. The worst case space complexity of our algorithm is O(n), where n is the number of statements of the program.

Program slicing is a well-known technique that extracts from a program those statements which are relevant to a particular criterion. While static slicing does not consider any input data, dynamic slices are computed from a particular program execution. Thus, dynamic slicers are usually easier to design and implement.In this work, we present a program specialization technique for lazy functional logic programming which is based on dynamic slicing. Our method exploits the code size reduction capabilities of slicing in order to produce a version of the original program specialized w.r.t. a given criterion. We also introduce some simple, post-processing transformations that allow us to further simplify the specialized program. The kind of specialization performed by our approach cannot be achieved with other related techniques like partial evaluation.

Dynamic program slicing is an effective technique for narrowing the errors to the relevant parts of a program when debugging. Given a slicing criterion, the dynamic slice contains only those statements that actually affect the variables in the slicing criterion. We propose a method to dynamically slice object-oriented (OO) programs based on dependence analysis. It uses the object program dependence graph and other static information to reduce the information to be traced during program execution. It deals with OO features such as inheritance, polymorphism and dynamic bindings. Based on this model, we present methods to slice methods, objects and classes. We also modify the slicing criterion to fit for debugging.

Program Slicing minimizes the program to substatements, which produces the same behaviour where the subset of the program also called the program slice comprises of the chunks or statements of the program which impact the values calculated at a point of absorption called as the slicing criterion. The concept of slicing was introduced by Weiser using a data-flow diagram [1]. If you look at static slicing, it does not make any suppositions about the input of a particular program, whereas the dynamic slicing counts on a distinct test case. Object-oriented programming is an extensively used software development technique. In this paper, we will create an approach to compute a static slice as well as a dynamic slice of a set of programs by creating an intermediary representation of the program, i.e. a Java program dependence graph and Java system dependence graph (JSysDG) (in case of multiple functions) and then use it as input and apply the slicing algorithm in order to compute slice of the program with respect to the slicing criterion and analyze the results as well.

Aim/Purpose: When learning to program, both text-based and visual-based input methods are common. However, it is unclear which method is more appropriate for first-time learners (first learners). Background: The differences in the learning effect between text-based and visual-based input methods for first learners are compared the using a questionnaire and problems to assess first learners’ understanding of programming. In addition, we study the benefits and feasibility of both methods. Methodology: In this research, we used the sandbox game Minecraft and the extended function ComputerCraftEdu (CCEdu). CCEdu provides a Lua programming environments for the two (text and visual) methods inside Minecraft. We conducted a lecture course on both methods for first learners in Japan ranging in age from 6 to about 15 years old. The lecture taught the basics and concepts of programming. Furthermore, we implemented a questionnaire about the attitude of programming before and after the lecture. Contribution: This research is more than a comparison between the visual method and the text method. It compares visual input and text input methods in the same environment. It clearly shows the difference between the programming learning effects of visual input and text input for first learners. In addition, it shows the more suitable input method for introductory education of first learners in programming learning. Findings: The following results are revealed: (1) The visual input method induces a larger change in attitude toward programming; (2) The number of operations and input quantity influence both groups; (3) The overall results suggest that a visual input is advantageous in a programming implementation environment for first learners. Impact on Society: A visual input method is better suited for first learners as it improves the attitude toward programming. Future Research: In the future, we plan to collect and analyze additional data as well as elucidate the correlation between attitudes and understanding of programming.

Program slicing is an effective techniqe for narrowing the focus of attention to the relevant parts of a program during the debugging process. However, imprecision is a problem in static slices, since they are based on all possible executions that reach a given program point rather than the specific execution under which the program is being debugged. Dynamic slices, based on the specific execution being debugged, are precise but incur high run-time overhead due to the tracing information that is collected during the program's execution. We present a hybrid slicing technique that integrates dynamic information from a specific execution into a static slice analysis. The hybrid slice produced is more precise that the static slice and less costly that the dynamic slice. The technique exploits dynamic information that is readily available during debugging—namely, breakpoint information and the dynamic call graph. This information is integrated into a static slicing analysis to more accurately estimate the potential paths taken by the program. The breakpoints and call/return points, used as reference points, divide the execution path into intervals. By associating each statement in the slice with an execution interval, hybrid slicing provides information as to when a statement was encountered during execution. Another attractive feature of our approach is that it allows the user to control the cost of hybrid slicing by limiting the amount of dynamic information used in computing the slice. We implemented the hybrid slicing technique to demonstrate the feasibility of our approach.

SummaryFault localization is sensitive to program runs, and the pattern of fault propagation and manifestation in real software is extremely complex and uncertain. To accommodate the complexity and uncertainty, this paper presents a novel probabilistic graph model – the probabilistic cause–effect graph (PCEG) is built upon dynamic dependencies generated from running the faulty program against failed test cases and performs probabilistic inference with coverage information from the whole test suite. PCEG is an extension of the traditional probabilistic graph both in structural and inferential terms and is different from earlier probabilistic approaches to software diagnosis by introducing two forms of evidences (i.e. apparent faults and real faults). The proposed probabilistic reasoning algorithm works on the PCEG converted from a dynamic program dependency graph and diagnoses the causes with both top‐down and bottom‐up inference. The experimental results have shown the improvements on diagnostic effectiveness and accuracy in both single‐fault and multiple‐fault context, even when a program yields similar program runs through loop statements. Copyright © 2015 John Wiley & Sons, Ltd.

Current and future parallel programming models need to be portable and efficient when moving to heterogeneous multi-core systems. OmpSs is a task-based programming model with dependency tracking and dynamic scheduling. This paper describes the OmpSs approach on scheduling dependent tasks onto the asymmetric cores of a heterogeneous system. The proposed scheduling policy improves performance by prioritizing the newly-created tasks at runtime, detecting the longest path of the dynamic task dependency graph, and assigning critical tasks to fast cores. While previous works use profiling information and are static, this dynamic scheduling approach uses information that is discoverable at runtime which makes it implementable and functional without the need of an oracle or profiling. The evaluation results show that our proposal outperforms a dynamic implementation of Heterogeneous Earliest Finish Time by up to 1.15x, and the default breadth-first OmpSs scheduler by up to 1.3x in an 8-core heterogeneous platform and up to 2.7x in a simulated 128-core chip.

This study proposes an adaptive spatiotemporal graph contrastive learning model to address the challenges of anomaly detection in cloud service systems under highly dynamic topologies, complex dependencies, and multi-source heterogeneous monitoring data. The model constructs a dynamic spatiotemporal dependency graph to achieve adaptive modeling of structural relationships among service nodes and incorporates temporal encoding to capture multi-scale temporal variations, thereby achieving joint spatiotemporal feature representation. It consists of three main components: adaptive graph construction, spatiotemporal feature encoding, and contrastive learning optimization, which together enhance anomaly identification in an unsupervised manner through feature aggregation and discrimination. First, a learnable adjacency matrix is generated based on the dynamic correlations among service metrics to reflect the evolution of service dependencies. Then, structural and temporal features are jointly extracted through the integration of graph convolution and recurrent neural units, forming representations that are globally consistent and locally sensitive. Finally, an InfoNCE-based contrastive loss function is introduced to strengthen the aggregation of normal samples and the separation of anomalous ones in the latent space, improving model robustness and generalization. Experiments conducted on real cloud monitoring data include multi-dimensional comparisons and sensitivity analyses covering key factors such as time window length, attention head number, node failure ratio, and anomaly sample ratio. The results show that the proposed method outperforms existing baseline models in accuracy, precision, recall, and F1-Score, maintaining high detection accuracy and stable performance in complex cloud environments and providing an efficient and robust solution for anomaly identification and intelligent operation in large-scale distributed systems.

In the design of highly complex, heterogeneous, and concurrent systems, deadlock detection and resolution remains an important issue. In this paper, we systematically analyze the synchronization dependencies in concurrent systems modeled in the Metropolis design environment, where system functions, high level architectures and function-architecture mappings can be modeled and simulated. We propose a data structure called the dynamic synchronization dependency graph, which captures the runtime (blocking) dependencies. A loop-detection algorithm is then used to detect deadlocks and help designers quickly isolate and identify modeling errors that cause the deadlock problems. We demonstrate our approach through a real world design example, which is a complex functional model for video processing and a high level model of function-architecture mapping.