Compiling polymorphism using intensional type analysis
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Cache-conscious structure definition
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Dynamic typing for distributed programming in polymorphic languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
Principles of Program Analysis
Principles of Program Analysis
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
Intensional polymorphism in type-erasure semantics
Journal of Functional Programming
Cost and precision tradeoffs of dynamic data slicing algorithms
ACM Transactions on Programming Languages and Systems (TOPLAS)
Splay trees, Davenport-Schinzel sequences, and the deque conjecture
Proceedings of the nineteenth annual ACM-SIAM symposium on Discrete algorithms
A control-structure splitting optimization for GPGPU
Proceedings of the 6th ACM conference on Computing frontiers
Proceedings of the eighteenth international symposium on Software testing and analysis
Priestley Duality for Strong Proximity Lattices
Electronic Notes in Theoretical Computer Science (ENTCS)
A trajectory-based strict semantics for program slicing
Theoretical Computer Science
Parallel program performance modeling for runtime optimization of multi-algorithm circuit simulation
Proceedings of the 47th Design Automation Conference
Flow sensitive-insensitive pointer analysis based memory safety for multithreaded programs
ICCSA'11 Proceedings of the 2011 international conference on Computational science and Its applications - Volume Part V
Data slicing: separating the heap into independent regions
CC'05 Proceedings of the 14th international conference on Compiler Construction
Analysis of bug fixing processes using program slicing metrics
PROFES'10 Proceedings of the 11th international conference on Product-Focused Software Process Improvement
Proof-Carrying code in a session-typed process calculus
CPP'11 Proceedings of the First international conference on Certified Programs and Proofs
IEEE Transactions on Software Engineering
| Hi-index | 0.00 |
Using type systems, this paper treats heap slicing which is a technique transforming a program into a new one that produces the same result while working on a heap sliced into independent regions. Heap slicing is a common approach to handle the problem of modifying the heap layout without changing the program semantics. Heap slicing has applications in the areas of performance optimization and security. Towards solving the problem of heap slicing, this paper introduces three type systems. The first type system does a pointer analysis and annotates program points with pointer information. This type system is an augmentation of a previously developed type system by the author. The second type system does a region analysis and refines the result of the first type system by augmenting the pointer information with region information. The region information approximately specifies at each program point for each memory cell the region where the cell exists. The third type system uses the information gathered by the region type system to do the principal transformation of heap slicing. The paper also presents two operational semantics; one for single-region heap scenario and the other for multi-regions heap scenario. These semantics are used to prove the soundness of the type systems.