Resource usage analysis

It is an important criterion of program correctness that a program accesses resources in a valid manner. For example, a memory region that has been allocated should be eventually deallocated, and after the deallocation, the region should no longer be accessed. A file that has been opened should be eventually closed. So far, most of the methods to analyze this kind of property have been proposed in rather specific contexts (like studies of memory management and verification of usage of lock primitives), and it was not so clear what is the essence of those methods or how methods proposed for individual problems are related. To remedy this situation, we formalize a general problem of analyzing resource usage as a resource usage analysis problem, and propose a type-based method as a solution to the problem.

[1]  Sorin Lerner.  Path-Sensitive Program Veri cation in Polynomial Time , 2002 .

[2]  Naoki Kobayashi,et al.  A Generalized Deadlock-Free Process Calculus , 1998, Electron. Notes Theor. Comput. Sci..

[3]  David Walker,et al.  On regions and linear types (extended abstract) , 2001, ICFP '01.

[4]  Flemming Nielson,et al.  Principles of Program Analysis , 1999, Springer Berlin Heidelberg.

[5]  Jakob Rehof,et al.  Tractable Constraints in Finite Semilattices , 1999, Sci. Comput. Program..

[6]  Atsushi Igarashi,et al.  A generic type system for the Pi-calculus , 2001, POPL '01.

[7]  Atsushi Igarashi,et al.  Type Reconstruction for Linear -Calculus with I/O Subtyping , 2000, Inf. Comput..

[8]  Futoshi Iwama,et al.  A new type system for JVM lock primitives , 2002, ASIA-PEPM.

[9]  Matthias Felleisen,et al.  Abstract models of memory management , 1995, FPCA '95.

[10]  Bruno Blanchet,et al.  Escape analysis: correctness proof, implementation and experimental results , 1998, POPL '98.

[11]  Mark Lillibridge,et al.  Extended static checking for Java , 2002, PLDI '02.

[12]  E. Allen Emerson,et al.  Temporal and Modal Logic , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[13]  Sriram K. Rajamani,et al.  The SLAM project: debugging system software via static analysis , 2002, POPL '02.

[14]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[15]  Martín Abadi,et al.  Object Types against Races , 1999, CONCUR.

[16]  Thomas A. Henzinger,et al.  Lazy abstraction , 2002, POPL '02.

[17]  Philip Wadler,et al.  Linear Types can Change the World! , 1990, Programming Concepts and Methods.

[18]  Martín Abadi,et al.  Types for Safe Locking , 1999, ESOP.

[19]  Harry G. Mairson,et al.  Unification and ML-Type Reconstruction , 1991, Computational Logic - Essays in Honor of Alan Robinson.

[20]  Jay L. Gischer.  Shuffle languages, Petri nets, and context-sensitive grammars , 1981, CACM.

[21]  Sorin Lerner,et al.  ESP: path-sensitive program verification in polynomial time , 2002, PLDI '02.

[22]  Philip Wadler,et al.  Once upon a type , 1995, FPCA '95.

[23]  Simon L. Peyton Jones,et al.  Once upon a polymorphic type , 1999, POPL '99.

[24]  John Hannan,et al.  A Type-based Analysis for Stack Allocation in Functional Languages , 1995, SAS.

[25]  Naoki Kobayashi.  Quasi-linear types , 1999, POPL '99.

[26]  Alexander Aiken,et al.  Better static memory management: improving region-based analysis of higher-order languages , 1995, PLDI '95.

[27]  Naoki Kobayashi,et al.  Type Systems for Concurrent Processes: From Deadlock-Freedom to Livelock-Freedom, Time-Boundedness , 2000, IFIP TCS.

[28]  Naoki Kobayashi.  Type-Based Useless-Variable Elimination , 2001, High. Order Symb. Comput..

[29]  Josef Svenningsson,et al.  A Usage Analysis with Bounded Usage Polymorphism and Subtyping , 2000, IFL.

[30]  Mads Tofte,et al.  Implementation of the typed call-by-value λ-calculus using a stack of regions , 1994, POPL '94.

[31]  Joanna Jedrzejowicz,et al.  Shuffle languages are in P , 2001, Theor. Comput. Sci..

[32]  Lars Birkedal,et al.  From region inference to von Neumann machines via region representation inference , 1996, POPL '96.

[33]  Naoki Kobayashi,et al.  Garbage Collection Based on a Linear Type System , 2000 .

[34]  Alexander Aiken,et al.  Flow-sensitive type qualifiers , 2002, PLDI '02.

[35]  David Walker,et al.  Typed memory management via static capabilities , 2000, TOPL.

[36]  Futoshi Iwama,et al.  A New Type System for JVM Lock Primitives , 2002, ASIA-PEPM '02.

[37]  James Cheney,et al.  Region-based memory management in cyclone , 2002, PLDI '02.

[38]  Cosimo Laneve,et al.  A type system for JVM threads , 2003, Theor. Comput. Sci..

[39]  Davide Sangiorgi,et al.  The Pi-Calculus - a theory of mobile processes , 2001 .

[40]  Shin Saito,et al.  An Implicitly-Typed Deadlock-Free Process Calculus , 2000, CONCUR.

[41]  Naoki Kobayashi.  Time regions and effects for resource usage analysis , 2003, TLDI '03.

[42]  Robert DeLine,et al.  Enforcing high-level protocols in low-level software , 2001, PLDI '01.

[43]  Jean-Yves Girard,et al.  Linear Logic , 1987, Theor. Comput. Sci..

[44]  Robert DeLine,et al.  Adoption and focus: practical linear types for imperative programming , 2002, PLDI '02.