Program Slicing Techniques with Support for Unconditional Jumps

Galindo, Carlos; Pérez, Sergio; Silva, Josep

doi:10.1007/978-3-031-17244-1_8

Cited by 3 publications

(2 citation statements)

References 20 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Developing a slicer that supports the whole range of functionality of today's programming languages is challenging, particularly the handling of exception-related constructs [26], unconditional jumps [27], object orientation [27], concurrency [28], and shared memory [29]. The aforementioned papers highlight that there are still many issues that need to be addressed to develop slicers for programs written in modern programming languages.…”

Section: Related Workmentioning

confidence: 99%

Reducing the Length of Dynamic and Relevant Slices by Pruning Boolean Expressions

Hirsch,

Hofer

2024

Electronics

View full text Add to dashboard Cite

Dynamic and relevant (backward) slicing helps programmers in the debugging process by reducing the number of statements in an execution trace. In this paper, we propose an approach called pruned slicing, which can further reduce the size of slices by reasoning over Boolean expressions. It adds only those parts of a Boolean expression that are responsible for the evaluation outcome of the Boolean expression to the set of relevant variables. We empirically evaluate our approach and compare it to dynamic and relevant slicing using three small benchmarks: the traffic collision avoidance system (TCAS), the Refactory dataset, and QuixBugs. Pruned slicing reduces the size of the TCAS slices on average by 10.2%, but it does not reduce the slice sizes of the Refactory and QuixBugs programs. The times required for computing pruned dynamic and relevant slices are comparable to the computation times of non-pruned dynamic and relevant slices. Thus, pruned slicing is an extension of dynamic and relevant slicing that can reduce the size of slices while having a negligible computational overhead.

show abstract

Section: Related Workmentioning

confidence: 99%

Reducing the Length of Dynamic and Relevant Slices by Pruning Boolean Expressions

Hirsch,

Hofer

2024

Electronics

View full text Add to dashboard Cite

show abstract

“…The programming languages which have an object-oriented base are greater appropriate than the different languages for the dynamic reducing technique which is the third method called Dynamic Slicing Algorithm. The dynamic slicing algorithm identifies the input and considers the distinctive incidences of an announcement in an implementation hint [13]. The entered and the software announcement are belonging to the run hint which in flip belongs to the dynamic slicing algorithm.…”

Section: Figure (3)mentioning

confidence: 99%

An Improved Dynamic Slicing Algorithm to Prioritize a Concurrent Multi-threading in Operating System

Mohammed

2023

IJOIR

View full text Add to dashboard Cite

One of the issues with multi-threading in operating systems is the concurrency of operations or threads. In a multithreaded process on a single processor, the processor can switch execution resources between threads, enabling concurrent execution. Concurrency indicates that more than one thread is making progress, but the threads are not actually running simultaneously. The switching between threads occurs rapidly enough that the threads might appear to run simultaneously. In this paper, three related strategies for prioritizing multi-threading are presented: ACE-thread, Semaphore coprocessor, and the Concurrent Priority Threads Algorithm. The aim of this work is to enhance an existing prioritization algorithm, specifically the Concurrent Priority Threads Algorithm, by extending a dynamic slicing algorithm to prioritize multi-threading concurrently. The algorithm is designed to compute correct slices in multi-threading prioritization scenarios. Threads with the same highest priority can perform in a synchronized manner without encountering deadlocks. The C++ programming language is used to implement the extended algorithms. The improved algorithm achieved results that were 3% more accurate than the existing one. The outcomes of this work would facilitate the simultaneous execution of threads with the same priority, ultimately reducing waiting and processing times.

show abstract