mdh.sePublications
Change search
Refine search result
1 - 5 of 5
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1.
    Khanfar, Husni
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Objects-Based Slicing2014Report (Other academic)
    Abstract [en]

    Static slicing selects a part of the program that can possibly affect the slicing criterion in question. The standard algorithm in the slicing is based upon the Program Dependency Graph (PDG). PDG is constructed upon Control Flow Graph (CFG) nodes, which afterwards, are connected by control and data dependencies edges. PDG-Based slicing algorithm requires building in advance a PDG, which can be quite an expensive operation. Two new improvements are proposed to this scheme: rstly, Strongly Live Variables (SLV) data flow analysis is used rather than Reaching Definitions to compute the data dependencies. This has the advantage that the slicing of program statements can be done concurrently with the SLV analysis as well as it eliminates the need to build a Data Dependence Graph (DDG). Secondly, for well-structured code, an Object-Based representation of the code is designed, Objects structured into loops and conditionals, which directly captures the control dependencies: thus, the Control Dependence Graph (CDG) needs not be built. This scheme also allows for a more efficient representation of the SLV sets, and a simpler test that the fixed-point iteration in the combined SLV analysis and slicing has converged.

  • 2.
    Khanfar, Husni
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Lisper, Björn
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Enhanced PCB Based Slicing2016In: Proceedings of the Fifth International Valentin Turchin Workshop on Metacomputation, Pereslavl-Zalessky, Russian Federation, 2016, p. 71-91Conference paper (Refereed)
  • 3.
    Khanfar, Husni
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Lisper, Björn
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Masud, Abu Naser
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Static backward program slicing for safety-critical systems2015In: Lect. Notes Comput. Sci., 2015, p. 50-65Conference paper (Refereed)
    Abstract [en]

    Static program slicing is a technique to detect the program parts (i.e. the “slice”) of the given program possibly affecting a given property. The technique is of interest for analysing safety-critical software, since it can identify the program parts that may affect various safety properties. Verification efforts can then be directed towards those parts, leading to a more efficient verification process. We have developed a novel method for static backward program slicing. The method works for well-structured programs, as commonly demanded by coding standards for safety-critical software. It utilises the program structure to obtain a highly efficient slicing process, where control dependencies are inferred from the program structure, and the slicing is done on-the-fly concurrently with the data dependence analysis. We have evaluated our method experimentally. For applications that require few slices to be taken, like checking for a set of safety properties, we obtain large speedups as compared with the standard method for static backward program slicing. We have also investigated how the speedup varies with various parameters such as code size, size of the slice relative to the full program, and relative frequency of conditions in the code.

  • 4.
    Khanfar, Husni
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Lisper, Björn
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Mubeen, Saad
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Demand-Driven Static Backward Slicing for Unstructured Programs2019Report (Other academic)
    Abstract [en]

    Backward program slicing identifies the program parts that might influence a particular variable at a program point. A program part (e.g., a statement) can be directly influenced by another part due to its data or control dependence on the later. The classical program slicing approaches are designed to find in advance all the data and control dependencies in the program. This design entails a considerable amount of unnecessary computations because not all the dependencies are required for computing the slice. Demand-driven program slicing approaches try to raise the analysis performance by avoiding the unnecessary computations. However, these approaches cannot address unstructured programs in a demand-driven fashion. On the other hand, the existing techniques that compute the control dependencies in unstructured programs are based on fixed-point iterations, which limits their integration to the demand-driven slicing approaches. Program slicing based on Predicate Code Block (PCB) is a new demand-driven slicing approach that can address only structured programs. This paper presents the first demand-driven technique to compute the control dependencies in unstructured programs. In this regard, the technique uses flow information, location-based information and syntactic structure of the source code. Further, the paper shows how the new technique can be integrated to the PCB-based slicing approach to address unstructured programs.

  • 5.
    Lisper, Björn
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Masud, Abu Naser
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Khanfar, Husni
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Static Backward Demand-Driven Slicing2015In: PEPM '15 Proceedings of the 2015 Workshop on Partial Evaluation and Program Manipulation, 2015, p. 115-126Conference paper (Refereed)
    Abstract [en]

    Program slicing identifies the program parts that may affect certain properties of the program, such as the outcomes of conditions affecting the program flow. Ottenstein’s Program Dependence Graph (PDG) based algorithm is the state-of-practice for static slicing today: it is well-suited in applications where many slices are computed, since the cost of building the PDG then can be amortized over the slices. But there are applications that require few slices of a given program, and where computing all the dependencies may be unnecessary. We present a light-weight interprocedural algorithm for backward static slicing where the data dependence analysis is done using a variant of the Strongly Live Variables (SLV) analysis. This allows us to avoid building the Data Dependence Graph, and to slice program statements “on-the-fly” during the SLV analysis which is potentially faster for computing few slices. Furthermore we use an abstract interpretation-based value analysis to extend our slicing algorithm to slice low-level code, where data dependencies are not evident due to dynamically calculated addresses. Our algorithm computes slices as sets of Control Flow Graph nodes: we show how to adapt existing techniques to generate executable slices that correspond to semantically correct code, where jump statements have been inserted at appropriate places. We have implemented our slicing algorithms, and made an experimental evaluation comparing them with the standard PDG-based algorithm for a number of example programs. We obtain the same accuracy as for PDG-based slicing, sometimes with substantial improvements in performance.

1 - 5 of 5
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf