8 research outputs found

    Implementing Order Relations on Graphs

    No full text
    The design of automatic verification methods for programs manipulating dynamic data structures is a challenging problem. We consider programs that operate on a data structures with one next-pointer, such as singly linked lists and circular lists. We refer to such data structures as heaps. We represent a heap as a graph, where vertices in the graph represent cells in the heap. To test that a program is safe, we should check that the out put of this program is well formed and is sorted. The aim of this project is to design a number of algorithms to test the different orderings between graphs which arise when including heaps. More precisely, given two graphs, G1 and G2, we check that G1 can be included in G2, using different type of orderings

    Automated Analysis of Data-Dependent Programs with Dynamic Memory

    Get PDF
    We present a new approach for automatic verification of data-dependent programs manipulating dynamic heaps. A heap is encoded by a graph where the nodes represent the cells, and the edges reflect the pointer structure between the cells of the heap. Each cell contains a set of variables which range over the natural numbers. Our method relies on standard backward reachability analysis, where the main idea is to use a simple set of predicates, called signatures, in order to represent bad sets of heaps. Examples of bad heaps are those which contain either garbage, lists which are not well-formed, or lists which are not sorted. We present the results for the case of programs with a single next-selector, and where variables may be compared for (in)equality. This allows us to verify for instance that a program, like bubble sort or insertion sort, returns a list which is well-formed and sorted, or that the merging of two sorted lists is a new sorted list. We report on the result of running a prototype based on the method on a number of programs
    corecore