Log in

Relevant bibliographies by topics / Heap-manipulating programs / Journal articles

To see the other types of publications on this topic, follow the link: Heap-manipulating programs.

Journal articles on the topic 'Heap-manipulating programs'

Author: Grafiati

Published: 28 June 2021

Last updated: 1 February 2022

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 18 journal articles for your research on the topic 'Heap-manipulating programs.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

Kostyukov, Yu O., K. A. Batoev, D. A. Mordvinov, M. P. Kostitsyn, and A. V. Misonizhnik. "Automatic verification of heap-manipulating programs." Proceedings of the Institute for System Programming of the RAS 31, no. 5 (2019): 37–62. http://dx.doi.org/10.15514/ispras-2019-31(5)-3.

Full text

APA, Harvard, Vancouver, ISO, and other styles

2

Watanabe, Yasunari, Kiran Gopinathan, George Pîrlea, Nadia Polikarpova, and Ilya Sergey. "Certifying the synthesis of heap-manipulating programs." Proceedings of the ACM on Programming Languages 5, ICFP (August 22, 2021): 1–29. http://dx.doi.org/10.1145/3473589.

Full text

Abstract:

Automated deductive program synthesis promises to generate executable programs from concise specifications, along with proofs of correctness that can be independently verified using third-party tools. However, an attempt to exercise this promise using existing proof-certification frameworks reveals significant discrepancies in how proof derivations are structured for two different purposes: program synthesis and program verification. These discrepancies make it difficult to use certified verifiers to validate synthesis results, forcing one to write an ad-hoc translation procedure from synthesis proofs to correctness proofs for each verification backend. In this work, we address this challenge in the context of the synthesis and verification of heap-manipulating programs. We present a technique for principled translation of deductive synthesis derivations (a.k.a. source proofs) into deductive target proofs about the synthesised programs in the logics of interactive program verifiers. We showcase our technique by implementing three different certifiers for programs generated via SuSLik, a Separation Logic-based tool for automated synthesis of programs with pointers, in foundational verification frameworks embedded in Coq: Hoare Type Theory (HTT), Iris, and Verified Software Toolchain (VST), producing concise and efficient machine-checkable proofs for characteristic synthesis benchmarks.

APA, Harvard, Vancouver, ISO, and other styles

3

Polikarpova, Nadia, and Ilya Sergey. "Structuring the synthesis of heap-manipulating programs." Proceedings of the ACM on Programming Languages 3, POPL (January 2, 2019): 1–30. http://dx.doi.org/10.1145/3290385.

Full text

APA, Harvard, Vancouver, ISO, and other styles

4

Magill, Stephen, Ming-Hsien Tsai, Peter Lee, and Yih-Kuen Tsay. "Automatic numeric abstractions for heap-manipulating programs." ACM SIGPLAN Notices 45, no. 1 (January 2, 2010): 211–22. http://dx.doi.org/10.1145/1707801.1706326.

Full text

APA, Harvard, Vancouver, ISO, and other styles

5

Nanevski, Aleksandar, Viktor Vafeiadis, and Josh Berdine. "Structuring the verification of heap-manipulating programs." ACM SIGPLAN Notices 45, no. 1 (January 2, 2010): 261–74. http://dx.doi.org/10.1145/1707801.1706331.

Full text

APA, Harvard, Vancouver, ISO, and other styles

6

Winterstein, Felix, Kermin E. Fleming, Hsin-Jung Yang, and George A. Constantinides. "Custom Multicache Architectures for Heap Manipulating Programs." IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 36, no. 5 (May 2017): 761–74. http://dx.doi.org/10.1109/tcad.2016.2608861.

Full text

APA, Harvard, Vancouver, ISO, and other styles

7

ALBERT, ELVIRA, MARÍA GARCÍA DE LA BANDA, MIGUEL GÓMEZ-ZAMALLOA, JOSÉ MIGUEL ROJAS, and PETER STUCKEY. "A CLP heap solver for test case generation." Theory and Practice of Logic Programming 13, no. 4-5 (July 2013): 721–35. http://dx.doi.org/10.1017/s1471068413000458.

Full text

Abstract:

AbstractOne of the main challenges to software testing today is to efficiently handle heap-manipulating programs. These programs often build complex, dynamically allocated data structures during execution and, to ensure reliability, the testing process needs to consider all possible shapes these data structures can take. This creates scalability issues since high (often exponential) numbers of shapes may be built due to the aliasing of references. This paper presents a novel CLP heap solver for the test case generation of heap-manipulating programs that is more scalable than previous proposals, thanks to the treatment of reference aliasing by means of disjunction, and to the use of advanced back-propagation of heap related constraints. In addition, the heap solver supports the use of heap assumptions to avoid aliasing of data that, though legal, should not be provided as input.

APA, Harvard, Vancouver, ISO, and other styles

8

Qin, Shengchao, Guanhua He, Chenguang Luo, Wei-Ngan Chin, and Hongli Yang. "Automatically refining partial specifications for heap-manipulating programs." Science of Computer Programming 82 (March 2014): 56–76. http://dx.doi.org/10.1016/j.scico.2013.03.004.

Full text

APA, Harvard, Vancouver, ISO, and other styles

9

Yahav, Eran, and Mooly Sagiv. "Verifying safety properties of concurrent heap-manipulating programs." ACM Transactions on Programming Languages and Systems 32, no. 5 (May 2010): 1–50. http://dx.doi.org/10.1145/1745312.1745315.

Full text

APA, Harvard, Vancouver, ISO, and other styles

10

Yorsh, Greta, Alexey Skidanov, Thomas Reps, and Mooly Sagiv. "Automatic Assume/Guarantee Reasoning for Heap-Manipulating Programs." Electronic Notes in Theoretical Computer Science 131 (May 2005): 125–38. http://dx.doi.org/10.1016/j.entcs.2005.01.028.

Full text

APA, Harvard, Vancouver, ISO, and other styles

11

Mathur, Umang, Adithya Murali, Paul Krogmeier, P. Madhusudan, and Mahesh Viswanathan. "Deciding memory safety for single-pass heap-manipulating programs." Proceedings of the ACM on Programming Languages 4, POPL (January 2020): 1–29. http://dx.doi.org/10.1145/3371103.

Full text

APA, Harvard, Vancouver, ISO, and other styles

12

Dillig, Isil, Thomas Dillig, Alex Aiken, and Mooly Sagiv. "Precise and compact modular procedure summaries for heap manipulating programs." ACM SIGPLAN Notices 47, no. 6 (August 6, 2012): 567. http://dx.doi.org/10.1145/2345156.1993565.

Full text

APA, Harvard, Vancouver, ISO, and other styles

13

Dillig, Isil, Thomas Dillig, Alex Aiken, and Mooly Sagiv. "Precise and compact modular procedure summaries for heap manipulating programs." ACM SIGPLAN Notices 46, no. 6 (June 4, 2011): 567–77. http://dx.doi.org/10.1145/1993316.1993565.

Full text

APA, Harvard, Vancouver, ISO, and other styles

14

DUCK, GREGORY J., JOXAN JAFFAR, and ROLAND H. C. YAP. "Shape Neutral Analysis of Graph-based Data-structures." Theory and Practice of Logic Programming 18, no. 3-4 (July 2018): 470–83. http://dx.doi.org/10.1017/s147106841800025x.

Full text

Abstract:

AbstractMalformed data-structures can lead to runtime errors such as arbitrary memory access or corruption. Despite this, reasoning over data-structure properties for low-level heap manipulating programs remains challenging. In this paper we present a constraint-based program analysis that checks data-structure integrity, w.r.t. given target data-structure properties, as the heap is manipulated by the program. Our approach is to automatically generate a solver for properties using the type definitions from the target program. The generated solver is implemented using a Constraint Handling Rules (CHR) extension of built-in heap, integer and equality solvers. A key property of our program analysis is that the target data-structure properties are shape neutral, i.e., the analysis does not check for properties relating to a given data-structure graph shape, such as doubly-linked-lists versus trees. Nevertheless, the analysis can detect errors in a wide range of data-structure manipulating programs, including those that use lists, trees, DAGs, graphs, etc. We present an implementation that uses the Satisfiability Modulo Constraint Handling Rules (SMCHR) system. Experimental results show that our approach works well for real-world C programs.

APA, Harvard, Vancouver, ISO, and other styles

15

Abdulla, Parosh Aziz, Lukáš Holík, Bengt Jonsson, Ondřej Lengál, Cong Quy Trinh, and Tomáš Vojnar. "Verification of heap manipulating programs with ordered data by extended forest automata." Acta Informatica 53, no. 4 (May 7, 2015): 357–85. http://dx.doi.org/10.1007/s00236-015-0235-0.

Full text

APA, Harvard, Vancouver, ISO, and other styles

16

Li, Renjian, Ji Wang, Liqian Chen, Wanwei Liu, and Dengping Wei. "Quantitative analysis for symbolic heap bounds of CPS software." Computer Science and Information Systems 8, no. 4 (2011): 1251–76. http://dx.doi.org/10.2298/csis110302054l.

Full text

Abstract:

One important quantitative property of CPS (Cyber-Physical Systems) software is its heap bound for which a precise analysis result needs to combine shape analysis and numeric reasoning. In this paper, we present a framework for statically finding symbolic heap bounds of CPS software. The basic idea is to separate numeric reasoning from shape analysis by first constructing an ASTG (Abstract State Transition Graph) and then extracting a pure numeric representation which can be analyzed for the heap bounds. A quantitative shape analysis method based on symbolic execution is defined in the framework to generate the ASTG. The numeric representation is extracted based on program slicing technique and inputted into an abstract interpretation tool for computing the heap bounds. We take list manipulating programs as an example to explain how to instantiate the framework for important data structures and to exhibit its practicability. A novel list abstraction method is also presented to support the instantiation of the framework.

APA, Harvard, Vancouver, ISO, and other styles

17

Atto, Muhsin H. "Graph Inclusion and Matching Algorithms for Programs Manipulating Singly linked Heaps." Science Journal of University of Zakho 9, no. 1 (March 30, 2021): 30–37. http://dx.doi.org/10.25271/sjuoz.2021.9.1.778.

Full text

Abstract:

Programs that manipulate heaps such as singlylinked lists, doublylinked lists, skiplists, and treesare ubiquitous, and hence ensuring their correctness is of utmost importance. Analysing correctness properties for such programs is not trivial since they induce dynamic data structures, leading to unbounded state spaces with intricate patterns. One approach that has been adopted to tackle this problem is the use of symbolic searching techniques. The state space is encoded using graphs where the nodes represent memory cells, and the edges represent pointers between the cells. It is necessary to prune the search to avoid generating massive numbers of graphs, thus making the procedure unpractical. Pruning strategies are defined based on operations such as graph matching and inclusion. In this paper, a set of algorithms for performing these operations are presented. It is demonstrated that the proposed algorithms can handle typical graphs that arise in the verification of heap manipulating programs.

APA, Harvard, Vancouver, ISO, and other styles

18

HOFFMANN, JAN, and ZHONG SHAO. "Type-based amortized resource analysis with integers and arrays." Journal of Functional Programming 25 (2015). http://dx.doi.org/10.1017/s0956796815000192.

Full text

Abstract:

AbstractProving bounds on the resource consumption of a program by statically analyzing its source code is an important and well-studied problem. Automatic approaches for numeric programs with side effects usually apply abstract interpretation-based invariant generation to derive bounds on loops and recursion depths of function calls. This article presents an alternative approach to resource-bound analysis for numeric and heap-manipulating programs that uses type-based amortized resource analysis. As a first step towards the analysis of imperative code, the technique is developed for a first-order ML-like language with unsigned integers and arrays. The analysis automatically derives bounds that are multivariate polynomials in the numbers and the lengths of the arrays in the input. Experiments with example programs demonstrate two main advantages of amortized analysis over current abstract interpretation–based techniques. For one thing, amortized analysis can handle programs with non-linear intermediate values like f((n + m)2). For another thing, amortized analysis is compositional and works naturally for compound programs like f(g(x)).

APA, Harvard, Vancouver, ISO, and other styles

We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!