An Inference Algorithm for Guaranteeing Safe Destruction

Montenegro, Manuel; Peña, Ricardo; Segura, Clara

doi:10.1007/978-3-642-00515-2_10

Cited by 9 publications

(8 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…However, all three approaches require the programmer to provide explicit size information, that is checked rather than inferred. Finally, a combination of sized types with memory regions has been suggested by Peña and Segura [22], building on information provided by ancillary analyses on termination and safe destruction [23]. However, this does not deal with co-recursive costs.…”

Section: Soundness Of the Proof Systemmentioning

confidence: 99%

Type-Based Allocation Analysis for Co-recursion in Lazy Functional Languages

Vasconcelos

Jost

Florido

et al. 2015

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. This paper presents a novel type-and-effect analysis for predicting upper-bounds on memory allocation costs for co-recursive definitions in a simple lazily-evaluated functional language. We show the soundness of this system against an instrumented variant of Launchbury's semantics for lazy evaluation which serves as a formal cost model. Our soundness proof requires an intermediate semantics employing indirections. Our proof of correspondence between these semantics that we provide is thus a crucial part of this work. The analysis has been implemented as an automatic inference system. We demonstrate its effectiveness using several example programs that previously could not be automatically analysed.

show abstract

Section: Soundness Of the Proof Systemmentioning

confidence: 99%

Type-Based Allocation Analysis for Co-recursion in Lazy Functional Languages

Vasconcelos

Jost

Florido

et al. 2015

Programming Languages and Systems

View full text Add to dashboard Cite

show abstract

“…is true for r-marked types, while function danger (t) attaches a mark r to a safe type t. For a complete description, see [11]. An inference algorithm for this type system has been developed in [12].…”

Section: Safe Type Systemmentioning

confidence: 99%

“…In [11] we made a detailed comparison with those works showing that our system accepts as safe some programs that their system rejects. Another difference is that we have developed a type inference algorithm [12] which they lack.…”

Section: Related Work and Conclusionmentioning

confidence: 99%

“…Our functional language Safe, described below, is equipped with type-based analyses for inferring regions where data structures are located [13], and for detecting when a program with explicit deallocation actions is free of dangling pointers [12]. One may wonder why a functional language with explicit deallocation may be useful and why not using a more conventional one such as e.g.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Certified Absence of Dangling Pointers in a Language with Explicit Deallocation

Dios

Montenegro

Peña

2010

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

Abstract. Safe is a first-order eager functional language with facilities for programmer controlled destruction of data structures. It provides also regions, i.e. disjoint parts of the heap, where the program allocates data structures, so that the runtime system does not need a garbage collector. A region is a collection of cells, each one big enough to allocate a data constructor. Deallocating cells or regions may create dangling pointers. The language is aimed at inferring and certifying memory safety properties in a Proof Carrying Code like environment. Some of its analyses have been presented elsewhere. The one relevant to this paper is a type system and a type inference algorithm guaranteeing that well-typed programs will be free of dangling pointers at runtime. Here we present how to generate formal certificates about the absence of dangling pointers property inferred by the compiler. The certificates are Isabelle/HOL proof scripts which can be proof-checked by this tool when loaded with a database of previously proved theorems. The key idea is proving an Isabelle/HOL theorem for each syntactic construction of the language, relating the static types inferred by the compiler to the dynamic properties about the heap that will be satisfied at runtime.

show abstract

“…The Safe language and a sharing analysis for it were published in [11]. We also defined a type system and a type inference algorithm [10,9] guaranteeing that destruction facilities and region management are done in a safe way.…”

Section: Introductionmentioning

confidence: 99%

A Resource-Aware Semantics and Abstract Machine for a Functional Language with Explicit Deallocation

Montenegro

Peòa

Segura

2009

Electronic Notes in Theoretical Computer Science

Self Cite

View full text Add to dashboard Cite

Safe is a first-order eager language with heap regions and unusual facilities such as programmer-controlled destruction and copying of data structures. The regions are disjoint parts of the heap where the compiler may allocate data structures. Thanks to regions, a runtime garbage collector is not needed. The language and its associated type system, guaranteeing that destruction facilities and region management are done in a safe way, have been presented previously. In this paper, we start from a high-level big-step operational semantics for Safe, and in a series of semiformal steps we derive its compilation to an imperative language and imperative abstract machine. Once the memory needs of the machine are known, we enrich the semantics with memory consumption annotations and prove that the enriched semantics is correct with respect to the translation and the abstract machine. All the steps are derived in such a way that it is easy to understand the translation and to formally establish its correctness.

show abstract

An Inference Algorithm for Guaranteeing Safe Destruction

Cited by 9 publications

References 11 publications

Type-Based Allocation Analysis for Co-recursion in Lazy Functional Languages

Type-Based Allocation Analysis for Co-recursion in Lazy Functional Languages

Certified Absence of Dangling Pointers in a Language with Explicit Deallocation

A Resource-Aware Semantics and Abstract Machine for a Functional Language with Explicit Deallocation

Contact Info

Product

Resources

About