Thematische Bibliographien / Heap-manipulating programs / Zeitschriftenartikel
Um die anderen Arten von Veröffentlichungen zu diesem Thema anzuzeigen, folgen Sie diesem Link: Heap-manipulating programs.

Zeitschriftenartikel zum Thema „Heap-manipulating programs“

Autor: Grafiati
Veröffentlicht am 28. Juni 2021
Zuletzt aktualisiert am 1. Februar 2022

Geben Sie eine Quelle nach APA, MLA, Chicago, Harvard und anderen Zitierweisen an

Wählen Sie eine Art der Quelle aus:

Machen Sie sich mit Top-18 Zeitschriftenartikel für die Forschung zum Thema "Heap-manipulating programs" bekannt.

Neben jedem Werk im Literaturverzeichnis ist die Option "Zur Bibliographie hinzufügen" verfügbar. Nutzen Sie sie, wird Ihre bibliographische Angabe des gewählten Werkes nach der nötigen Zitierweise (APA, MLA, Harvard, Chicago, Vancouver usw.) automatisch gestaltet.

Sie können auch den vollen Text der wissenschaftlichen Publikation im PDF-Format herunterladen und eine Online-Annotation der Arbeit lesen, wenn die relevanten Parameter in den Metadaten verfügbar sind.

Sehen Sie die Zeitschriftenartikel für verschiedene Spezialgebieten durch und erstellen Sie Ihre Bibliographie auf korrekte Weise.

1

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

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
2

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

Der volle Inhalt der Quelle
Annotation:
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 und andere Zitierweisen
3

Polikarpova, Nadia, und Ilya Sergey. „Structuring the synthesis of heap-manipulating programs“. Proceedings of the ACM on Programming Languages 3, POPL (02.01.2019): 1–30. http://dx.doi.org/10.1145/3290385.

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
4

Magill, Stephen, Ming-Hsien Tsai, Peter Lee und Yih-Kuen Tsay. „Automatic numeric abstractions for heap-manipulating programs“. ACM SIGPLAN Notices 45, Nr. 1 (02.01.2010): 211–22. http://dx.doi.org/10.1145/1707801.1706326.

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
5

Nanevski, Aleksandar, Viktor Vafeiadis und Josh Berdine. „Structuring the verification of heap-manipulating programs“. ACM SIGPLAN Notices 45, Nr. 1 (02.01.2010): 261–74. http://dx.doi.org/10.1145/1707801.1706331.

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
6

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

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
7

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

Der volle Inhalt der Quelle
Annotation:
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 und andere Zitierweisen
8

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

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
9

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

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
10

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

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
11

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

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
12

Dillig, Isil, Thomas Dillig, Alex Aiken und Mooly Sagiv. „Precise and compact modular procedure summaries for heap manipulating programs“. ACM SIGPLAN Notices 47, Nr. 6 (06.08.2012): 567. http://dx.doi.org/10.1145/2345156.1993565.

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
13

Dillig, Isil, Thomas Dillig, Alex Aiken und Mooly Sagiv. „Precise and compact modular procedure summaries for heap manipulating programs“. ACM SIGPLAN Notices 46, Nr. 6 (04.06.2011): 567–77. http://dx.doi.org/10.1145/1993316.1993565.

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
14

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

Der volle Inhalt der Quelle
Annotation:
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 und andere Zitierweisen
15

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

Der volle Inhalt der Quelle
APA, Harvard, Vancouver, ISO und andere Zitierweisen
16

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

Der volle Inhalt der Quelle
Annotation:
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 und andere Zitierweisen
17

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

Der volle Inhalt der Quelle
Annotation:
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 und andere Zitierweisen
18

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

Der volle Inhalt der Quelle
Annotation:
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 und andere Zitierweisen
Wir bieten Rabatte auf alle Premium-Pläne für Autoren, deren Werke in thematische Literatursammlungen aufgenommen wurden. Kontaktieren Sie uns, um einen einzigartigen Promo-Code zu erhalten!

Zur Bibliographie