Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 2,344 papers for “recursive data structures”

Recursive Assertions for Data Structures

2008

We present an assertion language for expressing properties of data structures. Its key features are constraints over arrays, multisets and integers which allow the specification of basic assertions, and rules, which allow the recursive specification of assertions. This language can thus be used to define assertions to an arbitrary level of expressiveness, ranging from low-level properties of memory allocation, for example, to abstract properties of complex data structures such as AVL trees. The main result is a proof method for verification conditions arising from a program annotated with assertions. The method has two main components. First and foremost is an unfolding algorithm which works by reducing the recursive definitions so that a constraint proof may now be applied. Here we introduce a notion of coinduction which forms the basis for termination of the unfolding process. The second step is to reduce the constraints, which in general contain expressions involving all the three data types of integers, arrays and multisets, into a base constraint involving only integer constraints. Base constraints can then be dispensed with available solvers. We finally show via a small benchmark of classic examples that our proof method is practical. 1.

Cited by 0

Data Flow Analysis of Recursive Structures

Albert Cohen, Jean-François Collard⋆, Martin Griebl · HAL (Le Centre pour la Communication Scientifique Directe) · 1996

. Most imperative languages only offer arrays as "first-class" data structures. Other data structures, especially recursive data structures such as trees, have to be manipulated using explicit control of memory, i.e., through pointers to explicitly allocated portions of memory. We believe that this severe limitation is mainly due to historical reasons, and this paper will try and demonstrate that modern analysis techniques, such as data flow analysis, allow to cope with the compilation problems associated with recursive data structures. As a matter of fact, recursion in the flow of control also is a current open issue in automatic parallelization: to our knowledge, no theory allows the parallelization of, e.g., recursive Pascal programs. This paper uniformly handles both issues. We propose a kernel language that manipulates recursive data structures in an elegant, algebraic way. In this preliminary work, both data- and control- recursive structures are restricted, so that a data flow a...

Cited by 0Open access

Parallelizing programs with recursive data structures

Laurie Hendren, Alexandru Nicolau · IEEE Transactions on Parallel and Distributed Systems · 1990

A study is made of the problem of estimating interference in an imperative language with dynamic data structures. The authors focus on developing efficient and implementable methods for recursive data structures. In particular, they present interference analysis tools and parallelization techniques for imperative programs that contain dynamically updatable trees and directed acyclic graphs. The analysis methods are based on a regular-expression-like representation of the relationship between accessible nodes in the data structure. They authors have implemented their analysis, and they present some concrete examples that have been processed by this system.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Cited by 10

Abstractions for recursive pointer data structures

Laurie Hendren, Joseph Hummell, Alexandru Nicolau · 1992

Even though impressive progress has been made in the area of optimizing and parallelizing programs with arrays, the application of similar techniques to programs with pointer data structures has remained difficult. In this paper we introduce a new approach that leads to improved analysis and transformation of programs with recursively-defined pointer data structures.We discuss how an abstract data structure description can improve program analysis by presenting an analysis approach that combines an alias analysis technique, path matrix, with information available from an ADDS declaration. Given this improved alias analysis technique, we provide a concrete example of applying a software pipelining transformation to loops involving pointer data structures.

Cited by 101

Gradual verification of recursive heap data structures

Jenna Wise, Johannes Bader, Cameron Wong et al. · Proceedings of the ACM on Programming Languages · 2020

Current static verification techniques do not provide good support for incrementality, making it difficult for developers to focus on specifying and verifying the properties and components that are most important. Dynamic verification approaches support incrementality, but cannot provide static guarantees. To bridge this gap, prior work proposed gradual verification, which supports incrementality by allowing every assertion to be complete, partial, or omitted, and provides sound verification that smoothly scales from dynamic to static checking. The prior approach to gradual verification, however, was limited to programs without recursive data structures. This paper extends gradual verification to programs that manipulate recursive, mutable data structures on the heap. We address several technical challenges, such as semantically connecting iso- and equi-recursive interpretations of abstract predicates, and supporting gradual verification of heap ownership. This work thus lays the foundation for future tools that work on realistic programs and support verification within an engineering process in which cost-benefit trade-offs can be made.

Cited by 12Open access

I/O prefetching for recursive data structures

Farah Farzana · TSpace · 2004

Out-of-core applications that manipulate data too large to fit entirely in memory, tend to waste a large percentage of their execution times waiting for disk requests to complete. We can hide disk latency from these applications by taking advantage of under-utilized I/O resources to perform prefetching. However, while I/O prefetching has proven to be quite successful in array-based numeric codes; its applicability in pointer-based codes has not been explored. In this thesis, we explore the potential of applying the concepts of cache prefetching for pointer-based applications to prefetch items from the disk to memory. We also propose a new data structure for prefetching the elements of linked lists that can effectively reduce the run-time at the expense of some extra space when there are frequent updates to the list. Experimental results demonstrate that our technique is able to outperform previous techniques when there are significant changes to the list.

Cited by 0Open access

Compressed Data Structures for Recursive Flow Classification

Edward W. Spitznagel · Open Scholarship Institutional Repository (Washington University in St. Louis) · 2003

High-speed packet classification is crucial to the implementation of several advanced network services and protocols; many QoS implementations, active networking platforms, and security devices (such as firewalls and intrusion-detection systems) require it. But performing classification on multiple fields, at the speed of modern networks, is known to be a difficult problem. The Recursive Flow Classification (RFC) algorithm described by Gupta and McKeown performs classification very quickly, but can require excessive storage when using thousands of rules. This paper studies a compressed representation for the tables used in RFC, trading some memory accesses for space. The compression’s efficiency can be improved by rear-ranging rows and columns of the tables. Finding a near-optimal rearrangement can be transformed into a Traveling Salesman Problem in which certain approximation algorithms can be used. Also, in evaluating the compressed representation of tables, we study the effects of choosing different reduction trees in RFC. We evaluate these methods using a real-world filter database with 159 rules. Results show a reduction in the size of the cross product tables by 61.6% in the median case; in some cases their size is reduced by 87% or more. Furthermore, experimental evidence suggests larger databases may be more compressible.

Cited by 12Open access

Gradual Verification of Recursive Heap Data Structures

Wise, Jenna, Bader, Johannes, Wong, Cameron et al. · Zenodo (CERN European Organization for Nuclear Research) · 2020

<pre>Current static verification techniques do not provide good support for incrementality, making it difficult for developers to focus on specifying and verifying the properties and components that are most important. Dynamic verification approaches support incrementality, but cannot provide static guarantees. To bridge this gap, prior work proposed gradual verification, which supports incrementality by allowing every assertion to be complete, partial, or omitted, and provides sound verification that smoothly scales from dynamic to static checking. The prior approach to gradual verification, however, was limited to programs without recursive data structures. This paper extends gradual verification to programs that manipulate recursive, mutable data structures on the heap. We address several technical challenges, such as semantically connecting iso- and equi-recursive interpretations of abstract predicates, and supporting gradual verification of heap ownership. This work thus lays the foundation for future tools that work on realistic programs and support verification within an engineering process in which cost-benefit trade-offs can be made.</pre>

Cited by 1Open access

Gradual Verification of Recursive Heap Data Structures

Jenna Wise, Johannes Bader, Cameron Wong et al. · Zenodo (CERN European Organization for Nuclear Research) · 2020

<pre>Current static verification techniques do not provide good support for incrementality, making it difficult for developers to focus on specifying and verifying the properties and components that are most important. Dynamic verification approaches support incrementality, but cannot provide static guarantees. To bridge this gap, prior work proposed gradual verification, which supports incrementality by allowing every assertion to be complete, partial, or omitted, and provides sound verification that smoothly scales from dynamic to static checking. The prior approach to gradual verification, however, was limited to programs without recursive data structures. This paper extends gradual verification to programs that manipulate recursive, mutable data structures on the heap. We address several technical challenges, such as semantically connecting iso- and equi-recursive interpretations of abstract predicates, and supporting gradual verification of heap ownership. This work thus lays the foundation for future tools that work on realistic programs and support verification within an engineering process in which cost-benefit trade-offs can be made.</pre>

Cited by 0Open access

Gradual Verification of Recursive Heap Data Structures

Jenna Wise, Johannes Bader, Cameron Wong et al. · Zenodo (CERN European Organization for Nuclear Research) · 2020

<pre>Current static verification techniques do not provide good support for incrementality, making it difficult for developers to focus on specifying and verifying the properties and components that are most important. Dynamic verification approaches support incrementality, but cannot provide static guarantees. To bridge this gap, prior work proposed gradual verification, which supports incrementality by allowing every assertion to be complete, partial, or omitted, and provides sound verification that smoothly scales from dynamic to static checking. The prior approach to gradual verification, however, was limited to programs without recursive data structures. This paper extends gradual verification to programs that manipulate recursive, mutable data structures on the heap. We address several technical challenges, such as semantically connecting iso- and equi-recursive interpretations of abstract predicates, and supporting gradual verification of heap ownership. This work thus lays the foundation for future tools that work on realistic programs and support verification within an engineering process in which cost-benefit trade-offs can be made.</pre>

Cited by 1Open access

Abstract Alias Types for Recursive Data Structures

2008

Linear type systems permit programmers to deallocate or explicitly recycle memory, but are severely restricted by the fact that they admit no aliasing. This paper describes a pseudo-linear type system that allows a degree of aliasing and memory reuse as well as the ability to de ne complex recursive data structures. Our type system can encode conventional linear data structures such as linear lists and trees as well as more sophisticated data structures including cyclic and doubly-linked lists and trees. In the latter cases, our type system is expressive enough to represent pointer aliasing and yet safely permit destructive operations such as object deallocation. We demonstrate the exibility ofour type system by encoding two common space-conscious algorithms: destination-passing style and Deutsch-Schorr-Waite or \\link-reversal &amp;amp;quot; traversal algorithms. 1

Cited by 0