A Fast Algorithm to Locate Concepts in Execution Traces

Abstract

Abstract. The identification of cohesive segments in execution traces is a important step in concept location which, in turns, is of paramount importance for many program-comprehension activities. In this paper, we reformulate the trace segmentation problem as a dynamic programming problem. Differently to approaches based on genetic algorithms, dynamic programming can compute an exact solution with better performance than previous approaches, even on long traces. We describe the new problem formulation and the algorithmic details of our approach. We then compare the performances of dynamic programming with those of a genetic algorithm, showing that dynamic programming reduces dramatically the time required to segment traces, without sacrificing precision and recall; even slightly improving them.

SCAN: An Approach to Label and Relate Execution Trace Segments

“…The hybrid approach proposed by Asadi et al [9] and by Medini et al [10] resorts to the textual content of the methods contained in execution traces to split traces into segments that likely participate in the implementation of the concepts related to the features of interest. The underlying assumption is that when a specific feature is executed within a complex scenario (e.g., "Open a Web page from a browser" or "Save an image in a paint application"), the set of relevant methods being invoked is likely to be conceptually cohesive, decoupled from those of other features and invoked in sequence.…”

“…To alleviate the burden of manual analysis, different concept location approaches have been proposed in the literature, including static approaches [3], dynamic approaches [4], [5], and hybrid ones [6], [7], [8], [9], [10]. The hybrid approach proposed by Asadi et al [9] and by Medini et al [10] resorts to the textual content of the methods contained in execution traces to split traces into segments that likely participate in the implementation of the concepts related to the features of interest.…”

Stride: Search-based deterministic replay in polynomial time via bounded linkage

“…For example, thread T 1 updates x 1 , x 2 ...x n and then thread T 2 reads x 1 , x 2 ...x n . If we group x 1 , x 2 ...x n together as variable x, recording (1,n) 5 for the write order log and (n,n) 6 for the bounded linkages is enough. However, we have to record all the values of x 1 , x 2 ...x n , since the value of x 1 , x 2 ... x n are supposed to be different from each other.…”

“…When an object is created, we map the hash code of that object to C birth and increment the counter by one. After 5 (1,n) stands for the next n writes are issued by thread T 1 . 6 (n,n) stands for the next n read operations reads version n.…”

“…Deterministically replaying a concurrent multicore execution remains as one of the most effective ways to comprehend concurrency bugs( [1]- [5]). A typical deterministic replayer must tame two sources of non-determinism: the input non-determinism, observing the randomness in the program input such as the user input, interrupts, signals, and the scheduling non-determinism, concerned with races to the shared memory locations caused by a random scheduler.…”